ElasticSearch（项目中常用的ES）

已于 2022-10-02 21:23:56 修改
阅读量1k 收藏 1
点赞数
文章标签： elasticsearch java 大数据
于 2022-10-02 20:32:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43210794/article/details/127145584
版权

目录

一、操作索引库（用不到）

1.判断索引库是否存在

2.删除索引库

3.创建索引库

4.小结

二、操作文档（重点）

1.新增文档（数据库新增数据的时候  同步es索引库）

2.查询文档

3.修改文档

4.删除文档

5.批量操作(用于把所有数据的数据同步到ES索引库，先查询出所有然后一条条添加)

6.小结

三、查询文档

1.查询所有

2.全文检索

3.精确查询

①词条查询

②范围查询

4.地理查询

①矩形范围

②圆形范围

5.算分函数 （增加分值，让分值大于别人，排名时会在最前面）

6.复合查询（用于有多个查询条件的时候）

7.排序、分页

8.高亮（几乎所有搜索项目都要加）

四、项目实例，建议直接跳转

零、实现搜索业务，肯定离不开RestHighLevelClient，我们需要把它注册到Spring中作为一个Bean。

@Bean
public RestHighLevelClient client(){
    return new RestHighLevelClient(RestClient.builder(
        HttpHost.create("http://192.168.136.134:9200")
    ));
}

一、操作索引库（用不到）

1.判断索引库是否存在

@Test
void testExistsHotelIndex() throws IOException {
    // 1.创建Request对象
    GetIndexRequest request = new GetIndexRequest("hotel");
    // 2.发送请求
    boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
    // 3.输出
    System.err.println(exists ? "索引库已经存在！" : "索引库不存在！");
}

2.删除索引库

@Test
void testDeleteHotelIndex() throws IOException {
    // 1.创建Request对象
    DeleteIndexRequest request = new DeleteIndexRequest("hotel");
    // 2.发送请求
    client.indices().delete(request, RequestOptions.DEFAULT);
}

3.创建索引库

@Test
void createHotelIndex() throws IOException {
    // 1.创建Request对象
    CreateIndexRequest request = new CreateIndexRequest("hotel");
    // 2.准备请求的参数：DSL语句
    request.source(HotelConstants.MAPPING_TEMPLATE, XContentType.JSON);
    // 3.发送请求
    client.indices().create(request, RequestOptions.DEFAULT);
}

4.小结

索引库操作的基本步骤：

- 初始化`RestHighLevelClient`
- 创建`XxxIndexRequest`。XXX是Get、Create、Delete
- 准备参数（Create需要）
- 发送请求。调用`RestHighLevelClient.indices().xxx()`方法，xxx是exists、create、delete

二、操作文档（重点）

