分布式搜索引擎02-elasticsearch-DSL查询文档(地理坐标查、算分函数查(竞价排名)、布尔查询)、搜索结果处理(排序(附近店)，分页、高亮)、RestClient(java代码实现搜索)

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

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

GET /indexName/_search

GET /indexName/_search
{
  "query": {
    "match": {
      "FIELD": "TEXT"
    }
  }
}

GET /indexName/_search
{
  "query": {
    "multi_match": {
      "query": "TEXT",
      "fields": ["FIELD1", " FIELD12"]
    }
  }
}

# match查询
GET /hotel/_search
{
  "query": {
    "match": {
      "all":"外滩如家"
    }
  }
}

// term查询
GET /indexName/_search
{
  "query": {
    "term": {
      "FIELD": {
        "value": "VALUE"
      }
    }
  }
}

// range查询
GET /indexName/_search
{
  "query": {
    "range": {
      "FIELD": {
        "gte": 10, // 这里的gte代表大于等于，gt则代表大于
        "lte": 20 // lte代表小于等于，lt则代表小于
      }
    }
  }
}

// geo_bounding_box查询
GET /indexName/_search
{
  "query": {
    "geo_bounding_box": {
      "FIELD": { // 字段名称 eg: location
        "top_left": { // 左上点
          "lat": 31.1,
          "lon": 121.5
        },
        "bottom_right": { // 右下点
          "lat": 30.9,
          "lon": 121.7
        }
      }
    }
  }
}

// geo_distance 查询
GET /indexName/_search
{
  "query": {
    "geo_distance": {
      "distance": "15km", // 半径
      "FIELD": "31.21,121.5" // 圆心
    }
  }
}

// geo_distance 查询  附近的人
GET /hotel/_search
{
  "query": {
    "geo_distance": {
      "distance": "15km", // 半径
      "location": "31.21,121.5" // 圆心
    }
  }
}

[
  {
    "_score" : 17.850193,
    "_source" : {
      "name" : "虹桥如家酒店真不错",
    }
  },
  {
    "_score" : 12.259849,
    "_source" : {
      "name" : "外滩如家酒店真不错",
    }
  },
  {
    "_score" : 11.91091,
    "_source" : {
      "name" : "迪士尼如家酒店真不错",
    }
  }
]

GET /hotel/_search
{
  "query": {
    "function_score": {
      "query": {  .... }, // 原始查询，可以是任意条件
      "functions": [ // 算分函数
        {
          "filter": { // 满足的条件，品牌必须是如家
            "term": {
              "brand": "如家"
            }
          },
          "weight": 2 // 算分权重为2
        }
      ],
      "boost_mode": "sum" // 加权模式，求和
    }
  }
}

GET /hotel/_search
{
  "query": {
    "function_score": {
      "query": {
        "match": {
          "all": "外滩"
        }
      }
    }
  }
}

# function score 查询 (竞价排名)
GET /hotel/_search
{
  "query": {
    "function_score": {
      "query": {
        "match": {
          "all": "外滩"
        }
      },
      "functions": [
        {
          "filter": {
            "term": {
              "brand": "如家"
            }
          },
          "weight": 10
          
        }
      ],
      "boost_mode": "sum"
    }
  }
}

GET /hotel/_search
{
  "query": {
    "bool": {
      "must": [
        {"term": {"city": "上海" }}
      ],
      "should": [
        {"term": {"brand": "皇冠假日" }},
        {"term": {"brand": "华美达" }}
      ],
      "must_not": [
        { "range": { "price": { "lte": 500 } }}
      ],
      "filter": [
        { "range": {"score": { "gte": 45 } }}
      ]
    }
  }
}

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

GET /indexName/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "FIELD": "desc"  // 排序字段、排序方式ASC、DESC
    }
  ]
}

# 结果排序
GET /hotel/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "score": "desc",
      "price": "asc"
    }
  ]
}

GET /indexName/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "_geo_distance" : {
          "FIELD" : "纬度，经度", // 文档中geo_point类型的字段名、目标坐标点
          "order" : "asc", // 排序方式
          "unit" : "km" // 排序的距离单位
      }
    }
  ]
}

# 结果排序 31.034661,121.612282周围的酒店，距离升序排序
GET /hotel/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "_geo_distance": {
        "location": {
          "lat": 31.034661,
          "lon": 121.612282
        },
        "order": "asc",
        "unit": "km"
      }
    }
  ]
}

