ElasticSearch nested 字段多关键字搜索，高亮全部匹配关键字的处理
环境介绍
ElasticSearch 版本号: 6.7.0
需求说明
用户会传入多个关键字去ES查询ElasticSearch nested 字段 的多个字段，要求在返回的结果中被搜索的字段需要高亮所有匹配的关键字。例如同时通过上海和策划关键字，再 工作经历的列表中的工作内容和公司名称中搜索。如果有人员的工作经历中这两个关键字上海和策划都可以匹配到，那么返回的结果中同时高亮这上海和策划关键字
分析调研
基础的ElasticSearch nested 字段的高亮实现搜可以参考https://blog.csdn.net/weixin_48990070/article/details/120342597 这篇笔记。
问题点1
对于同一个nested 字段支持在一个nested Query 用不同的关键字来搜索，但对于should 查询只会高亮其中匹配的一个关键字，而不是全部。引入如果多关键字直接是任意满足的关系，则之后高亮匹配的其中的一个关键字，这个与不满足需求。
问题点2
那就把关键字拆分为多个nested Query ，一个关键字对应一个nested Query 。但这个方法一样可以搜索，但对于同一个nested字段的nested Query 默认的inner_hits 属性只能出现在一个nested Query中，不允许同一个nested字段的不同nested Query 都指定inner_hits ，如果一定要这么做，那么就会得到一个查询错误的提示，提示如下：
"reason": {
"type": "illegal_argument_exception",
"reason": "[inner_hits] already contains an entry for key [trackRecordList]"
}
如果只在一个关键字的nested Query指定inner_hits，那么最终的高亮结果只会有该nested Query的高亮，还是不满足要求。
问题点3
通过AI询问得知inner_hits 有个name 属性可以解决问题点2的情况，可以通过设置inner_hits不同的name 属性值来达到对同一个nested字段用不同nested Query 来做多关键字的高亮效果，但是这样里又出现了两个新的问题。
1、inner_hits 有个name 属性值不能重复，否则一样出问题点2的错误提示。
2、高亮 结果是按照inner_hits 有个name 属性值分组展示的，不像非nested会给一个最终多个关键字都高亮的结果。
转换下问题就是：
1、要根据关键字自动生成不重复inner_hits 有个name 属性值
2、对于同字段的高亮结果，要做高亮内容的合并。
因此只要解决了上面两个问题，就可以完成业务的需求了。
最终解决方案
问题1解决方案
在将查询参数转换为ES Query语句的处理中，用Map来缓存每个nested字段的当前有几个nested Query，通过累计数量，来自动生成每个nested Query中的inner_hits 有个name 属性名，例如名称为 nested字段名+“-”+自增序号
因此就不能再使用静态方法来构建查询语句了，得用构建器了，下面就是构建器的部分实现
public class EsQueryBuilder {
// 存储嵌套字段及其累计值的映射
private Map<String, IntAccumulator> accNestedFieldMap = new HashMap<>();
// 无需嵌套高亮的字段集合
private Set<String> noNestedHighlightFields = new HashSet<>();
// 关键词分组列表
private List<PageSearchKeywordGroupParameter> keywordGroupList ;
// 是否开启高亮显示
private boolean isHighlight = false;
// 主查询构建器
private BoolQueryBuilder mainQueryBuilder;
//存储嵌套字段及其高亮构建器
private Map<NestedQueryBuilder,InnerHitBuilder> nestedQueryBuilderHighlightMap = new HashMap<>();
/**
* 构造方法
* @param keywordGroupList 搜索关键字组
* @param isHighlight 是否高亮
*/
public EsQueryBuilder(List<PageSearchKeywordGroupParameter> keywordGroupList,boolean isHighlight) {
this.keywordGroupList = keywordGroupList;
this.isHighlight = isHighlight;
this.mainQueryBuilder = new BoolQueryBuilder();
//补充嵌套字段初始累加器
EsQueryFieldEnum.getNestedFieldList().forEach(item->{
accNestedFieldMap.put(item.getFieldConfig().getMainField(),new IntAccumulator(0));
});
}
/**
* 向当前的查询构建器中添加条件。这个方法会遍历关键字组列表（keywordGroupList）中的每一个项目，
* 并根据是否标记为排除条件，将关键字添加到查询的必须条件（must）或者必须不条件（mustNot）中。
* @return EsQueryBuilder 返回当前的查询构建器实例，允许链式调用。
*/
public EsQueryBuilder addCondition() {
keywordGroupList.forEach(item->{
// 只处理非空关键字的项目
if(StringUtils.isNotBlank(item.getKeyword())){
// 根据是否为排除条件，选择添加到must或mustNot中
if(BooleanUtils.isTrue(item.getIsExclude())){
mainQueryBuilder.mustNot(buildQueryBuilder(item));
}else{
mainQueryBuilder.must(buildQueryBuilder(item));
}
}
});
return this;
}
/**
* 为所有内容添加高亮显示条件的查询构建器。
* 该方法遍历关键字组列表，对非排除条件的关键字进行全文搜索设置，并根据关键字是否为排除条件，添加相应的查询条件。
* @return EsQueryBuilder 当前查询构建器实例，支持链式调用。
*/
public EsQueryBuilder addConditionForAllContentHighlight() {
// 遍历关键字组列表，过滤掉设置为排除条件的关键字，对剩余的关键字进行全文搜索设置
keywordGroupList.stream()
// 过滤掉设置为排除条件的关键字
.filter(item->BooleanUtils.isNotTrue(item.getIsExclude()))
.peek(item->{
// 设置搜索类型为全文搜索，清空子类型设置
item.setSearchType(EsQueryTypeEnum.ALL.value());
item.setSearchSubType(null);
})
.forEach(item->{
// 根据关键字是否为排除条件，添加相应的查询条件
if(StringUtils.isNotBlank(item.getKeyword())){
if(BooleanUtils.isTrue(item.getIsExclude())){
// 如果是排除条件，则添加到must not查询条件中
mainQueryBuilder.mustNot(buildQueryBuilder(item));
}else{
// 如果不是排除条件，则添加到must查询条件中
mainQueryBuilder.must(buildQueryBuilder(item));
}
}
});
return this;
}
/**
* 嵌套字段高亮处理
**/
private void highlightNestedQuery() {
if(!nestedQueryBuilderHighlightMap.isEmpty()){
nestedQueryBuilderHighlightMap.forEach(NestedQueryBuilder::innerHit);
}
}
/**
* 为查询添加过滤条件。
* 这个方法允许用户指定一个过滤条件，并将其应用到当前的查询构建器中。
* @param queryBuilder 过滤条件的查询构建器。这是一个已经构建好的查询条件，将作为过滤条件添加到主查询中。
* @return 返回当前的EsQueryBuilder实例，允许链式调用。
*/
public EsQueryBuilder filterCondition(QueryBuilder queryBuilder) {
// 为主查询添加过滤条件
mainQueryBuilder.filter(queryBuilder);
return this;
}
/**
* 构建查询条件
* @return org.elasticsearch.search.builder.SearchSourceBuilder
*/
public SearchSourceBuilder build() {
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
//查询条件
searchSourceBuilder.query(mainQueryBuilder);
return searchSourceBuilder;
}
/**
* 构建查询条件(支持高亮)
* @return org.elasticsearch.search.builder.SearchSourceBuilder
*/
public SearchSourceBuilder buildWithHighlight() {
SearchSourceBuilder searchSourceBuilder = build();
if(isHighlight){
//补充非嵌套字段的高亮
highlightNestedQuery();
//非嵌套高亮
searchSourceBuilder.highlighter(EsHighlightUtils.buildNotNestHighlightBuilder(noNestedHighlightFields));
}
return searchSourceBuilder;
}
/**
* 构建查询构建器。
* 该方法根据传入的参数生成一个对应的查询条件构建器，主要用于处理专家页面的搜索关键词分组参数。
* @param parameter 搜索参数，包含需要搜索的关键词和其他搜索条件。
* @return 返回构建好的查询条件构建器对象。
*/
private QueryBuilder buildQueryBuilder(PageSearchKeywordGroupParameter parameter){
// 初始化一个布尔类型的查询条件构建器，用于后续添加各种查询条件
BoolQueryBuilder keywordQueryBuilder = new BoolQueryBuilder();
// 根据参数生成对应的查询类型枚举，用于确定如何构建查询条件
EsQueryTypeEnum queryTypeEnum = generateQueryTypeEnum(parameter);
// 调用查询类型枚举中定义的添加条件处理器，处理当前搜索参数，并将其添加到查询条件构建器中
queryTypeEnum.getAddConditionHandler().handle(this,keywordQueryBuilder,parameter.getKeyword());
return keywordQueryBuilder;
}
/**
* 根据关键词和字段枚举生成查询条件。
* @param keyword 关键词，用于构建查询条件。
* @param fieldEnum 字段枚举，包含字段配置信息，用于指定要查询的字段。
* @param highlight 是否高亮处理。
* @return org.elasticsearch.index.query.QueryBuilder 查询构建器，用于构建Elasticsearch的查询语句。
*/
private QueryBuilder generateCondition(String keyword, EsQueryFieldEnum fieldEnum, boolean highlight){
EsQueryFieldConfigDTO fieldConfigDTO = fieldEnum.getFieldConfig();
// 构建基于关键词的基本查询条件
BoolQueryBuilder boolQueryBuilder = EsQueryBuilderUtils.generateFieldQueryBuilder(keyword,
true, fieldConfigDTO.getSearchFieldList());
if(BooleanUtils.isTrue(fieldConfigDTO.getIsNested())){
// 如果是嵌套类型字段，则使用NestedQueryBuilder来处理
NestedQueryBuilder
nestedQueryBuilder = new NestedQueryBuilder(fieldConfigDTO.getMainField(), boolQueryBuilder, ScoreMode.Avg);
if(highlight && isHighlight){
// 如果需要高亮显示，则为嵌套类型字段设置高亮处理
String innerHitName = generateInnerHitName(fieldEnum);
InnerHitBuilder innerHitBuilder = EsHighlightUtils.buildNestHighlightBuilder(innerHitName,
fieldConfigDTO.getSearchFieldList());
nestedQueryBuilderHighlightMap.put(nestedQueryBuilder,innerHitBuilder);
}
return nestedQueryBuilder;
}else{
// 对于非嵌套类型字段，处理高亮显示的逻辑
if(highlight && isHighlight){
// 收集非嵌套类型的高亮字段
noNestedHighlightFields.addAll(fieldConfigDTO.getSearchFieldList());
}
return boolQueryBuilder;
}
}
/**
* 生成嵌套查询的innerHit名称
* @param fieldEnum
* @return java.lang.String
**/
private String generateInnerHitName(EsQueryFieldEnum fieldEnum){
IntAccumulator accumulator = accNestedFieldMap.get(fieldEnum.getFieldConfig().getMainField());
accumulator.accumulate(1);
return fieldEnum.getFieldConfig().getMainField()+"-"+accumulator.getValue();
}
/**
* 向查询构建器中添加公司名称条件。
* @param esQueryBuilder ES查询构建器，用于生成特定的ES查询条件。
* @param keywordQueryBuilder 关键词查询构建器，用于组合不同的查询条件。
* @param keyword 用户输入的关键词，用于匹配公司名称。
*/
public static void addCompanyNameCondition(EsQueryBuilder esQueryBuilder,BoolQueryBuilder keywordQueryBuilder,
String keyword) {
// 根据关键词和字段类型（当前公司名称），生成查询条件，并添加到关键词查询构建器中
keywordQueryBuilder.should(esQueryBuilder.generateCondition(keyword,EsQueryFieldEnum.CURRENT_COMPANY,true));
// 根据关键词和字段类型（履历中的公司名称），生成查询条件，并添加到关键词查询构建器中
keywordQueryBuilder.should(esQueryBuilder.generateCondition(keyword,EsQueryFieldEnum.TRACK_RECORD_COMPANY,true));
}
}
其他相关代码：
定义一个适用Lambda表达式的接口
/**
* Es 搜索条件处理器
*/
@FunctionalInterface
public interface IEsQueryConditionHandler {
/**
* 处理Es搜索条件
* @param esQueryBuilder
* @param keywordQueryBuilder
* @param keyword
* @return void
*/
void handle(EsQueryBuilder esQueryBuilder, BoolQueryBuilder keywordQueryBuilder,
String keyword);
}
定义搜索字段的枚举
/**
* 专家库ES查询字段枚举
*/
public enum EsQueryFieldEnum {
/**
* 当前公司
*/
CURRENT_COMPANY(10,"当前公司", EsQueryFieldConfigDTO.builder()
.mainField("companyInfo")
.isNested(false)
.searchFieldList(List.of("companyInfo.companyName"))
.build()),
/**
* 工作经历公司
*/
TRACK_RECORD_COMPANY(20,"工作经历公司", EsQueryFieldConfigDTO.builder()
.mainField("trackRecordList")
.isNested(true)
.searchFieldList(List.of("trackRecordList.companyName","trackRecordList.companyOtherName"))
.build()),
;
/**
* 嵌套字段列表
*/
private static final List<EsQueryFieldEnum> NESTED_FIELD_LIST = Stream.of(EsQueryFieldEnum.values())
.filter(item->item.fieldConfig.getIsNested()).collect(Collectors.toList());
EsQueryFieldEnum(Integer value, String description,
EsQueryFieldConfigDTO fieldConfig){
this.value =value;
this.description = description;
this.fieldConfig = fieldConfig;
}
private final Integer value;
private final String description;
private final EsQueryFieldConfigDTO fieldConfig;
public Integer value() {
return this.value;
}
public String getDescription() {
return this.description;
}
public EsQueryFieldConfigDTO getFieldConfig() {
return fieldConfig;
}
/**
* 获取嵌套字段列表
*/
public static List<EsQueryFieldEnum> getNestedFieldList() {
return NESTED_FIELD_LIST;
}
}
定义搜索类型的枚举
/**
* ES查询类型枚举
**/
public enum EsQueryTypeEnum {
/**
* 公司
*/
COMPANY(20,"公司", EsQueryBuilder::addCompanyNameCondition),
;
EsQueryTypeEnum(Integer value, String description,
IEsQueryConditionHandler addConditionHandler){
this.value =value;
this.description = description;
this.addConditionHandler = addConditionHandler;
}
private final Integer value;
private final String description;
private final IEsQueryConditionHandler addConditionHandler;
public Integer value() {
return this.value;
}
public String getDescription() {
return this.description;
}
public IEsQueryConditionHandler getAddConditionHandler() {
return addConditionHandler;
}
public static EsQueryTypeEnum resolve(Integer statusCode) {
for (EsQueryTypeEnum status : values()) {
if (status.value.equals(statusCode)) {
return status;
}
}
return null;
}
}
使用方法
SearchSourceBuilder searchSourceBuilder = queryBuilder
// 增加关键字查询条件条件
.addCondition()
// 组合条件过滤
.filterCondition(EsQueryHandler.getAdvancedSearchQueryBuilder(searchParameter))
//生成查询语句
.build();
// 获取总条数
Integer total = EsService.countBySearch(searchSourceBuilder);
//重新生成高亮查询语句
searchSourceBuilder = queryBuilder.buildWithHighlight();
//补充排序规则
EsQueryHandler.setSearchSortRule(searchSourceBuilder,searchParameter.getSortType());
// 从第几页开始
searchSourceBuilder.from(searchParameter.getOffset());
// 每页显示多少条
searchSourceBuilder.size(searchParameter.getLimit());
//分页搜索
List<EsAllInfoDTO> allInfoList = EsService.listByPageSearch(searchSourceBuilder);
问题2解决方案
合并高亮的处理，这个问题实际就是：对于一个字符串a，存在多个字符串a1,a2,a3，并且a1,a2,a3再过滤掉<em>和</em> 字符后是相同的字符串。现在需要将字符串a,a1,a2,a3 合并为一个字符串fa。合并后的字符串需要满足：
1、fa过滤掉<em>和</em> 字符后同a相同
2、所有在a1,a2,a3被<em>和</em>包围的子字符串，在fa同样被<em>和</em>包围
另外要保证一个点是原始的字符串a不能本身就有<em>或</em> 这些字符串，这个可以通过对数据源头进行过滤就可以了。比如使用Jsonp 过滤。
合并高亮字符串的具体的实现算法如下：
/**
* Es高亮工具类
*/
public class EsHighlightUtils {
public static final String emBegin = "<em>";
public static final String emEnd = "</em>";
private static final String emRegex = "(?i)<em>|</em>";
private static final int emBeginLen = emBegin.length();
private static final int emEndLen = emEnd.length();
/**
* 将字符串数组中的字符串合并，并在特定位置添加增强标签（<em></em>）。
* @param stringList 字符串数组，数组中所有字符串如果去除"<em>" 和"</em>"后必定是相同的字符串。
* @return 合并后的字符串，增强了指定的字符串片段。
*/
public static String mergeStrWithEmTags(List<String> stringList) {
// 移除原始字符串中的所有em标签，获取干净的源字符串
String sourceStr = stringList.get(0).replaceAll(emRegex, "");
// 使用StringBuilder来操作源字符串，以便高效地添加em标签
StringBuilder sourceBuilder = new StringBuilder(sourceStr);
// 初始化一个布尔数组，用于标记哪些字符需要增强
boolean[] emFlags = new boolean[sourceStr.length()];
// 填充布尔数组，标记需要增强的字符位置
fillEmFlags(stringList, emFlags);
// 根据标记，在相应位置添加em标签
addEmFlags(sourceBuilder, emFlags);
return sourceBuilder.toString();
}
/**
* 为给定的字符串数组中的每个字符串设置强调标志数组。
* 该方法会查找每个字符串中所有"<em>"开头和"</em>"结尾的包围结构，
* 并将这些包围结构在原字符串中的对应部分在标志数组中设置为true。
* @param stringList 字符串数组，包含需要处理的字符串。
* @param emFlags 增强标志数组，与字符串数组对应，用于标记特定部分。
*/
private static void fillEmFlags(List<String> stringList, boolean[] emFlags) {
// 遍历字符串数组，为每个字符串设置强调标志
for(int j = 0; j< stringList.size(); j++){
String str = stringList.get(j);
// 查找每个字符串中"<em>"的起始位置
int beginIndex = str.indexOf(emBegin);
int cumulativeOffset = 0;
int noEmLen = 0;
int endIndex = 0;
while(beginIndex != -1){
//计算没有增强的字符串长度
noEmLen = endIndex>0?Math.max(beginIndex - (endIndex + emEndLen),0):beginIndex;
// 查找"<em>"后的"</em>"位置
endIndex = str.indexOf(emEnd,beginIndex+emBeginLen);
if(endIndex==-1){
// 如果找不到结束标签，则跳出循环
break;
}
// 计算被包围的子字符串长度
int emSubLength = endIndex - beginIndex - emBeginLen;
// 更新累计偏移量,跳过未增强的字符串
cumulativeOffset = cumulativeOffset+ noEmLen;
// 将被包围的子字符串在标志数组中对应的元素设置为true
for(int i=0;i<emSubLength;i++){
emFlags[cumulativeOffset + i] = true;
}
// 更新累计偏移量，为处理下一个"<em>"做准备
cumulativeOffset = cumulativeOffset + emSubLength;
// 计算下一个"<em>"标签的起始位置
beginIndex = endIndex + emEndLen;
// 继续查找下一个"<em>"
beginIndex = str.indexOf(emBegin,beginIndex);
}
}
}
/**
* 向源字符串中插入增强标签。
* 根据给定的增强标志数组（emFlags），在源字符串（sourceBuilder）中插入开始（emBegin）和结束（emEnd）标签。
* 当emFlags中的元素为true时，表示字符串的这个位置需要被增强
* @param sourceBuilder 被插入标签的源字符串的StringBuilder对象。
* @param emFlags 增强标志数组，true表示字符串的这个位置需要被增强。
*/
private static void addEmFlags(StringBuilder sourceBuilder, boolean[] emFlags) {
// 初始化是否开始插入标签的标志和累计偏移量
boolean startEm = false;
int cumulativeOffset = 0 ;
// 遍历增强标志数组，根据标志插入相应的标签
for (boolean emFlag : emFlags) {
if (emFlag) {
// 当前位置需要插入开始标签
if (!startEm) {
// 第一次需要插入开始标签，进行插入操作并更新累计偏移量
startEm = true;
sourceBuilder.insert(cumulativeOffset, emBegin);
cumulativeOffset += emBeginLen;
}
// 无论是否第一次，只要需要插入开始标签，累计偏移量就需要增加
cumulativeOffset++;
} else {
// 当前位置需要插入结束标签
if (startEm) {
// 已经开始插入标签，进行插入操作并更新累计偏移量
sourceBuilder.insert(cumulativeOffset, emEnd);
cumulativeOffset += emEndLen;
}
// 标记不再插入开始标签
startEm = false;
// 累计偏移量增加
cumulativeOffset++;
}
}
// 如果遍历结束时正在插入开始标签，插入结束标签
if(startEm){
sourceBuilder.insert(cumulativeOffset,emEnd);
}
}
/**
* 构建嵌套的高亮 InnerHitBuilder
* @param name
* @param fields
* @return org.elasticsearch.index.query.InnerHitBuilder
*/
public static InnerHitBuilder buildNestHighlightBuilder(String name, Collection<String> fields) {
if(CollectionUtils.isEmpty(fields)){
return null;
}
InnerHitBuilder innerHitBuilder = StringUtils.isBlank(name)?new InnerHitBuilder():new InnerHitBuilder(name);
HighlightBuilder highlightBuilder = new HighlightBuilder();
highlightBuilder.preTags(emBegin).postTags(emEnd);
//设置高亮的方法
highlightBuilder.highlighterType("plain");
//设置分段的数量不做限制
highlightBuilder.numOfFragments(0);
for(String field:fields){
highlightBuilder.field(field);
}
innerHitBuilder.setHighlightBuilder(highlightBuilder);
return innerHitBuilder;
}
/**
* 构建非嵌套的高亮 HighlightBuilder
* @param fields
* @return org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder
*/
public static HighlightBuilder buildNotNestHighlightBuilder(Collection<String> fields) {
HighlightBuilder highlightBuilder = new HighlightBuilder();
highlightBuilder.preTags(emBegin).postTags(emEnd);
//设置高亮的方法
highlightBuilder.highlighterType("plain");
//设置分段的数量不做限制
highlightBuilder.numOfFragments(0);
for(String field:fields){
highlightBuilder.field(field);
}
return highlightBuilder;
}
}
修改https://blog.csdn.net/weixin_48990070/article/details/120342597 这篇笔记中的替换高亮处理的代码，思路为每次只合并找到的第一个高亮内容，将它和当前的原始内容合并，并将合并后的内容替换掉原始内容。重复这个动作知道所有高亮的内容都被合并到当前的原始内容中。
/**
* 替换嵌套高亮的值
* @param sourceObj
* @param nestedEle
* @param highlightEle
* @return void
*/
private void replaceInnerHighlightValue(JsonObject sourceObj, JsonElement nestedEle, JsonElement highlightEle){
if(nestedEle==null || highlightEle==null){
return ;
}
//获取源对象中的嵌套字段名称
JsonObject nestedObj= nestedEle.getAsJsonObject();
String innerFieldName = nestedObj.get("field").getAsString();
//获取当前对象匹配的源对象中的偏移位置
int innerFieldOffset = nestedObj.get("offset").getAsInt();
//获取源对象
JsonObject findSourceObj = GsonUtils.getJsonObjectForArray(sourceObj,innerFieldName,innerFieldOffset);
if(findSourceObj==null){
return ;
}
//替换高亮的部分
log.debug("高亮的部分:{}",highlightEle);
JsonObject highlightObj = highlightEle.getAsJsonObject();
highlightObj.entrySet().forEach((h)->{
//合并高亮字段对应的原值
String highlightValue = h.getValue().getAsString();
JsonObject currentSourceObj = findSourceObj;
String[] keyNames = StringUtils.split(h.getKey(),".");
//循环到倒数第二层，获取待替换字段值对象
for(int i=0;i<keyNames.length-2;i++){
String keyName = keyNames[i+1];
currentSourceObj = currentSourceObj.get(keyName).getAsJsonObject();
}
//获取最后一层的字段名称
String lastFieldName = keyNames[keyNames.length-1];
//获取高亮字段对应的原值
String sourceValue = currentSourceObj.get(lastFieldName).getAsString();
//合并原值和高亮增强的值
String mergedValue = EsHighlightUtils.mergeStrWithEmTags(List.of(sourceValue, highlightValue));
//替换最后一层对象的指定字段的值
GsonUtils.replaceFieldValue(currentSourceObj,
lastFieldName, mergedValue);
});
log.debug("替换后的高亮的部分{}",findSourceObj);
}
