ElastaticSearch-应用详解

已于 2023-04-11 20:19:19 修改
阅读量263 收藏
点赞数
文章标签： elasticsearch 搜索引擎 java
于 2023-04-10 15:45:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60266957/article/details/130060739
版权

ElastaticSearch-应用详解

声明： 本博客已标明出处，如有侵权请告知，马上删除。

ES基本操作

ES概述

概述

Elasticsearch是一款非常强大的开源搜索引擎，具备非常多强大功能，可以帮助我们从海量数据中快速找到需要的内容

Elasticsearch是专门用于文档搜索的一块搜索引擎.

结构
在这里插入图片描述

ES操作-索引

脚本操作

创建索引库

PUT /索引库名称
{
  "mappings": {
    "properties": {
      "字段名": {
        "type": "text",
        "analyzer": "ik_smart"
      },
      "字段名2": {
        "type": "keyword",
        "index": "false"
      }
      #...略
    }
  }
}

查询索引库

GET /索引库名

添加新字段

PUT /索引库名/_mapping
{
  "properties": {
    "新字段名":{
      "type": "integer"
    }
  }
}

删除索引库

DELETE /索引库名

Java操作

导入坐标

<!--定义版本-->
<properties>
    <java.version>1.8</java.version>
    <elasticsearch.version>7.12.1</elasticsearch.version>
</properties>

<!--elasticsearch-->
<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
</dependency>

相关代码

@SpringBootTest
public class HotelIndexTest {

    private RestHighLevelClient client;
    
    @BeforeEach
    void setUp() {
        //建立联接
        client = new RestHighLevelClient(RestClient.builder(
                HttpHost.create("http://192.168.150.101:9200")
        ));
    }

    @AfterEach
    void tearDown() throws IOException {
        //释放联接
        client.close();
    }

    @Test
    void testCreateIndex() throws IOException {
        // 1.准备Request      PUT /hotel
        CreateIndexRequest request = new CreateIndexRequest("hotel");
        // 2.准备请求参数
        request.source("mappings映射的json字符串", XContentType.JSON);
        // 3.发送请求
        client.indices().create(request, RequestOptions.DEFAULT);
    }

    @Test
    void testExistsIndex() throws IOException {
        // 1.准备Request
        GetIndexRequest request = new GetIndexRequest("hotel");
        // 3.发送请求
        boolean isExists = client.indices().exists(request, RequestOptions.DEFAULT);

        System.out.println(isExists ? "存在" : "不存在");
    }

    @Test
    void testDeleteIndex() throws IOException {
        // 1.准备Request
        DeleteIndexRequest request = new DeleteIndexRequest("hotel");
        // 3.发送请求
        client.indices().delete(request, RequestOptions.DEFAULT);
    }   
}

ES操作-文档

脚本操作

添加文档

POST /索引库名/_doc/文档id
{
    "字段1": "值1",
    "字段2": "值2",
    "字段3": {
        "子属性1": "值3",
        "子属性2": "值4"
    },
    // ...
}

查询文档

GET /索引库名称/_doc/文档id

修改文档-替换

PUT /索引库名称/_doc/文档id
{
    "字段1": "值1",
    "字段2": "值2",
    // ... 略
}

修改文档-修改

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

删除文档

DELETE /索引库名称/_doc/文档id

Java操作

导入坐标

<!--定义版本-->
<properties>
    <java.version>1.8</java.version>
    <elasticsearch.version>7.12.1</elasticsearch.version>
</properties>

<!--elasticsearch-->
<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
</dependency>

相关代码

@SpringBootTest
public class HotelDocumentTest {

    private RestHighLevelClient client;

    @Autowired
    private IHotelService hotelService;
    
    
    @BeforeEach
    void setUp() {
        client = new RestHighLevelClient(RestClient.builder(
                HttpHost.create("http://192.168.150.101:9200")
        ));
    }

    @AfterEach
    void tearDown() throws IOException {
        client.close();
    }

    @Test
    void testAddDocument() throws IOException {
        // 1.查询数据库hotel数据
        Hotel hotel = hotelService.getById(61083L);
        // 2.转换为HotelDoc
        HotelDoc hotelDoc = new HotelDoc(hotel);
        // 3.转JSON
        String json = JSON.toJSONString(hotelDoc);

        // 1.准备Request
        IndexRequest request = new IndexRequest("hotel").id(hotelDoc.getId().toString());
        // 2.准备请求参数DSL，其实就是文档的JSON字符串
        request.source(json, XContentType.JSON);
        // 3.发送请求
        client.index(request, RequestOptions.DEFAULT);
    }