1.新增文档（数据库新增数据的时候  同步es索引库）

    //添加文档
    @Test
    public void testAddDocument() throws Exception {
        //1 准备文档数据
        // 1-1 根据id查询酒店数据
        Hotel hotel = hotelMapper.selectById(61083L);
        // 1-2 转为文档实体类型
        HotelDoc hotelDoc = new HotelDoc(hotel);
        // 1-3 将hotelDoc转为json
        String json = JSON.toJSONString(hotelDoc);

        //2 创建request
        IndexRequest request = new IndexRequest("hotel").id(hotelDoc.getId().toString());
        request.source(json, XContentType.JSON);

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

2.查询文档

    //根据id查询文档
    @Test
    public void testGetDocumentById()throws Exception{
        // 1.创建request
        GetRequest request = new GetRequest("hotel", "61083");
        // 2.发送请求，得到响应
        GetResponse response = client.get(request, RequestOptions.DEFAULT);
        // 3.解析响应
        String json = response.getSourceAsString();
        // 4.json转为hotelDoc
        HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
        System.out.println(hotelDoc);
    }

3.修改文档

    //根据id修改指定文档
    @Test
    public void testUpdateDocument() throws Exception {
        // 1.创建request
        UpdateRequest request = new UpdateRequest("hotel", "61083");
        //2. 设置更新内容
        Map<String, Object> map = new HashMap<>();
        map.put("price", 339);
        map.put("starName", "四钻");
        request.doc(map);
        // 3.发送请求
        client.update(request, RequestOptions.DEFAULT);
    }

4.删除文档

    //删除文档
    @Test
    void testDeleteDocument() throws IOException {
        // 1.创建Request
        DeleteRequest request = new DeleteRequest("hotel", "61083");
        // 2.发送请求
        client.delete(request, RequestOptions.DEFAULT);
    }

5.批量操作(用于把所有数据的数据同步到ES索引库，先查询出所有然后一条条添加)

	//批量操作
    @Test
    public void testBulkRequest() throws Exception {
        // 查询所有酒店数据
        List<Hotel> hotelList = hotelMapper.selectList(null);

        // 1.创建request
        BulkRequest request = new BulkRequest();
        // 2.准备DSL
        for (Hotel hotel : hotelList) {
            // 2-1 转为文档类型
            HotelDoc hotelDoc = new HotelDoc(hotel);
            // 2-2 转为json
            String json = JSON.toJSONString(hotelDoc);
            // 2-3 新增document
            request.add(
                    new IndexRequest("hotel")
                            .id(hotelDoc.getId().toString())
                            .source(json, XContentType.JSON)
            );
        }
        // 3.发送请求
        client.bulk(request, RequestOptions.DEFAULT);
    }

6.小结

文档操作的基本步骤：

- 初始化`RestHighLevelClient`
- 创建`XxxRequest`。XXX是Index、Get、Update、Delete、Bulk
- 准备参数（Index、Update、Bulk时需要）
- 发送请求。调用`RestHighLevelClient..xxx()`方法，xxx是index、get、update、delete、bulk
- 解析结果（Get时需要）

三、查询文档

1.查询所有

    //查询
    @Test
    public void testMatchAll() throws IOException {
        //1. 构建查询请求
        SearchRequest request = new SearchRequest("hotel");

        //2. 设置查询条件
        request.source().query(
                QueryBuilders.matchAllQuery() //match_all
        );

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

        //4. 解析结果
        System.out.println("结果数量:" + response.getHits().getTotalHits().value);//hits.total.value
        SearchHit[] searchHitArr = response.getHits().getHits();
        for (SearchHit searchHit : searchHitArr) {
            String source = searchHit.getSourceAsString();//hits.hits.get(n).source
            System.out.println(JSON.parseObject(source, HotelDoc.class));
        }
    }


elasticsearch返回的结果是一个JSON字符串，结构包含：

- `hits`：命中的结果
 - `total`：总条数，其中的value是具体的总条数值
 - `max_score`：所有结果中得分最高的文档的相关性算分
 - `hits`：搜索结果的文档数组，其中的每个文档都是一个json对象
   - `_source`：文档中的原始数据，也是json对象

因此，我们解析响应结果，就是逐层解析JSON字符串，流程如下：

- `SearchHits`：通过response.getHits()获取，就是JSON中的最外层的hits，代表命中的结果
 - `SearchHits.getTotalHits().value`：获取总条数信息
 - `SearchHits.getHits()`：获取SearchHit数组，也就是文档数组
   - `SearchHit.getSourceAsString()`：获取文档结果中的_source，也就是原始的json文档数据

2.全文检索

    //查询 match
    @Test
    public void testMatch() throws IOException {
        //1. 构建查询请求
        SearchRequest request = new SearchRequest("hotel");

        //2. 设置查询条件
        request.source().query(
                QueryBuilders.matchQuery("all", "外滩如家") //match
        );

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

        //4. 解析结果
        System.out.println("结果数量:" + response.getHits().getTotalHits().value);
        SearchHit[] searchHitArr = response.getHits().getHits();
        for (SearchHit searchHit : searchHitArr) {
            String source = searchHit.getSourceAsString();
            System.out.println(JSON.parseObject(source, HotelDoc.class));
        }
    }

    //查询 multi_match
    @Test
    public void testMultiMatch() throws IOException {
        //1. 构建查询请求
        SearchRequest request = new SearchRequest("hotel");

        //2. 设置查询条件
        request.source().query(
                QueryBuilders.multiMatchQuery("外滩如家", "brand", "business", "name")
        );

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

        //4. 解析结果
        System.out.println("结果数量:" + response.getHits().getTotalHits().value);
        SearchHit[] searchHitArr = response.getHits().getHits();
        for (SearchHit searchHit : searchHitArr) {
            String source = searchHit.getSourceAsString();
            System.out.println(JSON.parseObject(source, HotelDoc.class));
        }
    }

3.精确查询

①词条查询

    //词条查询 term
    @Test
    public void testTerm() throws IOException {
        //1. 构建查询请求
        SearchRequest request = new SearchRequest("hotel");

        //2. 设置查询条件
        request.source().query(
                QueryBuilders.termQuery("city", "北京")
        );

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

        //4. 解析结果
        System.out.println("结果数量:" + response.getHits().getTotalHits().value);
        SearchHit[] searchHitArr = response.getHits().getHits();
        for (SearchHit searchHit : searchHitArr) {
            String source = searchHit.getSourceAsString();
            System.out.println(JSON.parseObject(source, HotelDoc.class));
        }
    }

②范围查询

//范围查询 range
@Test
public void testRange() throws IOException {
    //1. 构建查询请求
    SearchRequest request = new SearchRequest("hotel");

    //2. 构建条件,并添加到查询请求
    request.source().query(
                rangeQuery("price").gte(1000).lte(2000)
    );

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

    //4. 解析结果
    System.out.println("结果数量:" + response.getHits().getTotalHits().value);
    SearchHit[] searchHitArr = response.getHits().getHits();
    for (SearchHit searchHit : searchHitArr) {
        String source = searchHit.getSourceAsString();
        System.out.println(JSON.parseObject(source, HotelDoc.class));
    }
}

4.地理查询

①矩形范围

   //矩形范围查询 geo_bounding_box
    @Test
    public void testGeoBoundingBox() throws IOException {
        //1. 构建查询请求
        SearchRequest request = new SearchRequest("hotel");

        //2. 设置查询条件
        request.source().query(
                QueryBuilders.geoBoundingBoxQuery("location")
                        .setCorners(new GeoPoint(40.08, 116.47), new GeoPoint(39.9, 116.405))
        );

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

        //4. 解析结果
        System.out.println("结果数量:" + response.getHits().getTotalHits().value);
        SearchHit[] searchHitArr = response.getHits().getHits();
        for (SearchHit searchHit : searchHitArr) {
            String source = searchHit.getSourceAsString();
            System.out.println(JSON.parseObject(source, HotelDoc.class));
        }
    }

②圆形范围

    //矩形圆形查询 geo_distance
    @Test
    public void testGeoDistance() throws IOException {
        //1. 构建查询请求
        SearchRequest request = new SearchRequest("hotel");

        //2. 设置查询条件
        request.source().query(
                QueryBuilders.geoDistanceQuery("location")
                        .point(39.9, 116.405)//设置圆心坐标
                        .distance("15km")//设置半径
        );

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

        //4. 解析结果
        System.out.println("结果数量:" + response.getHits().getTotalHits().value);
        SearchHit[] searchHitArr = response.getHits().getHits();
        for (SearchHit searchHit : searchHitArr) {
            String source = searchHit.getSourceAsString();
            System.out.println(JSON.parseObject(source, HotelDoc.class));
        }
    }

5.算分函数 （增加分值，让分值大于别人，排名时会在最前面）

    //算分函数
    @Test
    public void testFunctionScore() throws IOException {
        //1. 构建查询请求
        SearchRequest request = new SearchRequest("hotel");

        //2. 设置查询条件
        request.source().query(
                QueryBuilders.functionScoreQuery(
                        QueryBuilders.matchQuery("all", "北京"),//设置查询条件
                        new FunctionScoreQueryBuilder.FilterFunctionBuilder[]{ //设置算分函数
                                new FunctionScoreQueryBuilder.FilterFunctionBuilder(
                                        QueryBuilders.termQuery("brand", "凯悦"),
                                        ScoreFunctionBuilders.weightFactorFunction(10)
                                )

                        }
                ).boostMode(CombineFunction.MULTIPLY) //设置算法策略
        );

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

        //4. 解析结果
        System.out.println("结果数量:" + response.getHits().getTotalHits().value);
        SearchHit[] searchHitArr = response.getHits().getHits();
        for (SearchHit searchHit : searchHitArr) {
            String source = searchHit.getSourceAsString();
            System.out.println(JSON.parseObject(source, HotelDoc.class));
        }
    }

6.复合查询（用于有多个查询条件的时候）

    //布尔查询
    @Test
    public void testBoolean() throws IOException {
        //1. 构建查询请求
        SearchRequest request = new SearchRequest("hotel");

        //2. 设置查询条件
        request.source().query(
                QueryBuilders.boolQuery().must(
                        QueryBuilders.termQuery("name", "如家")
                ).mustNot(
                        QueryBuilders.rangeQuery("price").gte(400)
                ).filter(
                        QueryBuilders.geoDistanceQuery("location")
                                .point(39.9, 116.405)//设置圆心坐标
                                .distance("10km")//设置半径
                )
        );

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

        //4. 解析结果
        System.out.println("结果数量:" + response.getHits().getTotalHits().value);
        SearchHit[] searchHitArr = response.getHits().getHits();
        for (SearchHit searchHit : searchHitArr) {
            String source = searchHit.getSourceAsString();
            System.out.println(JSON.parseObject(source, HotelDoc.class));
        }
    }

7.排序、分页

 	// 排序 分页
    @Test
    public void testPageAndSort() throws IOException {
        //1. 构建查询请求
        SearchRequest request = new SearchRequest("hotel");

        //2. 设置查询条件
        request.source().query(QueryBuilders.matchAllQuery());
        request.source().sort("price", SortOrder.ASC);//排序,按照价格正序排
        request.source().from(0).size(10);//分页,从0查,查10个;

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

        //4. 解析结果
        System.out.println("结果数量:" + response.getHits().getTotalHits().value);
        SearchHit[] searchHitArr = response.getHits().getHits();
        for (SearchHit searchHit : searchHitArr) {
            String source = searchHit.getSourceAsString();
            System.out.println(JSON.parseObject(source, HotelDoc.class));
        }
    }

8.高亮（几乎所有搜索项目都要加）

    //高亮
    @Test
    public void testHighLight() throws IOException {
        //1. 构建查询请求
        SearchRequest request = new SearchRequest("hotel");

        //2. 设置查询条件
        request.source().query(QueryBuilders.matchQuery("all", "如家"));

        //3. 设置高亮效果
        request.source().highlighter(
                new HighlightBuilder()
                        .field("name")
                        .preTags("<em>")
                        .postTags("</em>").
                        requireFieldMatch(false)
        );

        //4. 执行请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);

        //5. 解析结果
        SearchHit[] searchHits = response.getHits().getHits();
        for (SearchHit searchHit : searchHits) {
            //没有效果的对象
            HotelDoc hotelDoc = JSON.parseObject(searchHit.getSourceAsString(), HotelDoc.class);
            //解析效果,替换上面对象中的title的值
            String name = (searchHit.getHighlightFields().get("name").getFragments())[0].toString();
            hotelDoc.setName(name);

            System.out.println(hotelDoc);
        }
    }

四、项目实例，建议直接跳转

    @Override
    public PageResult list(RequestParams requestParams) throws IOException {

        //1. 构建查询请求
        SearchRequest request = new SearchRequest("hotel");

        //2. 设置查询条件
        //2-1创建复合查询
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();

        //2-2 获取搜索关键字, 设置为查询条件
        String key = requestParams.getKey();
        if (StringUtils.isEmpty(key)) {
            boolQuery.must(QueryBuilders.matchAllQuery());
        } else {
            boolQuery.must(QueryBuilders.matchQuery("all", key));
        }

        //2-3 获取城市、星级、品牌、价格，使用过滤语法筛选
        // 城市
        if (StrUtil.isNotEmpty(requestParams.getCity())) {
            boolQuery.filter(QueryBuilders.termQuery("city", requestParams.getCity()));
        }
        // 星级
        if (StrUtil.isNotEmpty(requestParams.getStarName())) {
            boolQuery.filter(QueryBuilders.termQuery("starName", requestParams.getStarName()));
        }
        // 品牌
        if (StrUtil.isNotEmpty(requestParams.getBrand())) {
            boolQuery.filter(QueryBuilders.termQuery("brand", requestParams.getBrand()));
        }
        // 价格
        if (requestParams.getMinPrice() != null && requestParams.getMaxPrice() != null) {
            boolQuery.filter(QueryBuilders.rangeQuery("price").gte(requestParams.getMinPrice()).lte(requestParams.getMaxPrice()));
        }

        //2-4 使用算分函数 提供广告酒店的排名
        FunctionScoreQueryBuilder functionScoreQuery = QueryBuilders.functionScoreQuery(boolQuery,
                new FunctionScoreQueryBuilder.FilterFunctionBuilder[]{
                        new FunctionScoreQueryBuilder.FilterFunctionBuilder(
                                QueryBuilders.termQuery("isAD", true),
                                ScoreFunctionBuilders.weightFactorFunction(5))
                }
        );

        request.source().query(functionScoreQuery);

        //3. 设置分页
        Integer pageNum = requestParams.getPage();
        Integer pageSize = requestParams.getSize();
        request.source().from((pageNum - 1) * pageSize).size(pageSize);

        //4. 设置排序
        String location = requestParams.getLocation();
        if (StrUtil.isNotEmpty(location)) {
            request.source().sort(
                    SortBuilders.geoDistanceSort("location", new GeoPoint(location))//设置核心坐标位置
                            .order(SortOrder.ASC) //设置排序方式
                            .unit(DistanceUnit.KILOMETERS)// 单位
            );
        }

        //5. 设置高亮
        request.source().highlighter(
                new HighlightBuilder().field("name").requireFieldMatch(false)
        );

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

        //7. 处理结果
        return handleResponse(response);
    }

五、没用

# 测试默认分词器
GET /_analyze
{
  "analyzer": "standard",
  "text": "程序员学习java太棒了"
}


# 测试IK分词器
GET /_analyze
{
  "analyzer": "ik_smart",
  "text": "程序员学习java太棒了"
}

GET /_analyze
{
  "analyzer": "ik_max_word",
  "text": "程序员学习java太棒了"
}


GET /_analyze
{
  "analyzer": "ik_max_word",
  "text": "程序员的Java就业超过90%,奥力给了！"
}



# 创建索引库
PUT /course

# 查看索引库
GET /course

# 删除索引库
DELETE /course






# 创建索引库
PUT /course
# 自定义映射
PUT /course/_mapping/
{
  "properties":{
    "title":{
      "type":"text",
      "analyzer":"ik_max_word"
    },
    "images":{
      "type":"keyword",
      "index":false
    },
    "price":{
      "type":"float"
    },
    "name":{
      "properties":{
        "firstName":{
          "type":"keyword"
        },
        "lastName":{
          "type":"keyword"
        }
      }
    }
  }
}
# 查看映射
GET /course/_mapping

 
 
# 创建索引库的时候同时设置映射
PUT /course/
{
  "mappings": {
      "properties":{
      "title":{
        "type":"text",
        "analyzer":"ik_max_word"
      },
      "images":{
        "type":"keyword",
        "index":false
      },
      "price":{
        "type":"float"
      },
      "name":{
        "properties":{
          "firstName":{
            "type":"keyword"
          },
          "lastName":{
            "type":"keyword"
          }
        }
      }
    }
  }
}


# 创建文档
POST /course/_doc/1
{
  "title":"小米手机",
  "price":2000,
  "images":"http://image.xiaomi.com/1.jpg",
  "name":{
    "firstName":"三",
    "lastName":"张"
  }
}

# 创建文档
POST /course/_doc
{
  "title":"华为手机",
  "price":3000,
  "images":"http://image.huawei.com/1.jpg",
  "name":{
    "firstName":"四",
    "lastName":"李"
  }
}


# 根据主键查询
GET /course/_doc/1
GET /course/_doc/Wn37GoMBJhQmYmwV_1pK


# 全量修改,语法跟新增一致
POST /course/_doc/1
{
  "title":"小米手机",
  "price":2500,
  "images":"http://image.xiaomi.com/1.jpg",
  "name":{
    "firstName":"三",
    "lastName":"张"
  }
}


# 增量修改 
POST /course/_update/1
{
  "doc": {
      "title":"大米手机",
      "price":2500
  }
}


# 删除
DELETE /course/_doc/1



# 查询所有
GET /hotel/_search
{
  "query": {
    "match_all": {}
  }
}


# 全文检索(分词) 针对于一个字段
GET /hotel/_search
{
  "query": {
    "match": {
      "all": "外滩如家"
    }
  }
}

# 全文检索(分词) 针对于多个字段
GET /hotel/_search
{
  "query": {
    "multi_match": {
      "query": "外滩如家",
      "fields": ["name","brand","business"]
    }
  }
}

# 精确查询(term)
GET /hotel/_search
{
  "query": {
    "term": {
      "city": {
        "value": "北京"
      }
    }
  }
}

# 精确查询(range)
GET /hotel/_search
{
  "query": {
    "range": {
      "price": {
        "gte": 1000,
        "lte": 2000
      }
    }
  }
}


# 矩形范围
GET /hotel/_search
{
  "query": {
    "geo_bounding_box":{
      "location": {
        "top_left": {
          "lat": 40.08,
          "lon": 116.47
        },
        "bottom_right": {
          "lat": 39.9,
          "lon": 116.405
        }
      }
    }
  }
}


# 圆形范围
GET /hotel/_search
{
  "query": {
    "geo_distance":{
      "distance":"15km",
      "location":"39.9,116.405"
    }
  }
}




# 默认查询
GET /hotel/_search
{
  "query": {
    "match": {
      "all": "北京"
    }
  }
}

# 算分函数查询
GET /hotel/_search
{
  "query": {
    "function_score": {
      "query": {
        "match": {
          "all": "北京"
        }
      },
      "functions": [
        {
          "filter": {
            "term": {
              "brand": "凯悦"
            }
          },
          "weight": 20
        }
      ],
      "boost_mode": "multiply"
    }
  }
}

# 复合查询
# 需求：搜索名字包含“如家”，价格不高于400，在坐标39.9,116.405周围10km范围内的酒店
GET /hotel/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "term": {
            "name": {
              "value": "如家"
            }
          }
        }
      ],
      "must_not": [
        {
          "range": {
            "price": {
              "gt": 400
            }
          }
        }
      ],
      "filter": [
        {
          "geo_distance": {
            "distance": "10km",
            "location": {
              "lat": 39.9,
              "lon": 116.405
            }
          }
        }
      ]
    }
  }
}


