1. DSL查询文档
1.1 DSL Query的分类
Elasticsearch提供了基于JSON的DSL（Domain Specific Language）来定义查询。常见的查询类型包括：
- 查询所有：查询出所有数据，一般测试用。例如：match_all
- 全文检索（full text）查询：利用分词器对用户输入内容分词，然后去倒排索引库中匹配。例如：
- match_query
- multi_match_query
- 精确查询：根据精确词条值查找数据，一般是查找keyword、数值、日期、boolean等类型字段。例如：
- ids
- range
- term
- 地理（geo）查询：根据经纬度查询。例如：
- geo_distance
- geo_bounding_box
- 复合（compound）查询：复合查询可以将上述各种查询条件组合起来，合并查询条件。例如
- bool
- function_score
DSL Query基本语法（主要是查询类型、查询条件、条件值三要素）
GET /indexName/_search
{
"query": {
"查询类型": {
"查询条件": "条件值"
}
}
}
// 查询所有
GET /indexName/_search
{
"query": {
"match_all": {
}
}
}
1.2 全文检索查询
全文检索查询，会对用户输入内容分词，常用于搜索框搜索：
match查询：全文检索查询的一种，会对用户输入内容分词，然后去倒排索引库检索，语法：
（可以利用copy_to属性关联多个字段，然后对copy_to后的单个值查询）
GET /indexName/_search
{
"query": {
"match": {
"FIELD": "TEXT"
}
}
}
multi_match：与match查询类似，只不过允许同时查询多个字段，语法：
GET /indexName/_search
{
"query": {
"multi_match": {
"query": "TEXT",
"fields": ["FIELD1", " FIELD12"]
}
}
}
1.3 精确查询
精确查询一般是查找keyword、数值、日期、boolean等类型字段。所以不会对搜索条件分词。常见的有：
- term：根据词条精确值查询
- range：根据值的范围查询
精确查询常见的有term查询和range查询。语法如下：
term查询：根据词条精确匹配，一般搜索keyword类型、数值类型、布尔类型、日期类型字段
// term查询
GET /indexName/_search
{
"query": {
"term": {
"FIELD": {
"value": "VALUE"
}
}
}
}
//例如
GET /hotel/_search
{
"query": {
"term": {
"price": {
"value": "336"
}
}
}
}
range查询：根据数值范围查询，可以是数值、日期的范围
// range查询
GET /indexName/_search
{
"query": {
"range": {
"FIELD": {
"gte": 10,
"lte": 20
}
}
}
}
1.4 地理查询
根据经纬度查询。常见的使用场景包括：
- 携程：搜索我附近的酒店
- 滴滴：搜索我附近的出租车
- 微信：搜索我附近的人
根据经纬度查询，官方文档。例如： geo_bounding_box：查询geo_point值落在某个矩形范围的所有文档
// geo_bounding_box查询
GET /indexName/_search
{
"query": {
"geo_bounding_box": {
"FIELD": {
"top_left": {
"lat": 31.1,
"lon": 121.5
},
"bottom_right": {
"lat": 30.9,
"lon": 121.7
}
}
}
}
}
根据经纬度查询，官方文档。例如： geo_distance：查询到指定中心点小于某个距离值的所有文档
// geo_distance 查询
GET /indexName/_search
{
"query": {
"geo_distance": {
"distance": "15km",
"FIELD": "31.21,121.5"
}
}
}
1.5 复合查询
复合（compound）查询：复合查询可以将其它简单查询组合起来，实现更复杂的搜索逻辑，例如： fuction score：算分函数查询，可以控制文档相关性算分，控制文档排名。例如百度竞价
1.5.1 相关性算分
当我们利用match查询时，文档结果会根据与搜索词条的关联度打分（_score），返回结果时按照分值降序排列。 例如，我们搜索 "虹桥如家"，结果如下：
{
"_score" : 17.850193,
"_source" : {
"name" : "虹桥如家酒店真不错",
}
},
{
"_score" : 12.259849,
"_source" : {
"name" : "外滩如家酒店真不错",
}
},
{
"_score" : 11.91091,
"_source" : {
"name" : "迪士尼如家酒店真不错",
}
}
使用 function score query，可以修改文档的相关性算分（query score），根据新得到的算分排序。
GET /hotel/_search
{
"query": {
"function_score": {
"query": { "match": {"all": "外滩"} },#原始查询条件，搜索文档并根据相关性打分
"functions": [
{
"filter": {"term": {"id": "1"}},#过滤条件，符合条件的文档才会被重新算分
"weight": 10#算分函数
}
],
"boost_mode": "multiply"#权加模式
}
}
}
算分函数，算分函数的结果称为function score ，将来会与query score运算，得到新算分，常见的算分函数有：
- weight：给一个常量值，作为函数结果（function score）
- field_value_factor：用文档中的某个字段值作为函数结果
- random_score：随机生成一个值，作为函数结果 script_score：自定义计算公式，公式结果作为函数结果
加权模式，定义function score与query score的运算方式，包括：
- multiply：两者相乘。默认就是这个
- replace：用function score 替换 query score
- 其它：sum、avg、max、min
unction score query定义的三要素是什么？
- 过滤条件：哪些文档要加分
- 算分函数：如何计算function score
- 加权方式：function score 与 query score如何运算
案例：给“如家”这个品牌的酒店排名靠前一些
把这个问题翻译一下，function score需要的三要素：
- 哪些文档需要算分加权？
- 品牌为如家的酒店
- 算分函数是什么？
- weight就可以
- 加权模式是什么？
- 求和
GET /hotel/_search
{
"query": {
"function_score": {
"query": {// ... },
"functions": [ // 算分函数
{
"filter": { // 满足的条件，品牌必须是如家
"term": {
"brand": "如家"
}
},
"weight": 2 // 算分权重为2
}
],
"boost_mode": "sum"
}
}
}
1.5.2 复合查询 Boolean Query
布尔查询是一个或多个查询子句的组合。子查询的组合方式有：
- 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 } }}
]
}
}
}
案例：利用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}
}
}
]
}
}
}
2. 搜索结果处理
2.1 排序
elasticsearch支持对搜索结果排序，默认是根据相关度算分（_score）来排序。可以排序字段类型有：keyword类型、数值类型、地理坐标类型、日期类型等。
GET /indexName/_search
{
"query": {
"match_all": {}
},
"sort": [
{
"FIELD": "desc" // 排序字段和排序方式ASC、DESC
}
]
}
GET /indexName/_search
{
"query": {
"match_all": {}
},
"sort": [
{
"_geo_distance" : {
"FIELD" : "纬度，经度",
"order" : "asc", # 排序方式
"unit" : "km" # 单位
}
}
]
}
2.2 分页
elasticsearch 默认情况下只返回top10的数据。而如果要查询更多数据就需要修改分页参数了。 elasticsearch中通过修改from、size参数来控制要返回的分页结果：
GET /hotel/_search
{
"query": {
"match_all": {}
},
"from": 990, // 分页开始的位置，默认为0
"size": 10, // 期望获取的文档总数
"sort": [
{"price": "asc"}
]
}
深度分页问题
ES是分布式的，所以会面临深度分页问题。例如按price排序后，获取from = 990，size =10的数据：
- 首先在每个数据分片上都排序并查询前1000条文档。
- 然后将所有节点的结果聚合，在内存中重新排序选出前1000条文档
- 最后从这1000条中，选取从990开始的10条文档
如果搜索页数过深，或者结果集（from + size）越大，对内存和CPU的消耗也越高。因此ES设定结果集查询的上限是10000
深度分页解决方案
针对深度分页，ES提供了两种解决方案，官方文档：
- search after：分页时需要排序，原理是从上一次的排序值开始，查询下一页数据。官方推荐使用的方式。
- scroll：原理将排序数据形成快照，保存在内存。官方已经不推荐使用。
from + size：
- 优点：支持随机翻页
- 缺点：深度分页问题，默认查询上限（from + size）是10000
- 场景：百度、京东、谷歌、淘宝这样的随机翻页搜索
after search：
- 优点：没有查询上限（单次查询的size不超过10000）
- 缺点：只能向后逐页查询，不支持随机翻页
- 场景：没有随机翻页需求的搜索，例如手机向下滚动翻页
scroll：
- 优点：没有查询上限（单次查询的size不超过10000）
- 缺点：会有额外内存消耗，并且搜索结果是非实时的
- 场景：海量数据的获取和迁移。从ES7.1开始不推荐，建议用 after search方案。
2.3 高亮
高亮：就是在搜索结果中把搜索关键字突出显示。
原理是这样的： 将搜索结果中的关键字用标签标记出来 在页面中给标签添加css样式 语法：
GET /hotel/_search
{
"query": {
"match": {
"FIELD": "TEXT"
}
},
"highlight": {
"fields": { // 指定要高亮的字段
"FIELD": {
"pre_tags": "<em>", // 用来标记高亮字段的前置标签
"post_tags": "</em>" // 用来标记高亮字段的后置标签
}
}
}
}
搜索结果处理整体语法：
GET /hotel/_search
{
"query": {
"match": {
"name": "如家"
}
},
"from": 0, // 分页开始的位置
"size": 20, // 期望获取的文档总数
"sort": [
{ "price": "asc" }, // 普通排序
{
"_geo_distance" : { // 距离排序
"location" : "31.040699,121.618075",
"order" : "asc",
"unit" : "km"
}
}
],
"highlight": {
"fields": { // 高亮字段
"name": {
"pre_tags": "<em>", // 用来标记高亮字段的前置标签
"post_tags": "</em>" // 用来标记高亮字段的后置标签
}
}
}
}
3. RestClient查询文档
3.1 快速入门
查询的基本步骤是：
- 创建SearchRequest对象
- 准备Request.source()，也就是DSL。
- QueryBuilders来构建查询条件
- 传入Request.source() 的 query() 方法
- 发送请求，得到结果
- 解析结果（参考JSON结果，从外到内，逐层解析）
通过match_all来演示下基本的API，先看请求DSL的组织：
@Test
void testMatchAll() throws IOException {
// 1.准备Request
SearchRequest request = new SearchRequest("hotel");//ET /indexName/_search
// 2.组织DSL参数
request.source()
.query(QueryBuilders.matchAllQuery());//
// 3.发送请求，得到响应结果
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
// ...解析响应结果
}
@Test
void testMatchAll() throws IOException {
// ... 略
// 4.解析结果
SearchHits searchHits = response.getHits();
// 4.1.查询的总条数
long total = searchHits.getTotalHits().value;
// 4.2.查询的结果数组
SearchHit[] hits = searchHits.getHits();
for (SearchHit hit : hits) {
// 4.3.得到source
String json = hit.getSourceAsString();
// 4.4.打印
System.out.println(json);
}
}
RestAPI中其中构建DSL是通过HighLevelRestClient中的resource()来实现的，其中包含了查询、排序、分页、高亮等所有功能：
RestAPI中其中构建查询条件的核心部分是由一个名为QueryBuilders的工具类提供的，其中包含了各种查询方法：
3.2 全文检索查询
全文检索的match和multi_match查询与match_all的API基本一致。差别是查询条件，也就是query的部分。 同样是利用QueryBuilders提供的方法：
// 单字段查询
QueryBuilders.matchQuery("all", "如家");
// 多字段查询
QueryBuilders.multiMatchQuery("如家", "name", "business");
3.3 精确查询
精确查询常见的有term查询和range查询，同样利用QueryBuilders实现：
// 词条查询
QueryBuilders.termQuery("city", "杭州");
// 范围查询
QueryBuilders.rangeQuery("price").gte(100).lte(150);
3.4 复合查询-boolean query
精确查询常见的有term查询和range查询，同样利用QueryBuilders实现：
// 创建布尔查询
BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
// 添加must条件
boolQuery.must(QueryBuilders.termQuery("city", "杭州"));
// 添加filter条件
boolQuery.filter(QueryBuilders.rangeQuery("price").lte(250));
要构建查询条件，只要记住一个类：QueryBuilders
3.5 排序和分页
搜索结果的排序和分页是与query同级的参数，对应的API如下：
// 查询
request.source().query(QueryBuilders.matchAllQuery());
// 分页
request.source().from(0).size(5);
// 价格排序
request.source().sort("price", SortOrder.ASC);
3.6 高亮
高亮API包括请求DSL构建和结果解析两部分。我们先看请求的DSL构建：
request.source().highlighter(new HighlightBuilder()
.field("name")
// 是否需要与查询字段匹配
.requireFieldMatch(false)
);
高亮的结果处理相对比较麻烦：
// 获取source
HotelDoc hotelDoc = JSON.parseObject(hit.getSourceAsString(), HotelDoc.class);
// 处理高亮
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);
}
}
所有搜索DSL的构建，记住一个API：SearchRequest的source()方法。
4. 具体案例
案例1：实现旅游的酒店搜索功能，完成关键字搜索和分页
先实现其中的关键字搜索功能，实现步骤如下：
- 定义实体类，接收前端请求
- 定义controller接口，接收页面请求，调用IHotelService的search方法
- 定义IHotelService中的search方法，利用match查询实现根据关键字搜索酒店信息
步骤1：定义类，接收前端请求参数
@Data
public class RequestParams {
private String key;
private Integer page;
private Integer size;
private String sortBy;
}
步骤2：定义controller接口，接收前端请求
- 定义一个HotelController，声明查询接口，满足下列要求：
- 请求方式：Post
- 请求路径：/hotel/list
- 请求参数：对象，类型为RequestParam
- 返回值：PageResult，包含两个属性
- Long total：总条数 List<HotelDoc>
- hotels：酒店数据
步骤3：在IHotelService中定义一个方法，实现搜索功能
1. 在IHotelService中定义一个方法，声明如下：
/**
* 根据关键字搜索酒店信息
* @param params 请求参数对象，包含用户输入的关键字
* @return 酒店文档列表
*/
PageResult search(RequestParam params);
2. 在HotelService中实现该方法，满足下列要求：
- 利用match查询，根据参数中的key搜索all字段，查询酒店信息并返回
- 利用参数中的page、size实现分页
@Autowired
private RestHighLevelClient restHighLevelClient;
@Override
public PageResult search(RequestParams params) {
try {
// 1.准备Request
SearchRequest request = new SearchRequest("hotel");
// 2.准备请求参数
// 2.1.query
String key = params.getKey();
if (StringUtils.isNotBlank(key)) {
// 不为空，根据关键字查询
boolQuery.must(QueryBuilders.matchQuery("all", key));
} else {
// 为空，查询所有
boolQuery.must(QueryBuilders.matchAllQuery());
}
// 2.2.分页
int page = params.getPage();
int size = params.getSize();
request.source().from((page - 1) * size).size(size);
// 3.发送请求
SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
// 4.解析响应
return handleResponse(response);
} catch (IOException e) {
throw new RuntimeException("搜索数据失败", e);
}
}
//解析
private PageResult handleResponse(SearchResponse response) {
SearchHits searchHits = response.getHits();
// 4.1.总条数
long total = searchHits.getTotalHits().value;
// 4.2.获取文档数组
SearchHit[] hits = searchHits.getHits();
// 4.3.遍历
List<HotelDoc> hotels = new ArrayList<>(hits.length);
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();
if (map != null && !map.isEmpty()) {
// 2）根据字段名，获取高亮结果
HighlightField highlightField = map.get("name");
if (highlightField != null) {
// 3）获取高亮结果字符串数组中的第1个元素
String hName = highlightField.getFragments()[0].toString();
// 4）把高亮结果放到HotelDoc中
hotelDoc.setName(hName);
}
}
// 4.8.排序信息
Object[] sortValues = hit.getSortValues();
if (sortValues.length > 0) {
hotelDoc.setDistance(sortValues[0]);
}
// 4.9.放入集合
hotels.add(hotelDoc);
}
return new PageResult(total, hotels);
}案例2：添加品牌、城市、星级、价格等过滤功能
步骤：
- 修改RequestParams类，添加brand、city、starName、minPrice、maxPrice等参数
- 修改search方法的实现，在关键字搜索时，如果brand等参数存在，对其做过滤
步骤一：拓展IUserService的search方法的参数列表
修改RequestParams类，接收所有参数：
@Data
public class RequestParams {
private String key;
private Integer page;
private Integer size;
private String sortBy;
private String brand;
private String city;
private String starName;
private Integer minPrice;
private Integer maxPrice;
private String location;
}步骤二：修改search方法，在match查询基础上添加过滤条件
- 过滤条件包括：
- city精确匹配
- brand精确匹配
- starName精确匹配
- price范围过滤
注意事项：
- 多个条件之间是AND关系，组合多条件用BooleanQuery
- 参数存在才需要过滤，做好非空判断
private void buildBasicQuery(RequestParams params, SearchRequest request) {
// 1.准备Boolean查询
BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
// 1.1.关键字搜索，match查询，放到must中
String key = params.getKey();
if (StringUtils.isNotBlank(key)) {
// 不为空，根据关键字查询
boolQuery.must(QueryBuilders.matchQuery("all", key));
} else {
// 为空，查询所有
boolQuery.must(QueryBuilders.matchAllQuery());
}
// 1.2.品牌
String brand = params.getBrand();
if (StringUtils.isNotBlank(brand)) {
boolQuery.filter(QueryBuilders.termQuery("brand", brand));
}
// 1.3.城市
String city = params.getCity();
if (StringUtils.isNotBlank(city)) {
boolQuery.filter(QueryBuilders.termQuery("city", city));
}
// 1.4.星级
String starName = params.getStarName();
if (StringUtils.isNotBlank(starName)) {
boolQuery.filter(QueryBuilders.termQuery("starName", starName));
}
// 1.5.价格范围
Integer minPrice = params.getMinPrice();
Integer maxPrice = params.getMaxPrice();
if (minPrice != null && maxPrice != null) {
maxPrice = maxPrice == 0 ? Integer.MAX_VALUE : maxPrice;
boolQuery.filter(QueryBuilders.rangeQuery("price").gte(minPrice).lte(maxPrice));
}
// 2.设置查询条件
request.source().query(functionScoreQuery);
}案例3：我附近的酒店
前端页面点击定位后，会将你所在的位置发送到后台：
我们要根据这个坐标，将酒店结果按照到这个点的距离升序排序。 实现思路如下：
- 修改RequestParams参数，接收location字段
- 修改search方法业务逻辑，如果location有值，添加根据geo_distance排序的功能
// 2.3.距离排序
String location = params.getLocation();
if (StringUtils.isNotBlank(location)) {
request.source().sort(SortBuilders
.geoDistanceSort("location", new GeoPoint(location))
.order(SortOrder.ASC)
.unit(DistanceUnit.KILOMETERS)
);
}案例4：让指定的酒店在搜索结果中排名置顶
我们给需要置顶的酒店文档添加一个标记。然后利用function score给带有标记的文档增加权重。
实现步骤分析：
- 给HotelDoc类添加isAD字段，Boolean类型
- 挑选几个你喜欢的酒店，给它的文档数据添加isAD字段，值为true
- 修改search方法，添加function score功能，给isAD值为true的酒店增加权重
// 2.算分函数查询
FunctionScoreQueryBuilder functionScoreQuery = QueryBuilders.functionScoreQuery(
boolQuery, // 原始查询，boolQuery
new FunctionScoreQueryBuilder.FilterFunctionBuilder[]{ // function数组
new FunctionScoreQueryBuilder.FilterFunctionBuilder(
QueryBuilders.termQuery("isAD", true), // 过滤条件
ScoreFunctionBuilders.weightFactorFunction(10) // 算分函数
)
}
);HotelService完整代码：
@Slf4j
@Service
public class HotelService extends ServiceImpl<HotelMapper, Hotel> implements IHotelService {
@Autowired
private RestHighLevelClient restHighLevelClient;
@Override
public PageResult search(RequestParams params) {
try {
// 1.准备Request
SearchRequest request = new SearchRequest("hotel");
// 2.准备请求参数
// 2.1.query
buildBasicQuery(params, request);
// 2.2.分页
int page = params.getPage();
int size = params.getSize();
request.source().from((page - 1) * size).size(size);
// 2.3.距离排序
String location = params.getLocation();
if (StringUtils.isNotBlank(location)) {
request.source().sort(SortBuilders
.geoDistanceSort("location", new GeoPoint(location))
.order(SortOrder.ASC)
.unit(DistanceUnit.KILOMETERS)
);
}
// 3.发送请求
SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
// 4.解析响应
return handleResponse(response);
} catch (IOException e) {
throw new RuntimeException("搜索数据失败", e);
}
}
private void buildBasicQuery(RequestParams params, SearchRequest request) {
// 1.准备Boolean查询
BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
// 1.1.关键字搜索，match查询，放到must中
String key = params.getKey();
if (StringUtils.isNotBlank(key)) {
// 不为空，根据关键字查询
boolQuery.must(QueryBuilders.matchQuery("all", key));
} else {
// 为空，查询所有
boolQuery.must(QueryBuilders.matchAllQuery());
}
// 1.2.品牌
String brand = params.getBrand();
if (StringUtils.isNotBlank(brand)) {
boolQuery.filter(QueryBuilders.termQuery("brand", brand));
}
// 1.3.城市
String city = params.getCity();
if (StringUtils.isNotBlank(city)) {
boolQuery.filter(QueryBuilders.termQuery("city", city));
}
// 1.4.星级
String starName = params.getStarName();
if (StringUtils.isNotBlank(starName)) {
boolQuery.filter(QueryBuilders.termQuery("starName", starName));
}
// 1.5.价格范围
Integer minPrice = params.getMinPrice();
Integer maxPrice = params.getMaxPrice();
if (minPrice != null && maxPrice != null) {
maxPrice = maxPrice == 0 ? Integer.MAX_VALUE : maxPrice;
boolQuery.filter(QueryBuilders.rangeQuery("price").gte(minPrice).lte(maxPrice));
}
// 2.算分函数查询
FunctionScoreQueryBuilder functionScoreQuery = QueryBuilders.functionScoreQuery(
boolQuery, // 原始查询，boolQuery
new FunctionScoreQueryBuilder.FilterFunctionBuilder[]{ // function数组
new FunctionScoreQueryBuilder.FilterFunctionBuilder(
QueryBuilders.termQuery("isAD", true), // 过滤条件
ScoreFunctionBuilders.weightFactorFunction(10) // 算分函数
)
}
);
// 3.设置查询条件
request.source().query(functionScoreQuery);
}
private PageResult handleResponse(SearchResponse response) {
SearchHits searchHits = response.getHits();
// 4.1.总条数
long total = searchHits.getTotalHits().value;
// 4.2.获取文档数组
SearchHit[] hits = searchHits.getHits();
// 4.3.遍历
List<HotelDoc> hotels = new ArrayList<>(hits.length);
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();
if (map != null && !map.isEmpty()) {
// 2）根据字段名，获取高亮结果
HighlightField highlightField = map.get("name");
if (highlightField != null) {
// 3）获取高亮结果字符串数组中的第1个元素
String hName = highlightField.getFragments()[0].toString();
// 4）把高亮结果放到HotelDoc中
hotelDoc.setName(hName);
}
}
// 4.8.排序信息
Object[] sortValues = hit.getSortValues();
if (sortValues.length > 0) {
hotelDoc.setDistance(sortValues[0]);
}
// 4.9.放入集合
hotels.add(hotelDoc);
}
return new PageResult(total, hotels);
}
}
5458
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