    @Test
    void testGetDocumentById() throws IOException {
        // 1.准备Request      // GET /hotel/_doc/{id}
        GetRequest request = new GetRequest("hotel", "61083");
        // 2.发送请求
        GetResponse response = client.get(request, RequestOptions.DEFAULT);
        // 3.解析响应结果
        String json = response.getSourceAsString();

        HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
        System.out.println("hotelDoc = " + hotelDoc);
    }

    @Test
    void testDeleteDocumentById() throws IOException {
        // 1.准备Request      // DELETE /hotel/_doc/{id}
        DeleteRequest request = new DeleteRequest("hotel", "61083");
        // 2.发送请求
        client.delete(request, RequestOptions.DEFAULT);
    }

    @Test
    void testUpdateById() throws IOException {
        // 1.准备Request
        UpdateRequest request = new UpdateRequest("hotel", "61083");
        // 2.准备参数
        request.doc(
                "price", "870"
        );
        // 3.发送请求
        client.update(request, RequestOptions.DEFAULT);
    }

    @Test
    void testBulkRequest() throws IOException {
        // 查询所有的酒店数据
        List<Hotel> list = hotelService.list();

        // 1.准备Request
        BulkRequest request = new BulkRequest();
        // 2.准备参数
        for (Hotel hotel : list) {
            // 2.1.转为HotelDoc
            HotelDoc hotelDoc = new HotelDoc(hotel);
            // 2.2.转json
            String json = JSON.toJSONString(hotelDoc);
            // 2.3.添加请求
            request.add(new IndexRequest("hotel").id(hotel.getId().toString()).source(json, XContentType.JSON));
        }

        // 3.发送请求
        client.bulk(request, RequestOptions.DEFAULT);
    }
}

ES复杂搜索

ES搜索-脚本操作

基本语法

GET /索引库名称/_search
{
  "query": {
    "查询类型": {
      "查询条件": "条件值"
    }
  }
}

查询所有

GET /索引库名称/_search
{
  "query": {
    "match_all": {
    }
  }
}

全文检索

match

GET /索引库名称/_search
{
  "query": {
    "match": {
      "列名": "搜索文本"
    }
  }
}

multi_match

GET /索引库名称/_search
{
  "query": {
    "multi_match": {
      "query": "搜索文本",
      "fields": ["列名1", " 列名2"]
    }
  }
}

精确查询

** term查询**

GET /索引库名称/_search
{
  "query": {
    "term": {
      "列名": {
        "value": "值"
      }
    }
  }
}

range查询

GET /索引库名称/_search
{
  "query": {
    "range": {
      "列名": {
        "gte": 小值,  # 这里的gte代表大于等于，gt则代表大于
        "lte": 大值   # lte代表小于等于，lt则代表小于
      }
    }
  }
}

地理查询

区域查询

GET /索引库名称/_search
{
  "query": {
    "geo_bounding_box": {
      "列名": {
        "top_left": { 	# 左上点
          "lat": 31.1,
          "lon": 121.5
        },
        "bottom_right": { # 右下点
          "lat": 30.9,
          "lon": 121.7
        }
      }
    }
  }
}

附近查询

GET /索引库名称/_search
{
  "query": {
    "geo_distance": {
      "distance": "15km", // 半径
      "列名": "31.21,121.5" // 圆心
    }
  }
}

相关性算分

  • 原始查询条件：query部分，基于这个条件搜索文档，并且基于BM25算法给文档打分，原始算分（query score)
  • 过滤条件：filter部分，符合该条件的文档才会重新算分
  • 算分函数：符合filter条件的文档要根据这个函数做运算，得到的函数算分（function score），有四种函数
    • weight：函数结果是常量
    • field_value_factor：以文档中的某个字段值作为函数结果
    • random_score：以随机数作为函数结果
    • script_score：自定义算分函数算法
  • 运算模式：算分函数的结果、原始查询的相关性算分，两者之间的运算方式，包括：
    • multiply：相乘
    • replace：用function score替换query score
    • 其它，例如：sum、avg、max、min
GET /索引库名称/_search
{
  "query": {
    "function_score": {
      "query": { .... }, 	# 原始查询，可以是任意条件
      "functions": [ 		# 算分函数
        {
          "filter": { 		# 满足的条件，品牌必须是如家
            "term": {
              "brand": "如家"
            }
          },
          "weight": 2 		# 算分函数,算分权重为2
        }
      ],
      "boost_mode": "sum" 	# 运算模式，求和
    }
  }
}

