ElasticSearch保姆级入门教程

文章目录

  • 一、初识ElasticSearch
  • 二、安装Elasticsearch
    • 2.1 创建网络
    • 2.2 下载资源/加载镜像
    • 2.3 运行
    • 2.4 部署kibana
      • 2.4.1 部署
    • 2.5 安装IK分词器
      • 2.5.1 IK分词器的两种模式
      • 2.5.2 IK分词器的扩展词词典
      • 2.5.2 停用词词典
    • 2.6 Mapping索引库操作
      • 2.6.1 常见mapping属性
      • 2.6.2 创建索引库
      • 2.6.3 查看、删除、更新索引库
    • 2.7 文档操作
    • 2.8 RestClient操作客户端
      • 2.8.1 通过java代码实现对elasticsearch的操作
      • 2.8.2 RestClient索引库的增删查
      • 2.8.3 RestClient文档的增删改查
    • 2.9 DSL查询语法
      • 2.9.1 DSL Query基本语法
      • 2.9.2 DSL全文检索查询
      • 2.9.3 DSL精确查询
      • 2.9.4 DSL地理位置查询
      • 2.9.5 Function Score Query
      • 2.9.6 Boolean Query
    • 2.10 搜索结果处理
      • 2.10.1 排序 sort
      • 2.10.2 分页 from size
      • 2.10.3 高亮处理
    • 2.10 RestClient 查询文档
      • 2.10.1 快速入门查询文档
      • 2.10.2 全文检索 单字段查询
      • 2.10.3 全文检索 多字段查询
      • 2.10.4 bool多条件查询
      • 2.10.5 排序
      • 2.10.6 高亮处理
  • 三、数据聚合
    • 3.1 DSL实现Bucket聚合
    • 3.2 Bucket聚合-限定聚合范围
    • 3.3 DSL实现Metric聚合
    • 3.4 RstClient实现聚合
  • 四、安装拼音分词器
    • 4.1 自动补全
    • 4.2 RestClient实现自动补全
  • 总结


一、初识ElasticSearch

  • elasticsearch是elastic stack的核心,负责存储、搜索、分析数据

ElasticSearch保姆级入门教程_第1张图片

  • Lucene是一个Java语言的搜索引擎类库,是Apache公司的顶级项目。
  • Lucene官方
  • Lucene优势:
    1. 易扩展
    2. 高性能(基于倒排索引)

ElasticSearch保姆级入门教程_第2张图片

  • mysql和elasticsearch相关概念
    ElasticSearch保姆级入门教程_第3张图片
  • MySQL擅长:事务类的操作,可以确保数据的安全和一致性
  • Elasticsearch擅长:海量数据的搜索、分析、计算

二、安装Elasticsearch

2.1 创建网络

  • 因为我们还需要部署kibana容器,因此需要让es和kibana容器互联。这里先创建一个网络:
	docker network create es-net #创建网络

2.2 下载资源/加载镜像

ElasticSearch官网并且下载kibana依赖包
或者
采用镜像tar包

	docker load -i tar包 

2.3 运行

  • 运行docker命令,部署单点es
docker run -d \
	--name es \
    -e "ES_JAVA_OPTS=-Xms512m -Xmx512m" \
    -e "discovery.type=single-node" \
    -v es-data:/usr/share/elasticsearch/data \
    -v es-plugins:/usr/share/elasticsearch/plugins \
    --privileged \
    --network es-net \
    -p 9200:9200 \
    -p 9300:9300 \
elasticsearch:7.12.1
  • -e "cluster.name=es-docker-cluster":设置集群名称
  • -e "http.host=0.0.0.0":监听的地址,可以外网访问
  • -e "ES_JAVA_OPTS=-Xms512m -Xmx512m":内存大小
  • -e "discovery.type=single-node":非集群模式
  • -v es-data:/usr/share/elasticsearch/data:挂载逻辑卷,绑定es的数据目录
  • -v es-logs:/usr/share/elasticsearch/logs:挂载逻辑卷,绑定es的日志目录
  • -v es-plugins:/usr/share/elasticsearch/plugins:挂载逻辑卷,绑定es的插件目录
  • --privileged:授予逻辑卷访问权
  • --network es-net :加入一个名为es-net的网络中
  • -p 9200:9200:端口映射配置