# 按照价格正序排列
GET /hotel/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "price": {
        "order": "asc"
      }
    },
    {
      "score": "desc"
    }
  ]
}


# 按照距离远近排列(需要指定的是参考点)
GET /hotel/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "_geo_distance": {
        "location": {
          "lat": 39.91512,
          "lon": 116.40396
        },
        "order": "asc"
      }
    }
  ]
}


# 分页
GET /hotel/_search
{
  "query": {
    "match_all": {}
  },
  "from": 9990,
  "size": 11
}


# 高亮
GET /hotel/_search
{
  "query": {
    "match": {
      "name": "如家"
    }
  },
  "highlight": {
    "fields": {
      "name":{
        "pre_tags":"<em>",
        "post_tags":"</em>"
      }

    }
  }
}
GET /hotel/_search
{
  "query": {
    "match": {
      "all": "如家"
    }
  },
  "highlight": {
    "fields": {
      "name":{
        "pre_tags":"<i>",
        "post_tags":"</i>",
        "require_field_match": "false"
      }

    }
  }
}



#聚合为桶
GET /hotel/_search
{
  "query":{ //搜索条件
      "range": {
          "price":{
            "lte": 500
          } 
      }
  }, 
  "size": 0, //不查询具体的数据  
  "aggs": { //声明这是一个聚合查询，是aggregations的缩写
    "brandAgg": { //给这次聚合起一个名字，可任意指定
      "terms": { //聚合的类型，这里选择terms，是根据词条内容（这里是品牌）划分
        "field": "brand", //按照哪个字段分组
        "size": 10, //显示多少条聚合结果  
        "order": {
           "_count": "asc" //分组之后可以根据数量排序
        }
      }
    }
  }
}