GET /hotel/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "_geo_distance": {
        "location":"31.034661,121.612282",
        "order": "asc",
        "unit": "km"
      }
    }
  ]
}

GET /hotel/_search
{
  "query": {
    "match_all": {}
  },
  "from": 0, // 分页开始的位置，默认为0
  "size": 10, // 期望获取的文档总数
  "sort": [
    {"price": "asc"}
  ]
}

GET /hotel/_search
{
  "query": {
    "match_all": {}
  },
  "from": 990, // 分页开始的位置，默认为0
  "size": 10, // 期望获取的文档总数
  "sort": [
    {"price": "asc"}
  ]
}

GET /hotel/_search
{
  "query": {
    "match": {
      "FIELD": "TEXT" // 查询条件，高亮一定要使用全文检索查询  
    }
  },
  "highlight": {
    "fields": { // 指定要高亮的字段
      "FIELD": {
        "pre_tags": "<em>",  // 用来标记高亮字段的前置标签
        "post_tags": "</em>" // 用来标记高亮字段的后置标签
      }
    }
  }
}

# 高亮查询
GET /hotel/_search
{
  "query": {
    "match": {
      "all": "如家"
    }
  },
  "highlight": {
    "fields": {
      "name": {
        "require_field_match": "false"
      }
    }
  }
}

@Test
void testMatchAll() throws IOException {
    // 1.准备Request
    SearchRequest request = new SearchRequest("hotel");
    // 2.准备DSL
    request.source()
        .query(QueryBuilders.matchAllQuery());
    // 3.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);

    // 4.解析响应
    //System.out.println(response);//会发现直接把浏览器端返回的大json输出 也就是那个大json封装成一个完整的java对象response了       
    handleResponse(response);
}

private void handleResponse(SearchResponse response) {
    // 4.解析响应
    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) {
        // 获取文档source
        String json = hit.getSourceAsString();
        // 反序列化
        HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
        System.out.println("hotelDoc = " + hotelDoc);
    }
}

@Test
public void testMatch() throws IOException {
    //1.准备request
    SearchRequest request = new SearchRequest("hotel");
    //2.准备DSL
    //request.source().query(QueryBuilders.matchQuery("all","如家"));
    request.source().query(QueryBuilders.multiMatchQuery("如家","name","brand"));
    //3.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    //4.解析结果
    handleResponse(response);
}

@Test
public void testTerm() throws IOException {
    //1.准备request
    SearchRequest request = new SearchRequest("hotel");
    //2.准备DSL
    request.source().query(QueryBuilders.termQuery("brand","如家"));
    //3.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    //4.解析结果
    handleResponse(response);
}

@Test
public void testRange() throws IOException {
    //1.准备request
    SearchRequest request = new SearchRequest("hotel");
    //2.准备DSL
    request.source().query(QueryBuilders.rangeQuery("price").gte(100).lte(200));
    //3.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    //4.解析结果
    handleResponse(response);
}

@Test
public void testBoolean() throws IOException {
    //1.准备request
    SearchRequest request = new SearchRequest("hotel");

    //2.准备DSL
    // 2.1.准备BooleanQuery
    BoolQueryBuilder boolQuery = new BoolQueryBuilder();
    // 2.2.添加term
    boolQuery.must(QueryBuilders.termQuery("city","上海"));
    // 2.3.添加range
    boolQuery.filter(QueryBuilders.rangeQuery("price").lte(250));
    // 子查询(bool查询)条件打包好后 封装到request中
    request.source().query(boolQuery);

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

    //4.解析结果
    handleResponse(response);
}

@Test
public void testPageAndSort() throws IOException {
    int page = 2, size = 5;
    //1.准备request
    SearchRequest request = new SearchRequest("hotel");
    //2.准备DSL
    // 2.1 query
    request.source().query(QueryBuilders.matchAllQuery());
    // 2.2 排序
    request.source().sort("price", SortOrder.ASC);
    // 2.3 分页
    request.source().from((page-1)*size).size(size);
    //3.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    //4.解析结果
    handleResponse(response);
}

@Test
public void testHighlight() throws IOException {
    //1.准备request
    SearchRequest request = new SearchRequest("hotel");
    //2.准备DSL
    // 2.1 query //高亮查询不能matchAll
    request.source().query(QueryBuilders.matchQuery("all","如家"));
    // 2.2 高亮
    request.source().highlighter(new HighlightBuilder()
                    .field("name")
                    .requireFieldMatch(false)
    );

    //3.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    //4.解析结果
    handleResponse(response);
}