在浏览器输入 ip:9200 即可看见一下消息说明 elasticsearch安装成功
ElasticSearch保姆级入门教程_第4张图片

2.4 部署kibana

  • kibana可以给我们提供一个elasticsearch的可视化界面,便于我们学习。

2.4.1 部署

docker run -d \
--name kibana \
-e ELASTICSEARCH_HOSTS=http://es:9200 \
--network=es-net \
-p 5601:5601  \
kibana:7.12.1
  • 部署完成后 浏览器访问 ip:5601
  • --network es-net :加入一个名为es-net的网络中,与elasticsearch在同一个网络中
  • -e ELASTICSEARCH_HOSTS=http://es:9200":设置elasticsearch的地址,因为kibana已经与elasticsearch在一个网络,因此可以用容器名直接访问elasticsearch
  • -p 5601:5601:端口映射配置
    ElasticSearch保姆级入门教程_第5张图片

2.5 安装IK分词器

  • IK分词器下载
  • 下载好后我们把IK分词器的资源放入到我们docker挂载的数据卷中
  • 查看es的数据卷挂载目录
docker volume inspect es-plugins
  • 显示结果
[
    {
        "CreatedAt": "2022-05-06T10:06:34+08:00",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/es-plugins/_data",
        "Name": "es-plugins",
        "Options": null,
        "Scope": "local"
    }
]
  • 把IK分词器的解压文件放入/var/lib/docker/volumes/es-plugins/_data中即可
  • 重启es
docker restart es

2.5.1 IK分词器的两种模式

  • ik_smart:最少切分
  • ik_max_word:最细切分

2.5.2 IK分词器的扩展词词典

  • 随着互联网的发展,“造词运动”也越发的频繁。出现了很多新的词语,在原有的词汇列表中并不存在。比如:“奥力给”,“绝绝子” 等。我们需要把一些新词扩展到IK分词器中

  • 打开IK分词器config目录
    ElasticSearch保姆级入门教程_第6张图片

  • 在IKAnalyzer.cfg.xml配置文件内容添加:
    ElasticSearch保姆级入门教程_第7张图片

  • 在这个目录下新建一个 ext.dic,可以参考config目录下复制一个配置文件进行修改,然后输入新词保存即可。

  • 重启elasticsearch

docker restart es

2.5.2 停用词词典

  • 与扩展词词典一样、config目录下默认有stopword.dic文件打开后把我们想停用的词输入 保存即可。
  • 重启elasticsearch
docker restart es

2.6 Mapping索引库操作

  • 索引库类似于数据库中的建表操作

2.6.1 常见mapping属性

type 数据类型
type 数据类型
index 是否索引
analyzer 分词器
properties 子字段
type常见有哪些
字符串 text,keyword
数字 long/integet/short/byte/double/float
布尔 boolean
日期 date
对象 object

2.6.2 创建索引库

  • ES中通过Restful请求操作索引库、文档。请求内容用DSL语句来表示。创建索引库和mapping的DSL语法如下:
PUT /索引库名称
{
  "mappings": {
    "properties": {
      "字段名":{
        "type": "text",
        "analyzer": "ik_smart"
      },
      "字段名2":{
        "type": "keyword",
        "index": "false"
      },
      "字段名3":{
        "properties": {
          "子字段": {
            "type": "keyword"
          }
        }
      },
      // ...略
    }
  }
}

2.6.3 查看、删除、更新索引库

  • 查询索引库
PUT /索引库名
  • 删除索引库
DELETE /索引库名
  • 更新索引库
#更新索引库 只能添加新字段,不能修改已有字段
PUT /索引库名/_mapping
{
  "properties": {
    "新字段名":{
      "type": "integer"
    }
  }
}

2.7 文档操作

  • 查看文档:GET /索引库名/_doc/文档id
  • 添加文档
POST /索引库名/_doc/文档id
{
    "字段1": "值1",
    "字段2": "值2",
    "字段3": {
        "子属性1": "值3",
        "子属性2": "值4"
    },
    // ...
}
  • 删除文档:DELETE /索引库名/_doc/文档id
  • 更新文档
    1.全量修改,会删除旧文档,添加新文档
PUT /索引库名/_doc/文档id
{
    "字段1": "值1",
    "字段2": "值2",
    // ... 略
}