#桶内度量
GET /hotel/_search
{
  "query":{
      "match_all": {}
  }, 
  "size": 0, //不查询具体的数据    
  "aggs": {
    "brandAgg": {
      "terms": {
        "field": "brand", //按照哪个字段分组
        "order": {
           "scoreAgg.avg": "desc" //根据指定的统计项排序
        }
      },
      "aggs":{  //是brands聚合的子聚合，也就是分组后对每组分别计算
          "scoreAgg": {//聚合名称
            "stats": {//聚合类型，这里stats可以计算min、max、avg等
              "field":"score"//聚合字段，这里是score
            }
          }
        }
    }
  }
}



# 设置分词器
PUT /test
{
  "settings": {
    "analysis": {
      "analyzer": { 
        "my_analyzer": { 
          "tokenizer": "ik_max_word",
          "filter": "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": {
      "name":{
        "type": "text",
        "analyzer": "my_analyzer",
        "search_analyzer": "ik_smart"
      }
    }
  }
}

# 创建模拟数据
POST /test/_doc/1
{
  "id": 1,
  "name": "狮子"
}
POST /test/_doc/2
{
  "id": 2,
  "name": "虱子"
}

# 重新查询
GET /test/_search
{
  "query": {
    "match": {
      "name": "shizi"
    }
  }
}

GET /test/_search
{
  "query": {
    "match": {
      "name": "狮子"
    }
  }
}

pandied
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【ElasticSearch】es简单使用
海棠不惜胭脂色，独立蒙蒙细雨中
08-23 7011
es可以做到多字段模糊搜索，因其易用，被广大研发人员使用，最近小编就接到模糊搜索的需求，之前用过solr，通过看搜索引擎使用热度和排名，es近几年明显上升，小编公司所用也是es，那便来看看我们如何使用吧，本篇只做简单介绍es的使用方法，以及效果，关于原理小编日后补充。 es现在已有6.x版本，我们项目用的是5.5.3版本，更低版本的使用方式和高版本不太一样，这个大家注意下，可能影响到后来的使用。 ...
【Elasticsearch】ES常用命令
superone52033的博客
01-17 876
elasticsearch(es)常用指令
面试题：项目中是如何使用ES(elasticsearch)的？如何优化的？数据量多少？
weixin_43861391的博客
04-16 4191
面试题：项目中是如何使用ES(elasticsearch)的？如何优化的？数据量多少？
ElasticSearch读取查询结果（search）
热门推荐
节至
06-17 1万+
在es中所有的查询结果都会保存在SearchResponse中，在从SearchResponse中读取数据的时候，有两种方式：第一种是对Query的结果进行读取，使用的是hit，每一条查询到的doc都是一个hit，可以将每个hit转换为map形式的数据，map的具体形式为的形式，可以得到每一个字段的名称与内容（具体代码如下）； public static List getSC(Searc
Elasticsearch 零停机索引维护的3种方案
.
01-09 1284
Elasticsearch 零停机索引维护的3种方案 前言 业务开发中诸如一些表的字段更改，增加字段，我们需要将表进行增加字段，删除字段，也可能会重新建表将数据重新放入另一张表等等重建表的一些操作，对此es中我们也需要进行数据更新，或者说数据同步操作。 那么es中我们如何操作呢？ 常规的做法是新建index 然后重新将数据写到es中 可以使用java同步操作一遍读一遍写 也可以使用一些中间件mq异步写入es 也可以从es中查询出数据，然后写到es中，中间做一些数据或者类型的改变重新插入index中，这也是一
解决ES searchHit.getHighlightFields()输出null数据到前端
m0_46378271的博客
07-25 2217
SearchHit类的hit对象是由search.getHits()得到的，而search是一个SearchResponse类。我们进入SearchHit类中查看hit.getHighlightFields()方法的源码，发现由于。最后不加高亮操作，直接转为json，然后转为对象，前端也正常了。发现其getHits()是另一个类中的hit()因此这里的Map自然也就什么都接不到了，此时的hit是一个SearchHit对象。，经过调试排查发现获取为null。，此方法会返回null。分页，遍历搜索的结果。...
ES6.6.2 使用小结 - 封装ES常用的查询方法
BAStriver的博客
03-26 1219
1.首先，接下来的查询demo里面包含了10常用的方法：term查询、terms查询、range查询、exists查询、prefix查询、wildcard查询、regexp查询、fuzzy查询、type查询、ids查询。 2.以下是封装了10个常用方法的QueryUtil： package com.bas.util; import org.elasticsearch.action.sear...
ES查询客户端，elasticsearch可视化工具 elasticsearch查询客户端
06-20
**Elasticsearch查询客户端与可视化工具** Elasticsearch（简称ES）是一款强大的开源搜索引擎，广泛应用于数据检索、分析...正确选择和使用这些工具，能帮助开发者更好地管理和利用存储在Elasticsearch中的海量数据。
springboot整合es-springboot-elasticsearch.zip
11-07
1. **添加依赖**：在SpringBoot项目的pom.xml文件中，引入Elasticsearch的Spring Data Elasticsearch依赖。确保版本与Elasticsearch服务器版本匹配。 ```xml <groupId>org.springframework.boot <artifactId>...
es(elasticsearch)整合SpringCloud（SpringBoot）搭建教程详解
08-19
在本教程中，我们将探讨如何将Elasticsearch与SpringBoot和SpringCloud进行集成，以便在微服务架构中利用Elasticsearch强大的搜索和分析能力。Elasticsearch是一个分布式、RESTful风格的搜索和数据分析引擎，而...
ElasticSearch基于Mysql热更新IK词典项目
10-31
IK分词器是Elasticsearch中针对中文处理的重要插件，它提供了智能中文分词能力，支持自定义扩展词库。IK的主要特点有： 1. 灵活的分词策略：包括精确模式、全模式、最短路径模式等。 2. 实时热更新：可以通过配置...
flink-es7:为了使用Elasticsearch连接器，使用构建自动化工具(如Maven或SBT)的两个项目和带有SQL
04-12
flink-es7:为了使用Elasticsearch连接器，使用构建自动化工具(如Maven或SBT)的两个项目和带有SQL
Elastic Search 学习入门之Search全文检索(七)
Ran_记忆犹新的博客
12-10 2440
ES是基于Lucene的开源搜索引擎，其查询语法关键字部分和Lucene大致一样： 分页： from/size、字段：fields、排序：sort、查询：query 过滤：filter、高亮：highlight、统计：facet ES的搜索类型有4种(以下说明是基于elasticsearch2.3): query and fetch (速度最快)(返回N倍数据量)     受保护，5.3之...
elasticsearch
lemonth的博客
08-07 491
下载地址：https://www.elastic.co/cn/downloads/past-releases#elasticsearch \下载地址Releases · medcl/elasticsearch-analysis-ik · GitHub #创建索引库 PUT person {  "settings": {     "number_of_shards": 5,     "number_of_
elasticsearch教你使用搜索引擎
longtangbin的博客
10-14 495
1) 熟悉ES Java客户端版本特性 2) 掌握常用API操作 3) 安装、配置IK中文分词器 Java客户端 默认es启动后对外开放2个端口号：9200,9300 9200 对应的是http协议 restful api调用 9300 对应的是tcp协议 java 客户端、内部通信 请注意如果使用java客户端，默认的连接端口号是9300，一定请注意，注意，注意！！ 一定要开防火墙！！！...
ElasticSearch中查询后只显示10个结果的问题
yuntianyun的博客
03-11 7838
在kibana里的查询语句 GET /movie_2021-03-11/_search 得到的结果是： { "took" : 2, "timed_out" : false, "_shards" : { "total" : 3, "successful" : 3, "skipped" : 0, "failed" : 0 }, "hits" : { "total" : 50, "max_score" : 1.0, "hits" : [
Elasticsearch分页解决方案研究
WorldMvp的专栏
11-12 4161
1.1 常见的分页方式：from+size elasticsearch默认采用的分页方式是from+size的形式。但是，在深度分页的情况下，这种使用方式的效率是非常低的，比如from=5000,size=10，es需要在各个分片上匹配排序并得到5000*10条有效数据，然后在结果集中取最后10条数据返回。除了会遇到效率上的问题，还有一个无法解决的问题：es目前支持最大的skip值是max_result_window（默认为10000），也就是说，当from+size > max_resul...
ES 16 - 查询Elasticsearch中的数据 (基于_search API进行检索)
xiangjai的专栏
10-16 1241
目录 1 Search API的基本用法 1.1 查询所有数据 1.2 响应信息说明 1.3 timeout超时机制 1.4 查询多索引和多类型中的数据 2 URI Search的用法 2.1 GET请求携带参数查询 2.2 URI Search的参数列表 2.3 URI Search用法示例 2.4 不指定field时的搜索原理 说在前面: 本文的所有演示, 都是基于Elasticsearch 6.6.0进行的, 不同的版本可能存在API发生修改、不支持的情况, 还请注意. .
Java 结合elasticsearch-ik分词器，实现评论的违规词汇脱敏等操作
最新发布
Rui_bbm的博客
08-28 417
然后可以直接在业务代码中使用工具类即可，注意入参是String，这里我的判断条件是大于0就是存在违规词汇，进行相关操作即可。我直接给相关核心代码封装成了工具类，上半部分代码是用于做分词的，会返回一个集合，这个集合里面存放的都是根据入参分出来的词。下半部分是根据分出来的词做一个检索操作，根据es的索引，检索与集合中词汇对应的敏感词。这个依赖是我使用的，可以结合自己的情况自己选择适用版本的相关依赖。话不多说，直接上后台代码。
ES-elasticsearch 常用语句
07-24
ES (Elasticsearch) 是由 Elasticsearch 公司提供的开源全文搜索及分析引擎，它基于 Lucene，用于构建高性能、分布式的大数据处理系统。ES 支持实时查询，并能高效地处理大量的日志、事件流和其他实时数据源。下面是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值