复合查询

布尔查询是一个或多个查询子句的组合，每一个子句就是一个子查询。子查询的组合方式有：

  • must：必须匹配每个子查询，类似“与”
  • should：选择性匹配子查询，类似“或”
  • must_not：必须不匹配，不参与算分，类似“非”
  • filter：必须匹配，不参与算分
GET /hotel/_search
{
  "query": {
    "bool": {
      "must": [
        {"term": {"city": "上海" }}
      ],
      "should": [
        {"term": {"brand": "皇冠假日" }},
        {"term": {"brand": "华美达" }}
      ],
      "must_not": [
        { "range": { "price": { "lte": 500 } }}
      ],
      "filter": [
        { "range": {"score": { "gte": 45 } }}
      ]
    }
  }
}

ES搜索-Java操作

查询模版

package cn.jd.hotel;

import cn.jd.hotel.pojo.HotelDoc;
import com.alibaba.fastjson.JSON;
import org.apache.http.HttpHost;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
import org.elasticsearch.search.sort.SortOrder;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;
import java.util.Map;

@SpringBootTest
public class HotelSearchTest {

    private RestHighLevelClient client;
    
    @BeforeEach
    void setUp() {
        client = new RestHighLevelClient(RestClient.builder(
                HttpHost.create("http://192.168.150.101:9200")
        ));
    }

    @AfterEach
    void tearDown() throws IOException {
        client.close();
    }
    
    /**
     * 查询
     * @throws IOException
     */
    public void testESQuery(QueryBuilder query) throws IOException {
        // 1.准备request
        SearchRequest request = new SearchRequest("hotel");
        // 2.准备请求参数
        request.source().query(query);
        // 3.发送请求，得到响应
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        // 4.结果解析
        handleResponse(response);
    }

   /**
     * 处理结果
     * @param response 查询到的结果
     */
    private void handleResponse(SearchResponse response) {
        SearchHits searchHits = response.getHits();
        // 4.1.总条数
        long total = searchHits.getTotalHits().value;
        System.out.println("总条数：" + total);
        // 4.2.获取文档数组
        SearchHit[] hits = searchHits.getHits();
        // 4.3.遍历
        for (SearchHit hit : hits) {
            // 4.4.获取source
            String json = hit.getSourceAsString();
            // 4.5.反序列化，非高亮的
            HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
            // 4.6.打印
            System.out.println(hotelDoc);
        }
    }
}

查询所有

@Test
public void testMatchAll() throws IOException {
    testESQuery(QueryBuilders.matchAllQuery());
}

全文检索

match

@Test
public void testMatch() throws IOException {
 	MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("列名", "搜索文本");
    testESQuery(matchQueryBuilder);
}

multi_match

@Test
public void testMultiMatch() throws IOException {
 	MultiMatchQueryBuilder mq = QueryBuilders.multiMatchQuery("搜索文本", "列名1", "列名2");
    testESQuery(mq);
}

精确查询

term查询

@Test
public void testTerm() throws IOException {
 	TermQueryBuilder tq = QueryBuilders.termQuery("列名", "值");    
    testESQuery(tq);
}

range查询

@Test
public void testTerm() throws IOException {
 	RangeQueryBuilder rq = QueryBuilders.rangeQuery("列名").gte("小值").lte("大值");
    testESQuery(rq);
}

地理查询

区域查询

@Test
public void testGeoBoundingBox() throws IOException {
    GeoBoundingBoxQueryBuilder gbq = QueryBuilders.geoBoundingBoxQuery("列名")
        .setCorners("左上角维度,左上角经度", "右下角维度,右下角经度");
    testESQuery(gbq);
}

附近查询

@Test
public void testGeoDistance() throws IOException {
    GeoDistanceQueryBuilder dq = QueryBuilders.geoDistanceQuery("列名")
        .distance("15", DistanceUnit.KILOMETERS)
        .point(new GeoPoint("维度,经度"));
    testESQuery(dq);
}

相关性算分