private void handleHighlightResponse(SearchResponse response) {
    SearchHits searchHits = response.getHits();
    System.out.println("总数:"+searchHits.getTotalHits().value);

    for (SearchHit hit : searchHits.getHits()) {
        String json = hit.getSourceAsString();
        HotelDoc doc = JSON.parseObject(json, HotelDoc.class);

        // 获取高亮结果
        Map<String, HighlightField> highlightFields = hit.getHighlightFields();

        //if(highlightFields==null||highlightFields.size() == 0){// 健壮性判断
        if (!CollectionUtils.isEmpty(highlightFields)) {// 健壮性判断  直接用Spring提供的工具类 逻辑就是上行一样的
            // 根据字段名称获取值
            HighlightField highlightField = highlightFields.get("name");
            if (highlightField != null) {
                // 获取高亮值
                String name = highlightField.getFragments()[0].string();
                // 覆盖字段原来的(无高亮)值
                doc.setName(name);
            }
        }
        System.out.println(doc);
    }
}

{
    "key": "搜索关键字",
    "page": 1,
    "size": 3,
    "sortBy": "default"
}

package cn.itcast.hotel.pojo;

import lombok.Data;

@Data
public class RequestParams {
    private String key;
    private Integer page;
    private Integer size;
    private String sortBy;
}

package cn.itcast.hotel.pojo;

import lombok.Data;

import java.util.List;

@Data
public class PageResult {
    private Long total;
    private List<HotelDoc> hotels;

    public PageResult() {
    }

    public PageResult(Long total, List<HotelDoc> hotels) {
        this.total = total;
        this.hotels = hotels;
    }
}

//@RestController = @Controller + @ResponseBody + “一些无关紧要的”
// @ResponseBody本来是写在每个方法上的 表示响应(返回)的是json格式数据
@RestController
@RequestMapping("hotel")
@Slf4j
public class HotelController {

    @Autowired
    private IHotelService hotelService;