2.增量修改,修改指定字段值

POST /索引库名/_update/文档id
{
    "doc": {
         "字段名": "新的值",
    }
}

2.8 RestClient操作客户端

2.8.1 通过java代码实现对elasticsearch的操作

  • pom依赖
引入es的RestHighLevelClient依赖:

  org.elasticsearch.client
    elasticsearch-rest-high-level-client

  • 创建测试类初始化客户端
@BeforeEach//先运行这个方法进行绑定客户端
    void setUp(){
        this.client=new RestHighLevelClient(RestClient.builder(HttpHost.create("http://192.168.36.129:9200")));
    }

2.8.2 RestClient索引库的增删查

  • 公共部分
private RestHighLevelClient client;
  • 创建索引库
//创建索引库
    @Test
    void t2() throws IOException {
        //1. 创建索引库对象
        CreateIndexRequest request = new CreateIndexRequest("hotel");
        //2. 请求参数,HotelIndex.INDEX_MAPPING是创建索引库的字符串模板,内容是创建索引库的DSL语句
        request.source(HotelIndex.INDEX_MAPPING, XContentType.JSON);
        //3. 发送请求
        client.indices().create(request, RequestOptions.DEFAULT);
    }
  • 删除索引库
//删除索引库
    @Test
    void t3() throws IOException {
        //1.创建删除索引库请求对象
        DeleteIndexRequest request = new DeleteIndexRequest("hotel");
        //发送删除请求
        client.indices().delete(request,RequestOptions.DEFAULT);
    }
  • 查询索引库
//查询索引库是否存在
    @Test
    void t4() throws IOException {
        //1.创建查询索引库请求对象
        GetIndexRequest request = new GetIndexRequest("hotel");
        //发送请求
        boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
        System.out.println(exists==true?"索引库已经存在":"索引库不存在");
    }

2.8.3 RestClient文档的增删改查

  • 新增文档
//新增文档
    @Test
    void t5() throws IOException {
        Hotel data = hotelService.getById(61083L);
        HotelDoc hotelDoc = new HotelDoc(data);
        //1.准备Request对象
        IndexRequest request = new IndexRequest("hotel").id(hotelDoc.getId().toString());
        //2.准备JSON文档(索引库中的数据)
        request.source(JSON.toJSONString(hotelDoc),XContentType.JSON);
        //3.发送请求
        client.index(request,RequestOptions.DEFAULT);
    }
  • 删除文档