@Test
public void testScoreQuery() throws IOException {
    //1.准备基础查询
 	MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("列名", "搜索文本");
    // 2.算分函数查询
    FunctionScoreQueryBuilder fq = QueryBuilders.functionScoreQuery(
        matchQueryBuilder, // 原始查询，matchQueryBuilder
        new FunctionScoreQueryBuilder.FilterFunctionBuilder[]{ // function数组
            new FunctionScoreQueryBuilder.FilterFunctionBuilder(
                QueryBuilders.termQuery("isAD", true), // 过滤条件
                ScoreFunctionBuilders.weightFactorFunction(10) // 算分函数
            )
        }
    );
    testESQuery(fq);
}

复合查询

布尔查询是一个或多个查询子句的组合，每一个子句就是一个子查询。子查询的组合方式有：

  • must：必须匹配每个子查询，类似“与”
  • should：选择性匹配子查询，类似“或”
  • must_not：必须不匹配，不参与算分，类似“非”
  • filter：必须匹配，不参与算分
@Test
public void testTerm() throws IOException {
 	BoolQueryBuilder bq = QueryBuilders.boolQuery()
                .must(QueryBuilders.termQuery("city", "上海"))
                .should(QueryBuilders.termQuery("brand","皇冠假日"))
                .should(QueryBuilders.termQuery("brand","华美达"))
                .mustNot(QueryBuilders.rangeQuery("price").lte(500))
                .filter(QueryBuilders.rangeQuery("score").gte(45));
    testESQuery(bq);
}

ES结果处理

ES结果处理-脚本操作:

多个结果处理可以并用.

结果排序

普通字段排序

GET /indexName/_search
{
  "query": {
    "match_all": {}		#查询条件,可以是任意条件
  },
  "sort": [
    {
      "列名": "desc"  	#排序字段、排序方式ASC、DESC
    }
  ]
}

地理位置排序

GET /indexName/_search
{
  "query": {
    "match_all": {}		#查询条件,可以是任意条件
  },
  "sort": [
    {
      "_geo_distance" : {
          "列名" : "纬度，经度", 	#文档中geo_point类型的字段名、目标坐标点
          "order" : "asc", 		#排序方式
          "unit" : "km" 		#排序的距离单位
      }
    }
  ]
}

结果分页

GET /hotel/_search
{
  "query": {
    "match_all": {}		#查询条件,可以是任意条件
  },
  "from": 0, 			# 分页开始的位置，默认为0
  "size": 10, 			# 期望获取的文档总数
  "sort": [
    {"列名": "asc"}	#排序
  ]
}

结果高亮

所谓高亮查询,其实就是在查询的关键字前边添加前缀,在关键字的后边添加后缀

注意：

  • 高亮是对关键字高亮，因此搜索条件必须带有关键字，而不能是范围这样的查询。
  • 默认情况下，高亮的字段，必须与搜索指定的字段一致，否则无法高亮
  • 如果要对非搜索字段高亮，则需要添加一个属性：required_field_match=false
GET /hotel/_search
{
  "query": {
    "match": {
      "列名": "值"			#查询条件，高亮一定要使用全文检索查询
    }
  },
  "highlight": {
    "fields": { 		# 指定要高亮的字段
      "列名": {
        "pre_tags": "<em>",		# 用来标记高亮字段的前置标签
        "post_tags": "</em>", 	# 用来标记高亮字段的后置标签
        "required_field_match": "false"		#对非搜索字段高亮
      }
    }
  }
}

ES结果处理-Java操作

结果排序和分页:

对结果进行排序和分页, 都是在查询Request的对象处修改

/**
 * 查询-分页和排序
 * @throws IOException
 */
public void testESQuerySortPage(QueryBuilder query) throws IOException {
    // 1.准备request
    SearchRequest request = new SearchRequest("hotel");
    
    // 2.准备请求参数
    // 2.1.query
    request.source().query(query);
    // 2.2.排序 sort
    request.source().sort("列名", SortOrder.ASC);
    // 2.3.分页 from、size
    request.source().from((page - 1) * size).size(5);
    
    // // 2.3.距离排序
    // String location = "维度,经度";
    // if (StringUtils.isNotBlank(location)) {
    //     //按照地理位置排序
    //     request.source().sort(SortBuilders
    //             .geoDistanceSort("location", new GeoPoint(location))
    //             .order(SortOrder.ASC)
    //             .unit(DistanceUnit.KILOMETERS)
    //     );
    // }
    
    
    // 3.发送请求，得到响应
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.结果解析
    handleResponse(response);
}

高亮搜索

所谓高亮查询,其实就是在查询的关键字前边添加前缀,在关键字的后边添加后缀

高亮操作分为两部分: 1.设置高亮 2.获取高亮信息