    @PostMapping("list")
    public PageResult pageSearch(@RequestBody RequestParam params){//@RequestBody表示接受json格式数据
        log.info(params.toString());
        try {
            return hotelService.search(params);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

/**
 * 根据关键字搜索酒店信息
 * @param params 请求参数对象，包含用户输入的关键字 
 * @return 酒店文档列表
 */
PageResult search(RequestParams params);

// 创建成Bean就能注入了 写在这里最合适了
@Bean
public RestHighLevelClient client() {
    return new RestHighLevelClient(RestClient.builder(
            HttpHost.create("http://192.168.141.100:9200") // 最后的'/'不能有
            // 集群的话可以指定多个，中间逗号隔开
    ));
}

package cn.whu.hotel.service.impl;

import cn.whu.hotel.mapper.HotelMapper;
import cn.whu.hotel.pojo.Hotel;
import cn.whu.hotel.pojo.HotelDoc;
import cn.whu.hotel.pojo.PageResult;
import cn.whu.hotel.pojo.RequestParam;
import cn.whu.hotel.service.IHotelService;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.QueryBuilders;
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.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

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

@Service
public class HotelService extends ServiceImpl<HotelMapper, Hotel> implements IHotelService {

    @Autowired
    private RestHighLevelClient client;


    @Override
    public PageResult search(RequestParam params) throws IOException {
        // 1. 准备Request
        SearchRequest request = new SearchRequest("hotel");

        // 2. 准备DSL
        // 2.1 查询 // 高亮查询不能matchAllQuery,得给出条件查询具体字段
        String key = params.getKey();
        if (key == null || "".equals(key.trim())) {
            request.source().query(QueryBuilders.matchAllQuery());
        } else {
            request.source().query(QueryBuilders.matchQuery("all", key));
        }
        // 2.2 排序
        if (!"default".equals(params.getSortBy())) {
            request.source().sort(params.getSortBy(), SortOrder.ASC);
        }
        // 2.3 分页
        int page = params.getPage();//参与运算时就拆箱 别用包装类
        int size = params.getSize();
        request.source().from((page - 1) * size).size(size);
        // 2.4 高亮
        request.source().highlighter(new HighlightBuilder().field("name").requireFieldMatch(false));

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

        // 4. 解析结果
        PageResult pageResult = handlerResponse(response);

        return pageResult;
    }

    private PageResult handlerResponse(SearchResponse response) {
        // 0. 准备对象
        PageResult result = new PageResult();//个人觉得用set方法比较好 更灵活
        SearchHits searchHits = response.getHits();

        // 1. 总数
        result.setTotal(searchHits.getTotalHits().value);

        // 2. List<HotelDoc>
        List<HotelDoc> docs = new ArrayList<>();
        for (SearchHit hit : searchHits.getHits()) {
            // 2.1 hotel->hotelDoc
            String json = hit.getSourceAsString();
            HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);//hotelDoc就是专门接收es返回的json的

            // 2.2 高亮
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            if (!CollectionUtils.isEmpty(highlightFields)) {
                HighlightField highlightField = highlightFields.get("name");
                if (highlightField != null) {
                    String name = highlightField.getFragments()[0].string();
                    hotelDoc.setName(name);
                }
            }
            docs.add(hotelDoc);
        }
        // 3. 返回结果
        result.setHotels(docs);
        return result;
    }
}

@Data
public class RequestParams {
    private String key;
    private Integer page;
    private Integer size;
    private String sortBy;
    // 下面是新增的过滤条件参数
    private String city;
    private String brand;
    private String starName;
    private Integer minPrice;
    private Integer maxPrice;
}

private static void buildBasicQuery(RequestParam params, SearchRequest request) {
    // 2.1 查询 // 高亮查询不能matchAllQuery,得给出条件查询具体字段
    // 构建BooleanQuery (多条件查询嘛)
    BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
    // 2.1.1 查询： must: and
    String key = params.getKey();
    if (StringUtils.isEmpty(key)) {
        boolQuery.must(QueryBuilders.matchAllQuery());
    } else {
        boolQuery.must(QueryBuilders.matchQuery("all", key));
    }
    // 2.1.2 过滤条件：精确查询
    // 城市条件
    String city = params.getCity();
    if(!StringUtils.isEmpty(city)){
        boolQuery.filter(QueryBuilders.termQuery("city",city));
    }
    // 品牌条件
    String brand = params.getBrand();
    if(!StringUtils.isEmpty(brand)){
        boolQuery.filter(QueryBuilders.termQuery("brand",brand));
    }
    // 星级条件 (复制成city了 导致一直有bug)
    String starName = params.getStarName();
    if(!StringUtils.isEmpty(starName)){
        boolQuery.filter(QueryBuilders.termQuery("starName",starName));
    }
    // 2.2.3 过滤条件：范围查询
    // price
    Integer minPrice = params.getMinPrice();
    Integer maxPrice = params.getMaxPrice();
    if(minPrice!=null&&maxPrice!=null){
        boolQuery.filter(QueryBuilders.rangeQuery("price").gte(minPrice).lte(maxPrice));
    }

    // 最后别忘了加入条件哈
    request.source().query(boolQuery);
}

getGeoLoc(){
  this.searchByMap("31.03463, 121.61245");
},

package cn.itcast.hotel.pojo;

import lombok.Data;

@Data
public class RequestParams {
    private String key;
    private Integer page;
    private Integer size;
    private String sortBy;
    private String city;
    private String brand;
    private String starName;
    private Integer minPrice;
    private Integer maxPrice;
    // 我当前的地理坐标
    private String location;
}

GET /indexName/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "price": "asc"  
    },
    {
      "_geo_distance" : {
          "FIELD" : "纬度，经度",
          "order" : "asc",
          "unit" : "km"
      }
    }
  ]
}

@Override
public PageResult search(RequestParam params) throws IOException {
    // 1. 准备Request
    SearchRequest request = new SearchRequest("hotel");
    // 2. 准备DSL
    // 2.1 基础查询
    buildBasicQuery(params, request);
    // 2.2 排序
    // 2.2.1 距离升序
    String location = params.getLocation();
    if(!StringUtils.isEmpty(location)){
        request.source().sort(SortBuilders
                .geoDistanceSort("location",new GeoPoint(location))
                .order(SortOrder.ASC)
                .unit(DistanceUnit.KILOMETERS));
    }
    // 2.2.2 价格升序
    if (!"default".equals(params.getSortBy())) {
        request.source().sort(params.getSortBy(), SortOrder.ASC);
    }

    // 2.3 分页
    int page = params.getPage();//参与运算时就拆箱 别用包装类
    int size = params.getSize();
    request.source().from((page - 1) * size).size(size);
    // 2.4 高亮
    request.source().highlighter(new HighlightBuilder().field("name").requireFieldMatch(false));
    // 3. 发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4. 解析结果
    PageResult pageResult = handlerResponse(response);
    return pageResult;
}