//删除文档
    @Test
    void t8() throws Exception{
        DeleteRequest request = new DeleteRequest("hotel","61083");
        client.delete(request,RequestOptions.DEFAULT);
    }
  • ````修改文档```
//更新文档
    @Test
    void t7() throws Exception{
        //1.准备Request
        UpdateRequest request = new UpdateRequest("hotel","61083");
        //2.准备请求参数
        request.doc(
                //部分更新 key value的形式
                "price","666",
                "name","李四"
        );
        client.update(request,RequestOptions.DEFAULT);
    }
  • 查询文档
//查询文档
    @Test
    void t6() throws IOException {
        //1.查询请求对象
        GetRequest request = new GetRequest("hotel","61083");
        //2.发送请求,得到文档响应数据
        GetResponse documentFields = client.get(request, RequestOptions.DEFAULT);
        //3.拿到文档数据中的source
        String data = documentFields.getSourceAsString();
        //4.将source反序列化为对象
        HotelDoc hotelDoc = JSON.parseObject(data, HotelDoc.class);
        System.out.println("文档数据===>"+hotelDoc);
    }
  • 批量新增
//批量新增
    @Test
    void t9() throws Exception{
        BulkRequest request = new BulkRequest();
        List<Hotel> lists = hotelService.list();
        for (Hotel list : lists) {
            HotelDoc hotelDoc = new HotelDoc(list);
            request.add(new IndexRequest("hotel").id(hotelDoc.getId().toString()).source(JSON.toJSONString(hotelDoc),XContentType.JSON));

        }
        client.bulk(request,RequestOptions.DEFAULT);
    }

2.9 DSL查询语法

  • 查询所有:查询出所有数据,一般测试用。例如:match_all
  • 全文检索(full text)查询:利用分词器对用户输入内容分词,然后去倒排索引库中匹配。例如:match_query 和 multi_match_query
  • 精确查询:根据精确词条值查找数据,一般是查找keyword、数值、日期、boolean等类型字段。例如:ids range term
  • 地理(geo)查询:根据经纬度查询。例如:geo_distance 和 geo_bounding_box

2.9.1 DSL Query基本语法

GET /indexName/_search
{
  "query": {
    "查询类型": {
      "查询条件": "条件值"
    }
  }
}
例:
GET /hotel/_search
{
  "query": {
    "match_all": {}
  }
}

2.9.2 DSL全文检索查询

  • 全文检索查询的一种,会对用户输入内容分词,然后去倒排索引库检索
GET /索引库/_search
{
  "query": {
    "match": {
      "FIELD": "TEXT"
    }
  }
}
例:
GET /hotel/_search
{
  "query": {
    "match": {
      "all": "外滩五钻"
    }
  }
}

  • 查询多个字段
GET /索引库/_search
{
  "query": {
    "multi_match": {
      "query": "TEXT",
      "fields": ["FIELD1", " FIELD12"]
    }
  }
}
  • match:根据一个字段查询
  • multi_match:根据多个字段查询,参与查询字段越多,查询性能越差

2.9.3 DSL精确查询

  • term精确查询
#精确查询
GET /hotel/_search
{
  "query": {
    "term": {
      "FIELD": {
        "value": "VALUE"
      }
    }
  }
}
例:
#精确查询
GET /hotel/_search
{
  "query": {
    "term": {
      "city": {
        "value": "上海"
      }
    }
  }
}
  • range范围查询
GET /hotel/_search
{
  "query": {
    "range": {
      "FILED": {
        "gte": value,
        "lte": value
      }
    }
  }
}
例:
GET /hotel/_search
{
  "query": {
    "range": {
      "price": {
        "gte": 100,
        "lte": 200
      }
    }
  }
}

2.9.4 DSL地理位置查询

  • 根据geo-distance位置范围查询
GET /hotel/_search
{
  "query": {
    "geo_distance":{
      # distance: 可以设定查询距离
      "distance":"2km",
      # location:当前地址位置,此字段必须是 geo_point类型
      "location":"31.21,121.5"
    }
  }
}

2.9.5 Function Score Query

  • 当我们对第一次的搜索排序进行人工干预时,就需要用到Function Score 函数 可以自定义结果,让排序的结果变成我们想要的解构。 比如进行排名,一些酒店掏钱了,那么我们就可以通过Function Score进行加权算分 让我们想要的结果变成真
  • 在原来查询的条件下进行加权算分
GET /hotel/_search
{
  "query": {
    "function_score": {
      #第一次进行条件查询匹配
      "query": {"match": {
        "all": "外滩"
      }},
      #算分函数
      "functions": [
        {
          "filter": {
            "term": {
              "brand": "如家"
            }
          },
          #算分权重为 10
          "weight": 10
        }
      ],
      #加权模式  boost_mode:乘法
      "boost_mode": "multiply"
    }
  }
}

2.9.6 Boolean Query

  • 布尔查询是一个或多个查询子句的组合。子查询的组合方式有:
  1. must:必须匹配每个子查询,类似“与”
  2. should:选择性匹配子查询,类似“或”
  3. must_not:必须不匹配,不参与算分,类似“非”
  4. filter:必须匹配,不参与算分
  • 演示
  • 需求:搜索名字包含“如家”,价格不高于400,在坐标31.21,121.5周围10km范围内的酒店。
GET /hotel/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
          "name": "如家"
          }
          
        }
      ],
      "must_not": [
        {
          "range": {
            "FIELD": {
              "lte": 500
            }
          }
        }
      ],
      "filter": [
        {
          "geo_distance": {
            "distance": "10km",
            "location": {
              "lat": 31.21,
              "lon": 121.5
            }
          }
        }
      ]
    }
  }
}

2.10 搜索结果处理

2.10.1 排序 sort

  • 语法
GET /索引库名称/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "FIELD": "desc"  // 排序字段和排序方式ASC、DESC
    }
  ]
}

2.10.2 分页 from size

  • 语法
GET /索引库名称/_search
{
  "query": {
    "match_all": {}
  },
  "from": 从第几条数据开始查询, // 分页开始的位置,默认为0
  "size": 显示查询几条, // 期望获取的文档总数
  "sort": [
    {"按照哪个字段排序": "asc"}
  ]
}

2.10.3 高亮处理

  • 语法:高亮处理,默认情况搜索字段必须与高亮字段保持一致
GET /索引库名称/_search
{
  "query": {
    "match": {
      "FIELD": "TEXT"
    }
  },
  "highlight": {
    "fields": { // 指定要高亮的字段
      "FIELD": {
        "require_field_match":"false" #搜索字段与高亮字段匹配为false
        "pre_tags": "",  // 用来标记高亮字段的前置标签
        "post_tags": "" // 用来标记高亮字段的后置标签
      }
    }
  }
}

2.10 RestClient 查询文档

2.10.1 快速入门查询文档

	@Test
    void t1() throws IOException {
        //1.创建搜索请求对象
        SearchRequest request = new SearchRequest("索引库名称");
        //2.准备DSL参数
        request.source().query(QueryBuilders.matchAllQuery()).from(0).size(10);
        //3.发送请求 得到数据集合
        SearchResponse search = client.search(request, RequestOptions.DEFAULT);
        //4.解析响应数据
        SearchHits hits = search.getHits();
        //拿到数据集合中Hits数据的条数
        long value = hits.getTotalHits().value;
        //拿到数据集合
        SearchHit[] hits1 = hits.getHits();
        //5.遍历数据
        for (SearchHit hit : hits1) {
            System.out.println(hit.getSourceAsString());
        }
    }

2.10.2 全文检索 单字段查询

	@Test
    void t2() throws IOException {
        //1.创建搜索请求对象
        SearchRequest request = new SearchRequest("索引库名");
        //2.准备DSL参数
        request.source().query(QueryBuilders.matchQuery("字段","值")).from(0).size(10);
        //3.发送请求 得到数据集合
        SearchResponse search = client.search(request, RequestOptions.DEFAULT);
        //4.解析响应数据
        SearchHits hits = search.getHits();
        //拿到数据集合中Hits数据的条数
        long value = hits.getTotalHits().value;
        //拿到数据集合
        SearchHit[] hits1 = hits.getHits();
        //5.遍历数据
        for (SearchHit hit : hits1) {
            System.out.println(hit.getSourceAsString());
        }
    }

2.10.3 全文检索 多字段查询

	@Test
    void t3() throws IOException {
        //1.创建搜索请求对象
        SearchRequest request = new SearchRequest("hotel");
        //2.准备DSL参数
        request.source().query(QueryBuilders.multiMatchQuery("查询的值","查询字段","查询字段",...)).from(0).size(10);
        //3.发送请求 得到数据集合
        SearchResponse search = client.search(request, RequestOptions.DEFAULT);
        //4.解析响应数据
        SearchHits hits = search.getHits();
        //拿到数据集合中Hits数据的条数
        long value = hits.getTotalHits().value;
        //拿到数据集合
        SearchHit[] hits1 = hits.getHits();
        //5.遍历数据
        for (SearchHit hit : hits1) {
            System.out.println(hit.getSourceAsString());
        }
    }

2.10.4 bool多条件查询

	@Test
    void t4() throws IOException {
        //1.创建搜索请求对象
        SearchRequest request = new SearchRequest("hotel");
        //2.准备DSL参数
        BoolQueryBuilder boolQueryBuilder = new BoolQueryBuilder();
        //精确查询
        boolQueryBuilder.must(QueryBuilders.termQuery("字段名","查询的值"));
        //范围查询
        boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").lte(300));
        request.source().query(boolQueryBuilder);
        //3.发送请求 得到数据集合
        SearchResponse search = client.search(request, RequestOptions.DEFAULT);
        //4.解析响应数据
        SearchHits hits = search.getHits();
        //拿到数据集合中Hits数据的条数
        long value = hits.getTotalHits().value;
        //拿到数据集合
        SearchHit[] hits1 = hits.getHits();
        //5.遍历数据
        for (SearchHit hit : hits1) {
            System.out.println(hit.getSourceAsString());
        }
    }

2.10.5 排序

	@Test
    void t5() throws Exception{
        //1.创建搜索请求对象
        SearchRequest request = new SearchRequest("索引库名");
        //2.准备DSL参数
        request.source().sort("price", SortOrder.ASC).from(0).size(5);
        //3.发送请求 得到数据集合
        SearchResponse search = client.search(request, RequestOptions.DEFAULT);
        handleResponse(search);
    }

2.10.6 高亮处理

	@Test
    void t6()throws Exception{
        //1.创建搜索请求对象
        SearchRequest searchRequest = new SearchRequest("hotel");
        //2.准备DSL参数
        searchRequest.source().query(QueryBuilders.matchQuery("查询字段","value值"));
        searchRequest.source().highlighter(new HighlightBuilder().field("高亮的字段").requireFieldMatch(false));
        //3.发送请求 得到数据集合
        SearchResponse search = client.search(searchRequest,RequestOptions.DEFAULT);
        //4.解析响应数据
        SearchHits hits = search.getHits();
        //拿到数据集合中Hits数据的条数
        long value = hits.getTotalHits().value;
        //拿到数据集合
        SearchHit[] hits1 = hits.getHits();
        //5.遍历数据
        for (SearchHit hit : hits1) {
            //拿到高亮字段
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            if (!CollectionUtils.isEmpty(highlightFields)) {
                //拿到高亮字段的key
                HighlightField name = highlightFields.get("name");
                if(name!=null){
                    String highlightName = name.getFragments()[0].string();
                    System.out.println(highlightName);
                }
            }
        }
    }

三、数据聚合

  • 聚合(aggregations):可以实现对文档数据的统计、分析、运算。聚合常见的有三类:
    1. Bucket:对文档数据分组,并统计每组数量
    2. Metric:对文档数据做计算,例如avg
    3. Pipeline:基于其它聚合结果再做聚合
  • 聚合(aggregations):的字段类型必须是
    1. keyword
    2. 数值
    3. 布尔
    4. 日期
  • 聚合(aggregations)聚合三要素:聚合名称、聚合类型、聚合字段

3.1 DSL实现Bucket聚合

GET /索引库名/_search
{
  "size": 0,  // 设置size为0,结果中不包含文档,只包含聚合结果
  "aggs(固定名称)": { // 定义聚合
    "brandAgg(自定义聚合名称)": { //给聚合起个名字
      "terms": { // 聚合的类型,按照品牌值聚合,所以选择term
        "field": "参与聚合的字段名", // 参与聚合的字段
        "order": {
          "排序字段": "asc" // 按照升序排列
        },
        "size": 20 // 希望获取的聚合结果数量
      }
    }
  }
}

3.2 Bucket聚合-限定聚合范围

GET /索引库名/_search
{
  #先进行查询,然后再将查询后的数据进行聚合
  "query": {
    "match": {
      "name": "酒店"
    }
  }, 
  "size": 0, 
  "aggs": {
    "brandAgg": {
      "terms": {
        "field": "brand",
        "size": 20
      }
    }
  }
}

聚合可配置的属性
size 指定聚合结果数量
order 指定聚合结果排序方式
field 指定聚合字段

3.3 DSL实现Metric聚合

  • 可以获取min、max、avg等值
GET /索引库名/_search
{
  "size": 0, 
  "aggs": {
    "brandAgg(自定义聚合名)": { 
      "terms(添加聚合类型)": { 
        "field": "字段", 
        "size": 20
      },
      "aggs": { // 是上面聚合的子聚合,也就是分组后对每组分别计算
        "score_stats": { // 聚合名称
          "stats": { // 聚合类型,这里stats可以计算min、max、avg等
            "field": "score" // 聚合字段,这里是score
          }
        }
      }
    }
  }
}

3.4 RstClient实现聚合

@Test
    void t7()throws Exception{
        //1.准备搜索请求对象
        SearchRequest request = new SearchRequest("hotel");
        //2.准备DSL
        request.source().size(0);
        request.source().aggregation(AggregationBuilders
                //准备聚合:值为自定义聚合名称
                .terms("brandAgg")
                //聚合的字段
                .field("brand")
                //展示几条
                .size(10));
        //3.发出请求得到解析对象
        SearchResponse search = client.search(request, RequestOptions.DEFAULT);
        //4.拿到聚合对象
        Aggregations aggregations = search.getAggregations();
        //5.通过聚合对象.get(自定义聚合名称) 拿到具体的聚合类型的结果 对象
        Terms brandAgg = aggregations.get("brandAgg");
        //6.拿到桶Buckets
        List<? extends Terms.Bucket> buckets = brandAgg.getBuckets();
        //7.遍历每一条数据
        for (Terms.Bucket bucket : buckets) {
            String key = bucket.getKeyAsString();
            System.out.println(key);
        }
    }

四、安装拼音分词器

  • 拼音分词器下载地址
    1. 下载与elasticsearch对应版本的拼音分词器包
    2. 解压拼音分词器.zip
    3. 将拼音分词器解压后的文件夹放入elasticsearch数据卷相对应的es-plugin文件夹下
    4. docker insepect es 查看es的数据卷目录
    5. 重启 es
  • 自定义分词器中过滤器的参数文档:参数文档
PUT /test
{
  "settings": {
    "analysis": {
      "analyzer": { // 自定义分词器
        "my_analyzer(自定义分词器名称)": {  // 分词器名称
          "tokenizer": "ik_max_word",
          "filter": "py" #对应下面的过滤器名称
        }
      },
      "filter": { // 自定义tokenizer filter
        "py": { // 过滤器名称
          "type": "pinyin", // 过滤器类型,这里是pinyin
		  "keep_full_pinyin": false,
          "keep_joined_full_pinyin": true,
          "keep_original": true,
          "limit_first_letter_length": 16,
          "remove_duplicated_term": true,
          "none_chinese_pinyin_tokenize": false
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "name":{
        "type": "text",
        "analyzer": "my_analyzer", #当我插入文档数据时,会根据自定义分词规则进行过滤
        "search_analyzer": "ik_smart" #搜索时使用ik分词器 可以避免搜到同音字
      }
    }
  }
}

4.1 自动补全

  • elasticsearch提供了Completion Suggester查询来实现自动补全功能。这个查询会匹配以用户输入内容开头的词条并返回。为了提高补全查询的效率,对于文档中字段的类型有一些约束:
    1. 参与补全查询的字段必须是completion类型。
    2. 字段的内容一般是用来补全的多个词条形成的数组。
  • 创建语法:
// 创建索引库
PUT test
{
  "mappings": {
    "properties": {
      "title":{
        "type": "completion"
      }
    }
  }
}
// 示例数据
POST test/_doc
{
  "title": ["Sony","switch","LOL", "WH-1000XM3"]
}
POST test/_doc
{
  "title": ["switch", "WH-1000XM4"]
}

  • 查询语法:
// 自动补全查询
GET /test2/_search
{
  "suggest": {
    "title_suggest": {
      "text": "s", // 关键字
      "completion": {
        "field": "title", // 补全查询的字段
        "skip_duplicates": true, // 跳过重复的
        "size": 10 // 获取前10条结果
      }
    }
  }
}

4.2 RestClient实现自动补全

	@Test
    void t8()throws Exception{
        //1.准备搜索请求对象
        SearchRequest request = new SearchRequest("test2");
        //2.准备DSL语句
        request.source().suggest(new SuggestBuilder().addSuggestion(
                // 自定义suggestion名称
                "mySuggest",
                //补全功能搜索的字段
                SuggestBuilders.completionSuggestion("title")
                        //跳过重复的数据
                        .skipDuplicates(true)
                        //根据前缀来搜索补全的值,这里的值将来会通过前端传过来
                        .prefix("s")
                        //显示几条数据
                        .size(10)));
        //3.发送请求得到数据结果
        SearchResponse search = client.search(request, RequestOptions.DEFAULT);
        //4.拿到suggest所有数据
        Suggest suggest = search.getSuggest();
        //4.1 拿到真正的suggestion补全数据的json串儿
        Suggest.Suggestion<? extends Suggest.Suggestion.Entry<? extends Suggest.Suggestion.Entry.Option>> mySuggest = suggest.getSuggestion("mySuggest");
        //5.遍历补全数据json串儿
        for (Suggest.Suggestion.Entry<? extends Suggest.Suggestion.Entry.Option> options : mySuggest) {
            //拿到自动补全数据
            String data = options.getText().string();
            System.out.println(data);
        }
        System.out.println(search);
    }

总结

提示:学习视频来自B站

你可能感兴趣的:(Java,elasticsearch,搜索引擎,lucene)