注意: 高亮操作的列, 必须是"全文检索"的列, 也就是列的类型必须是text

设置高亮

**
 * 查询-高亮
 * @throws IOException
 */
public void testESQueryHighlight(QueryBuilder query) throws IOException {
    // 1.准备request
    SearchRequest request = new SearchRequest("hotel");
    
    // 2.准备请求参数
    // 2.1.query
    request.source().query(query);
    // 2.2.设置高亮
    request.source().highlighter(new HighlightBuilder().field("列名").requireFieldMatch(false));
    
    // 3.发送请求，得到响应
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.结果解析
    handleResponseHighlight(response);
}

** 获取高亮信息**

/**
  * 处理结果
  * @param response 查询到的结果
  */
private void handleResponseHighlight(SearchResponse response) {
    SearchHits searchHits = response.getHits();
    // 4.1.总条数
    long total = searchHits.getTotalHits().value;
    System.out.println("总条数：" + total);
    // 4.2.获取文档数组
    SearchHit[] hits = searchHits.getHits();
    // 4.3.遍历
    for (SearchHit hit : hits) {
        // 4.4.获取source
        String json = hit.getSourceAsString();
        // 4.5.反序列化，非高亮的
        HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
        // 4.6.处理高亮结果
        // 1)获取高亮map
        Map<String, HighlightField> map = hit.getHighlightFields();
        // 2）根据字段名，获取高亮结果
        HighlightField highlightField = map.get("name");
        // 3）获取高亮结果字符串数组中的第1个元素
        String hName = highlightField.getFragments()[0].toString();
        // 4）把高亮结果放到HotelDoc中
        hotelDoc.setName(hName);
        // 4.7.打印
        System.out.println(hotelDoc);
    }
}

ES聚合查询

ES聚合查询-脚本操作

桶聚合-分组:

GET /hotel/_search
{
  "query": {
    "range": {
      "price": {
        "lte": 200		#原始查询,可以修改(只对200元以下的文档聚合),如果不写,表示查询所有
      }
    }
  }, 
  "size": 0, 			#表示不显示文档,只显示聚合
  "aggs": {
    "brandAgg": {		#brandAgg是聚合名称,该名称自由定义,聚合可以书写多个
      "terms": {
        "field": "brand",	#根据brand进行分组
        "size": 20,			#最多显示20个结果
        "order": {
          "_count": "asc"	#按照_count升序排列,如果不写,默认根据count降序
        }
      }
    }
  }
}

度量聚合-聚合函数

直接聚合:

GET /hotel/_search
{
  "query": {
    "range": {
      "price": {
        "lte": 200	#原始查询,可以修改(只对200元以下的文档聚合),表示查询所有
      }
    }
  },
  "size": 0,	#表示不显示文档,只显示聚合
  "aggs": {		#如果直接写在外边,就是对所有聚合,如果写在桶聚合的里边,就是对分组之后进行聚合
    "score_stats": {	#score_stats是聚合名称,该名称自由定义
      "stats": {		#聚合类型，这里stats计算count,min,max,avg,sum等,也可以单独书写为min,max,avg,count,sum等
        "field": "score"	#聚合字段，这里是score
      }
    }
  }
}

分组后统计:

GET /hotel/_search
{
 "query": {
    "range": {
      "price": {
        "lte": 200	#原始查询,可以修改(只对200元以下的文档聚合),表示查询所有
      }
    }
  },
  "size": 0, 
  "aggs": {
    "brandAgg": { 			#聚合可以书写多个
      "terms": { 
        "field": "brand", 
        "size": 20
      },
      "aggs": { 			#书写在brandAgg里边,所以是brandAgg聚合的子聚合,也就是分组后对每组分别计算
        "score_stats": { 	#聚合名称,可以随便写
          "stats": { 		#聚合类型，这里stats可以计算min、max、avg等,也可以书写为min,max,avg,count
            "field": "score" #聚合字段，这里是score
          }
        }
      }
    }
  }
}

ES聚合查询-Java操作

桶聚合-分组:

@Test
public void testAgg() throws IOException {
    // 1.准备请求
    SearchRequest request = new SearchRequest("hotel");
    // 1.1 原始查询,如果不写,默认查询所有
    request.source().query(QueryBuilders.rangeQuery("price").lte(200));

    // 2.请求参数
    // 2.1.size
    request.source().size(0);
    // 2.2.聚合(聚合可以书写多个)
    request.source().aggregation(
        AggregationBuilders.terms("brandAgg")
        .field("brand")
        .size(20)
        .order(BucketOrder.count(true))
    );


    // 3.发出请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.解析结果
    Aggregations aggregations = response.getAggregations();
    // 4.1.根据聚合名称，获取聚合结果
    Terms brandAgg = aggregations.get("brandAgg");
    // 4.2.获取buckets
    List<? extends Terms.Bucket> buckets = brandAgg.getBuckets();
    // 4.3.遍历
    for (Terms.Bucket bucket : buckets) {
        String brandName = bucket.getKeyAsString();
        System.out.println("brandName = " + brandName);
        long docCount = bucket.getDocCount();
        System.out.println("docCount = " + docCount);
    }
}

度量聚合-聚合函数

直接聚合

/**
 * 度量聚合-聚合函数
 */
@Test
void testStatsAggs() throws IOException {
    // 1.准备请求
    SearchRequest request = new SearchRequest("hotel");
    // 1.1 原始查询,如果不写,默认查询所有
    request.source().query(QueryBuilders.rangeQuery("price").lte(200));

    // 2.请求参数
    // 2.1.size
    request.source().size(0);
    // 2.2.聚合
    request.source().aggregation(
        AggregationBuilders.stats("scoreStats").field("score")
    );

    // 3.发出请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.解析结果
    Aggregations aggregations = response.getAggregations();
    // 4.1.根据聚合名称，获取聚合结果
    Stats scoreStats = aggregations.get("scoreStats");
    // 4.2.获取数据
    double count = scoreStats.getCount();
    double max = scoreStats.getMax();
    double min = scoreStats.getMin();
    double avg = scoreStats.getAvg();
    double sum = scoreStats.getSum();
    System.out.println(count);
    System.out.println(max);
    System.out.println(min);
    System.out.println(avg);
    System.out.println(sum);
}

分组后统计

/**
     * 分组后统计
     */
@Test
void testTermsStatsAggs() throws IOException {
    // 1.准备请求
    SearchRequest request = new SearchRequest("hotel");
    // 1.1 原始查询,如果不写,默认查询所有
    request.source().query(QueryBuilders.rangeQuery("price").lte(200));

    // 2.请求参数
    // 2.1.size
    request.source().size(0);
    // 2.2.聚合
    request.source().aggregation(
        AggregationBuilders.terms("brandAgg")
        .field("brand")
        .size(20)
        .subAggregation(AggregationBuilders
                        .stats("scoreStats")
                        .field("score"))
    );


    // 3.发出请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);


    // 4.解析结果
    Aggregations aggregations = response.getAggregations();
    // 4.1.根据聚合名称，获取聚合结果
    Terms brandAgg = aggregations.get("brandAgg");
    // 4.2.获取buckets
    List<? extends Terms.Bucket> buckets = brandAgg.getBuckets();
    // 4.3.遍历
    for (Terms.Bucket bucket : buckets) {
        //获取key
        String brandName = bucket.getKeyAsString();
        //获取Count数量
        long docCount = bucket.getDocCount();

        //获取统计信息
        Aggregations scoreAgg = bucket.getAggregations();
        Stats scoreStats = scoreAgg.get("scoreStats");
        // 4.2.获取数据
        double count = scoreStats.getCount();
        double max = scoreStats.getMax();
        double min = scoreStats.getMin();
        double avg = scoreStats.getAvg();
        double sum = scoreStats.getSum();
        System.out.println(brandName + ":" + docCount);
        System.out.println(brandName + "统计信息:" + count + "-" + max + "-" + min + "-" + avg + "-" + sum);
    }
}

ES自定义分词器规则