package cn.itcast.hotel.pojo;

import lombok.Data;
import lombok.NoArgsConstructor;


@Data
@NoArgsConstructor
public class HotelDoc {
    private Long id;
    private String name;
    private String address;
    private Integer price;
    private Integer score;
    private String brand;
    private String city;
    private String starName;
    private String business;
    private String location;
    private String pic;
    // 排序时的 距离值
    private Object distance;

    public HotelDoc(Hotel hotel) {
        this.id = hotel.getId();
        this.name = hotel.getName();
        this.address = hotel.getAddress();
        this.price = hotel.getPrice();
        this.score = hotel.getScore();
        this.brand = hotel.getBrand();
        this.city = hotel.getCity();
        this.starName = hotel.getStarName();
        this.business = hotel.getBusiness();
        this.location = hotel.getLatitude() + ", " + hotel.getLongitude();
        this.pic = hotel.getPic();
    }
}

POST /hotel/_update/2056105938
{
    "doc": {
        "isAD": true
    }
}
POST /hotel/_update/36934
{
    "doc": {
        "isAD": true
    }
}
POST /hotel/_update/45845
{
    "doc": {
        "isAD": true
    }
}
POST /hotel/_update/47066
{
    "doc": {
        "isAD": true
    }
}
POST /hotel/_update/38665
{
    "doc": {
        "isAD": true
    }
}

# 根据id查询指定文档
GET /hotel/_doc/36934
GET /hotel/_doc/2056105938

# 分页查询文档
GET /hotel/_search
{
  "from": 2,
  "size": 20
}

private static void buildBasicQuery(RequestParam params, SearchRequest request) {
    // 1) 原始查询
    // 2.1 查询 // 高亮查询不能matchAllQuery,得给出条件查询具体字段
    // 构建BooleanQuery (多条件查询嘛)
    BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
    // 2.1.1 查询： must: and
    String key = params.getKey();
    if (StringUtils.isEmpty(key)) {
        boolQuery.must(QueryBuilders.matchAllQuery());
    } else {
        boolQuery.must(QueryBuilders.matchQuery("all", key));
    }
    // 2.1.2 过滤条件：精确查询
    // 城市条件
    String city = params.getCity();
    if (!StringUtils.isEmpty(city)) {
        boolQuery.filter(QueryBuilders.termQuery("city", city));
    }
    // 品牌条件
    String brand = params.getBrand();
    if (!StringUtils.isEmpty(brand)) {
        boolQuery.filter(QueryBuilders.termQuery("brand", brand));
    }
    // 星级条件 (复制成city了 导致一直有bug)
    String starName = params.getStarName();
    if (!StringUtils.isEmpty(starName)) {
        boolQuery.filter(QueryBuilders.termQuery("starName", starName));
    }
    // 2.2.3 过滤条件：范围查询
    // price
    Integer minPrice = params.getMinPrice();
    Integer maxPrice = params.getMaxPrice();
    if (minPrice != null && maxPrice != null) {
        boolQuery.filter(QueryBuilders.rangeQuery("price").gte(minPrice).lte(maxPrice));
    }

    // 2. 算分控制
    FunctionScoreQueryBuilder functionScoreQuery =
            QueryBuilders.functionScoreQuery(
                    // 原始查询 相关性算分查询
                    boolQuery,
                    // FunctionScore的数据
                    new FunctionScoreQueryBuilder.FilterFunctionBuilder[]{
                            // 其中的一个FunctionScore元素
                            new FunctionScoreQueryBuilder.FilterFunctionBuilder(
                                    // 过滤条件
                                    QueryBuilders.termQuery("isAD",true),//给isAD=true的酒店增加算分
                                    // 算分函数
                                    ScoreFunctionBuilders.weightFactorFunction(10) //默认乘以10
                            )
                    });


    // 最后别忘了加入条件哈
    request.source().query(functionScoreQuery);//boolQuery也放到functionScoreQuery里面去了
}