[大数据]Elasticsearch

ElasticSearch封装了Lucene

启动ElasticSearch

下载解压elastic search

配置config/jvm.options

#设置堆内存大小
-Xms256m
-Xmx256m

配置config/elasticsearch.yml

#解决跨域问题
http.cors.enabled: true
http.cors.allow-origin: "*"

启动bin/elasticsearch.bat文件

localhost:9200

启动ElasticSearch-head

下载项目https://github.com/mobz/elasticsearch-head.git

执行命令npm install安装依赖

执行命令npm run start启动项目

localhost:9100

启动Kibana

下载解压kibana

启动bin/kinaba.bat文件

配置config/kibana.yml

#汉化
i18n.locale: "zh-CN"

localhost:5601

ElasticSearch相关概念

节点：一个ElasticSearch服务

集群：一个或多个节点的集合

索引：具有类似特性的文档的集合，相当于一个数据库

类型：索引内部的逻辑分区，相当于一张表

文档：以JSON格式存储字段

分片：并行搜索提高效率

副本：提高到了容灾性

IK分词器

下载项目https://github.com/medcl/elasticsearch-analysis-ik/releases

在elasticsearch/plugins下创建ik目录，ik路径上千万不要有空格

将项目放入ik目录

配置ik/config/IKAnalyzer.cfg.xml

<!--配置自己的词典my.dic-->
<entry key="ext_dict">my.dic</entry>

#分词设置
GET _analyze
{
  "analyzer": "ik_smart",
  "text": "这是一个测试"
}
GET  _analyze 
{
	"analyzer": "ik_max_word",
	"text": "这是一个测试"
}

Rest操作

#判断索引是否存在
HEAD /index

#elastic的版本信息
GET /

#查看索引信息
GET /index

#查看index中所有type类型的文档
GET /index/type/_search

#查看文档信息
GET /index/type/document

#新增文档
POST /index/type/document
{
	"name": "zhangsan",
	"age": "18"
}

#更新文档
PUT /index/type/document
{
	"name": "zhangsan",
	"age": "18"
}

#删除索引
DELETE /index

#删除文档
DELETE /index/type/document

复杂操作

#使用match查询
GET /index/type/_search
{
	"query": {"match": {"name": "zhangsan"}},
	"from": "1",
	"size": "1"
}

#and条件查询
GET /index/type/_search
{
	"query": {
		"bool": {
			"must": {
				{"match": {"name": "zhangsan"}},
				{"match": {"age": "18"}}
			}
		}
	}
}
#or条件查询
GET /index/type/_search
{
	"query": {
		"bool": {
			"should": {
				{"match": {"name": "zhangsan"}},
				{"match": {"age": "18"}}
			}
		}
	}
}

#创建索引中的规则，设置字段的类型和分词规则
PUT /index 
{
    "mapping": {
        "_doc": {
            "properties": {
                "name": {
                	#当字段类型是keyword的时候会将整个字段进行equal匹配
                    "type": "text",
                    "analyzer": "ik_smart",
                    "search_analyzer": "ik_smart"
                }
            }
        }
    }
}

#设置索引分片数为3，备份数为2
PUT /index
{
	"settings": {
		"index": {
			"number_of_shards": "3",
			"number_of_replicas": "2"
		}
	}
}

#指定查询列
GET /index/type/_search
{
	"query": {"match": {"name": "zhangsan"}},
	"_source": ["name", "age"]
}

#指定字段排序，排序只能是数值类型
GET /index/type/_search
{
	"query": {"match": {"name": "zhangsan"}},
	"sort": [
		{
			"age": { 
				"order": "desc"
			}
		}
	]
}

#过滤查询
GET /index/type/_search
{
	"must": {
    	{"match": {"name": "zhangsan"}},
    	{"match": {"age": "18"}}
    },
    "filter": {
    	"range": {
    		"age": {"lt": 5}
    	}
    }
}

#精确查询
GET /index/type/_search
{
	"query": {
		"term": {
			"name": "zhangsan"
		}
	}
}

match通过分词器解析后再对结果进行查询，term不会进行分词

#高亮查询，通过"pre_tags"和"post_tags"自定义标签
GET /index/type/document
{
	"query": {"match": {"name": "zhangsan"}},
	"highlight": {
		"pre_tags": "<b>",
		"post_tags": "</b>",
    	"fields": {
			"name": {}
		}
	}
}

Java客户端

导入依赖

<!--es客户端-->
<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
    <version>7.6.2</version>
</dependency>
<!--springboot的elasticsearch服务-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
    <version>7.6.2</version>
</dependency>

//配置Java客户端
@Configuration
public class ElasticSearchClientConfig {
    @Bean
    public RestHighLevelClient restHighLevelClient() {
        RestHighLevelClient client = new RestHighLevelClient(
            RestClient.builder(new HttpHost("127.0.0.1", 9200, "http")
        );
        return client;
    }
}

//创建索引请求
CreateIndexRequest request = new CreateIndexRequest("index");
//获得响应
CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT);

//判断索引是否存在
GetIndexRequest request = new GetIndexRequest("index");
boolean exist = client.indices().exists(request, RequestOption.DEFAULT);

//删除索引请求
DeleteIndexRequest request = new DeleteIndexRequest("index");
AcknowledgedResponse delete = client.indices().delete(request, RequestOption.DEFAULT);
Boolean result = delete.isAcknowledged();

//创建文档
IndexRequest request = new IndexRequest("index");
//文档名
request.id("document");
//设置超时时间
request.timeout("1s");
//将json传入request
request.source(JSON.toJSONString(domain), XContentType.JSON);
//发送请求获取response
IndexResponse response = client.index(request, RequestOptions.DEFAULT);
RestStatus result = response.status();

//判断文档是否存在
GetRequest request = new GetRequest("index");
request.id("document");
boolean exist = client.exists(request, RequestOptions.DEFAULT);

//获取文档
GetRequest request = new GetRequest("index", "document");
GetResponse response = client.get(request, RequestOptions.DEFAULT);
String content = response.getSourceAsString();

//修改文档
UpdateRequest request = new UpdateRequest("index", "document");
request.timeout("1s");
//将json传入request
request.doc(JSON.toJSONString(domain), XContentType.JSON);
//发送修改请求并获得response
UpdateResponse response = client.update(request, RequestOptions.DEFAULT);

//删除文档
DeleteRequest request = new DeleteRequest("index", "document");
request.timeout("1s");
DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);

//批量添加文档
BulkRequest request = new BulkRequest();
request.timeout("1s");
for(Domain domain: domainList) {
    reuqest.add(
    	new IndexRequest("index")
        	.id(domain.getName())
        	.source(JSON.toJSONString(domain), XContentType.JSON);
    );
}
BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);
//判断操作是否成功
boolean result = response.hasFailures();

//复杂查询
SearchRequest request = new SearchRequest("index");
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
//设置高亮
sorceBuilder.highlighter();
//精确查询
TermQueryBuilder termQueryBuilder = QueryBuilder.termQuery("name", "zhangsan");
sourceBuilder.query(termQueryBUilder);
//设置查询超时
sourceBuilder.timeout(new TimeValue(60, TimeUtil.SECONDS));
request.source(sourceBuilder);
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
for(SearchHit documentField : response.getHits().getHits()) {
    Map<String, Object> map = documentField.getSourceAsMap();
}

索引

B-Tree索引

插入新节点不必移动全部节点，能同时兼顾插入和查询的效率。

倒排索引

将key提取出来，同一key内按照value-id的形式存储，并按照value排序，在大量的key中，通过找前缀的方式快速定位到目标key。