PUT /hotel			#索引库名称
{
  "settings": {		#索引库设置
    "analysis": {
      "analyzer": {			#自定义分词器
        "text_anlyzer": {	#分词器名称
          "tokenizer": "ik_max_word",	#先用ik_max_word分词器,分词
          "filter": "py"				#然后用py过滤器进行进一步处理
        },
        "completion_analyzer": {	#分词器名称
          "tokenizer": "keyword",	#先用确定keyword规则
          "filter": "py"			#然后用py过滤器进行进一步处理
        }
      },
      "filter": {	#定义过滤器
        "py": {		#过滤器名字
          "type": "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": {
      "id":{
        "type": "keyword"
      },
      "name":{
        "type": "text",
        "analyzer": "text_anlyzer",		#生成倒排索引时,使用text_anlyzer分词器
        "search_analyzer": "ik_smart",	#查询该列的时候,使用ik_smart分词器
        "copy_to": "all"
      },
      "address":{
        "type": "keyword",
        "index": false
      },
      "price":{
        "type": "integer"
      },
      "score":{
        "type": "integer"
      },
      "brand":{
        "type": "keyword",
        "copy_to": "all"
      },
      "city":{
        "type": "keyword"
      },
      "starName":{
        "type": "keyword"
      },
      "business":{
        "type": "keyword",
        "copy_to": "all"
      },
      "location":{
        "type": "geo_point"
      },
      "pic":{
        "type": "keyword",
        "index": false
      },
      "all":{
        "type": "text",
        "analyzer": "text_anlyzer",		#生成倒排索引时,使用text_anlyzer分词器
        "search_analyzer": "ik_smart"	#查询该列的时候,使用ik_smart分词器
      },
      "suggestion":{
          "type": "completion",
          "analyzer": "completion_analyzer"	#生成和查询时,都使用completion_analyzer分词器
          									#因为已经指定了分词器,所以,该列中可以直接存储中文,查询时会自动根据拼音补全
      }
    }
  }
}

ES自动补全查询

ES自动补全查询-脚本操作

自动补全字段的类型必须是completion类型, 且字段值必须是多词条数组

GET /hotel/_search
{
  "suggest": {
    "hotel_suggest": {
      "text": "sh",		#查询关键字
      "completion": {
        "field": "suggestion",	#补全查询的字段(根据哪个字段自动补全)
        "skip_duplicates": true,	#跳过重复的
        "size": 10		#获取前10条结果
      }
    }
  }
}

ES自动补全查询-Java操作

@Test
public void testSuggest() throws IOException {
    // 1.准备Request
    SearchRequest request = new SearchRequest("hotel");
    // 2.准备DSL
    request.source().suggest(new SuggestBuilder().addSuggestion(
        "hotelSuggest",
        SuggestBuilders.completionSuggestion("suggestion")	//补全的字段
        .prefix("sh")            //查询关键字
        .skipDuplicates(true)   //跳过重复
        .size(10)               //获取前10条结果
    ));
    // 3.发起请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.解析结果
    Suggest suggest = response.getSuggest();
    // 4.1.根据补全查询名称，获取补全结果
    CompletionSuggestion suggestions = suggest.getSuggestion("hotelSuggest");
    // 4.2.获取options
    List<CompletionSuggestion.Entry.Option> options = suggestions.getOptions();
    // 4.3.遍历
    List<String> list = new ArrayList<>(options.size());
    for (CompletionSuggestion.Entry.Option option : options) {
        String text = option.getText().toString();
        list.add(text);
        System.out.println(text);
    }
}

ES集群-设置分片

注意,分片和副本设置只能在集群环境下设置

PUT /索引库名称			#索引库名称
{
  "settings": {	
    "number_of_shards": 3, 	#分片数量,默认1
    "number_of_replicas": 1 #副本数量
  },
  "mappings": {
    "properties": {
      //.....
    }
  }
}
小新兜兜有糖
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
ElastaticSearch-5.6 head插件内网集成
11-05
内网环境下，es的head插件无法下载各种资源，所以把集成好的插件打包，内网环境可以解压直接使用（NodeJS 6.x请自行安装）。
PHP-PDO应用详解版.doc
11-30
PHP-PDO应用详解版.doc
Elasticsearch介绍和安装
Dreamer.
01-11 267
1.Elasticsearch介绍和安装 用户访问我们的首页，一般都会直接搜索来寻找自己想要购买的商品。 而商品的数量非常多，而且分类繁杂。如果能正确的显示出用户想要的商品，并进行合理的过滤，尽快促成交易，是搜索系统要研究的核心。 面对这样复杂的搜索业务和数据量，使用传统数据库搜索就显得力不从心，一般我们都会使用全文检索技术，比如之前大家学习过的Solr。 不过今天，我们要讲的是另一个全文检索技术...
elastaticsearch
weixin_30794851的博客
10-09 294
# https://elasticsearch-dsl.readthedocs.io/en/latest/ # 文档：https://es.xiaoleilu.com/054_Query_DSL/70_Important_clauses.html # https://www.cnblogs.com/dplearning/p/5975158.html 转载于:https://www.cnblo...
elastatic search 查询语法
zhongyuan_1990的专栏
09-19 4845
es中的数据可以分为两种：一种是准确值；一种是全文检索值。 全文搜索使用分词器。es提供多种分词器。 分词器的作用简单描述： 比如文档q有一个字段date 值为2016-03-28. 如果是准确值，将会存储为2016-03-28；如果使用分词器，将存储为，2016，03，28 这样如果查询GET /_search?q=2016,所有文档将匹配。查询GET
搜索引擎ElastaticSearch使用
qq_21703795的博客
07-15 632
elastaticsearch使用教程
TCP-IP详解卷
02-03
TCP-IP详解卷一：协议&TCP-IP详解卷二：实现&TCP-IP详解卷3-TCP协议
TCP-ip详解
03-10
TCP-ip详解 典藏
tcp-ip详解全集答案
02-08
tcp-ip非常经典的基础教学答案
TCP-IP详解卷123
12-29
TCP-IP详解卷123
ElastaticSearch的入门使用
qq_44407617的博客
04-27 3576
1.es的概念 –es是一个基于luence的全文检索框架 –特点是操作简单、不需要繁琐的配置，支持分布式、集群，可以以JSON格式来操作，可以以restful风格来操作。 –和es类似的框架还有solr,solr是一个重量级框架，功能比es丰富一些，但是实时搜索上面比es弱一些。 2.es的安装 –es的安装，在官网下载解压即可：https://www.elastic.co/downloads/...
elastaticsearch 插件的安装
zyb378747350的专栏
06-08 952
elastaticsearch 插件的安装
大数据存储框架之Elastaticsearch权威指南阅读(1) 基础篇(1) 集群内原理
风景旧曾谙
12-12 565
本文地址: 大数据存储框架之Elastaticsearch权威指南阅读(1) 基础篇(1) 集群内原理 ElasticSearch 的主旨是随时可用和按需扩容。 而扩容可以通过购买性能更强大（ 垂直扩容 ，或 纵向扩容 ） 或者数量更多的服务器（ 水平扩容 ，或 横向扩容 ）来实现。 虽然 Elasticsearch 可以获益于更强大的硬件设备，但是垂直扩容是有极限的。 真正的扩容能力是来自于...
大数据存储框架之Elastaticsearch(4) 提升性能
风景旧曾谙
12-18 825
原文地址：大数据存储框架之Elastaticsearch(4) 提升性能 本篇博文主要内容： 批量处理、多条获取和多条搜索API接口 刷新、冲刷、合并和存储 过滤器缓存和过滤器调优 调优脚本 查询预热器 均衡JVM堆大小和操作系统缓存 前言 Elastaticsearch 在进行做进行索引，搜索和抽取统计数值的聚集操作时，通常被认为是很快的。“快”是个模糊的概念。...
一文掌握ElastiscSearch
a805814077的博客
11-27 1744
ElastiscSearch入门，包括各种操作，都整合到这一篇文章里了
ElastaticSearch ---- es基础概念及命令
一生编程，快乐编程
11-12 390
Elasticsearch 是一个高度可扩展且开源的全文检索和分析引擎。可以快速且近实时地存储，检索以及分析海量数据。
ElastaticSearch学习笔记
liuqinhou的博客
05-14 83
查询具体某个索引内所有数据。查询项目下所有索引信息。
ElastaticSearch--- es多字段聚合
最新发布
一生编程，快乐编程
11-13 720
在使用es时，我们经常会用到聚合查询。简单的聚合查询，已经在前面介绍过，详情见： https://www.cnblogs.com/expiator/p/13843969.html有时，也会用到多字段聚合查询。类似于Mysql的Group By多个字段。比如，查询统计各个地区的各个日期，各自的订单总量。
elasticsearch 同义词搜索词_ES(Elasticsearch)支持PB级全文搜索引擎入门教程
weixin_39665992的博客
11-29 234
全文搜索属于最常见的需求，开源的 Elasticsearch （以下简称 Elastic）是目前全文搜索引擎的首选。它可以快速地储存、搜索和分析海量数据。比如维基百科、Stack Overflow、Github 都采用它。Elastic 的底层是开源库 Lucene。但是，你没法直接用 Lucene，必须自己写代码去调用它的接口。Elastic 是 Lucene 的封装，提供了 REST API ...
PL-Pro软件说明施耐德完美版资料.ppt
11-14
"PL-Pro软件是施耐德电气推出的一款专门用于编程和管理PLC程序的应用，该软件提供了全面的功能，如应用程序管理、浏览、创建、编辑和工具使用。它支持Windows 32位系统，应用程序以单一的.stx文件格式存储。软件允许...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值