SpringBoot使用注解的方式构建Elasticsearch查询语句，实现多条件的复杂查询
背景&痛点
通过ES进行查询，如果需要新增查询条件，则每次都需要进行硬编码，然后实现对应的查询功能。这样不仅开发工作量大，而且如果有多个不同的索引对象需要进行同样的查询，则需要开发多次，代码复用性不高。
想要解决这个问题，那么就需要一种能够模块化、配置化的解决方案。
解决方案
思路一：配置参数
通过配置参数的方式来配置参数映射、查询方式等，代码读取配置文件，根据配置文件构建查询语句。
优点：可配置化，新增查询字段基本不需要改动代码，除非增加新的查询方式。
缺点：配置文件太多、太复杂，配置文件配置错误将会导致整个查询不可用。
思路二：注解方式
和方案一类似，通过注解的方式来配置参数映射等，然后读取注解，根据注解构建查询语句。
优点：可配置化，代码清晰、明确，可读性高。
缺点：每次新增查询字段都需要改动代码（在指定字段增加注解）
目前只有这两种可以说大同小异的解决思路，不过不喜欢配置文件太多，所以我就选择了第二种思路。
代码实现(Elasticsearch版本6.7.2)
首先需要创建一个查询方式的枚举类，来区分有哪些查询方式，目前只实现了一些常用的查询类型。
源码如下：
package com.lifengdi.search.enums;
/**
* @author 李锋镝
* @date Create at 19:17 2019/8/27
*/
public enum QueryTypeEnum {
/**
* 等于
*/
EQUAL,
/**
* 忽略大小写相等
*/
EQUAL_IGNORE_CASE,
/**
* 范围
*/
RANGE,
/**
* in
*/
IN,
IGNORE,
/**
* 搜索
*/
FULLTEXT,
/**
* 匹配 和q搜索区分开
*/
MATCH,
/**
* 模糊查询
*/
FUZZY,
/**
* and
*/
AND,
/**
* 多个查询字段匹配上一个即符合条件
*/
SHOULD,
/**
* 前缀查询
*/
PREFIX,
;
}
然后开始自定义注解，通过注解来定义字段的查询方式、映射字段、嵌套查询的 path
以及其他的一些参数；通过 @Repeatable
注解来声明这是一个重复注解类。
源码如下：
package com.lifengdi.search.annotation;
import com.lifengdi.search.enums.QueryTypeEnum;
import java.lang.annotation.*;
/**
* 定义查询字段的查询方式
* @author 李锋镝
* @date Create at 19:07 2019/8/27
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.TYPE})
@Repeatable(DefinitionQueryRepeatable.class)
public @interface DefinitionQuery {
/**
* 查询参数
*
* @return 查询字段
*/
String key() default "";
/**
* 查询类型 see{@link QueryTypeEnum}
*
* @return QueryTypeEnum
*/
QueryTypeEnum type() default QueryTypeEnum.EQUAL;
/**
* 范围查询 from后缀
*
* @return from后缀
*/
String fromSuffix() default "From";
/**
* 范围查询 to后缀
*
* @return to后缀
*/
String toSuffix() default "To";
/**
* 多个字段分隔符
*
* @return 分隔符
*/
String separator() default ",";
/**
* 指定对象的哪个字段将应用于查询映射
* 例如：
* 同一个文档下有多个User对象，对象名分别为createdUser、updatedUser，该User对象的属性有name等字段，
* 如果要根据查询createdUser的name来进行查询，
* 则可以这样定义DefinitionQuery：queryField = cName, mapped = createdUser.name
*
* @return 映射的实体的字段路径
*/
String mapped() default "";
/**
* 嵌套查询的path
*
* @return path
*/
String nestedPath() default "";
}
同时定义 @DefinitionQueryRepeatable
注解，声明这是上边注解的容器注解类，源码如下：
package com.lifengdi.search.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* @author 李锋镝
* @date Create at 19:11 2019/8/27
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.TYPE})
public @interface DefinitionQueryRepeatable {
DefinitionQuery[] value();
}
如何使用注解？
- 在索引文档中需要查询的字段、对象或者类上面使用即可。
源码如下：
package com.lifengdi.document;
import com.lifengdi.document.store.*;
import com.lifengdi.search.annotation.DefinitionQuery;
import com.lifengdi.search.enums.QueryTypeEnum;
import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;
import java.util.List;
/**
* 门店Document
*
* @author 李锋镝
* @date Create at 19:31 2019/8/22
*/
@Document(indexName = "store", type = "base")
@Data
@DefinitionQuery(key = "page", type = QueryTypeEnum.IGNORE)
@DefinitionQuery(key = "size", type = QueryTypeEnum.IGNORE)
@DefinitionQuery(key = "q", type = QueryTypeEnum.FULLTEXT)
public class StoreDocument {
@Id
@DefinitionQuery(type = QueryTypeEnum.IN)
@DefinitionQuery(key = "id", type = QueryTypeEnum.IN)
@Field(type = FieldType.Keyword)
private String id;
/**
* 基础信息
*/
@Field(type = FieldType.Object)
private StoreBaseInfo baseInfo;
/**
* 标签
*/
@Field(type = FieldType.Nested)
@DefinitionQuery(key = "tagCode", mapped = "tags.key", type = QueryTypeEnum.IN)
@DefinitionQuery(key = "tagValue", mapped = "tags.value", type = QueryTypeEnum.AND)
@DefinitionQuery(key = "_tagValue", mapped = "tags.value", type = QueryTypeEnum.IN)
private List<StoreTags> tags;
}
package com.lifengdi.document.store;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.lifengdi.search.annotation.DefinitionQuery;
import com.lifengdi.search.enums.QueryTypeEnum;
import com.lifengdi.serializer.JodaDateTimeDeserializer;
import com.lifengdi.serializer.JodaDateTimeSerializer;
import lombok.Data;
import org.joda.time.DateTime;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;
/**
* 门店基础信息
*
*/
@Data
public class StoreBaseInfo {
/**
* 门店id
*/
@Field(type = FieldType.Keyword)
private String storeId;
/**
* 门店名称
*/
@Field(type = FieldType.Text, analyzer = "ik_smart")
@DefinitionQuery(type = QueryTypeEnum.FUZZY)
@DefinitionQuery(key = "name", type = QueryTypeEnum.SHOULD)
private String storeName;
/**
* 门店简称
*/
@Field(type = FieldType.Text, analyzer = "ik_smart")
private String shortName;
/**
* 门店简介
*/
@Field(type = FieldType.Text, analyzer = "ik_smart")
private String profile;
/**
* 门店属性
*/
@Field(type = FieldType.Integer)
private Integer property;
/**
* 门店类型
*/
@Field(type = FieldType.Integer)
private Integer type;
/**
* 详细地址
*/
@Field(type = FieldType.Text, analyzer = "ik_smart")
private String address;
/**
* 所在城市
*/
@Field(type = FieldType.Keyword)
@DefinitionQuery(type = QueryTypeEnum.IN)
private String cityCode;
/**
* 城市名称
*/
@Field(type = FieldType.Keyword)
private String cityName;
/**
* 所在省份
*/
@Field(type = FieldType.Keyword)
private String provinceCode;
/**
* 省份名称
*/
@Field(type = FieldType.Keyword)
private String provinceName;
/**
* 所在地区
*/
@Field(type = FieldType.Keyword)
private String regionCode;
/**
* 地区名称
*/
@Field(type = FieldType.Keyword)
private String regionName;
/**
* 所属市场id
*/
@Field(type = FieldType.Long)
@DefinitionQuery(type = QueryTypeEnum.IN)
private Integer marketId;
/**
* 所属市场key
*/
@Field(type = FieldType.Keyword)
@DefinitionQuery(type = QueryTypeEnum.IN)
private String marketKey;
/**
* 所属市场名称
*/
@Field(type = FieldType.Keyword)
private String marketName;
/**
* 摊位号
*/
@Field(type = FieldType.Text)
private String marketStall;
/**
* 门店状态
*/
@Field(type = FieldType.Keyword)
@DefinitionQuery(key = "storeStatus", type = QueryTypeEnum.IN)
@DefinitionQuery(key = "_storeStatus", type = QueryTypeEnum.IN)
private String status;
/**
* 删除标示
*/
@Field(type = FieldType.Integer)
@DefinitionQuery(key = "deleted")
private Integer deleted;
/**
* 创建时间
*/
@Field(type = FieldType.Date)
@JsonDeserialize(using = JodaDateTimeDeserializer.class)
@JsonSerialize(using = JodaDateTimeSerializer.class)
@DefinitionQuery(type = QueryTypeEnum.RANGE)
public DateTime createdTime;
/**
* 创建人id
*/
@Field(type = FieldType.Keyword)
@DefinitionQuery
private String createdUserId;
/**
* 创建人名称
*/
@Field(type = FieldType.Keyword)
private String createdUserName;
/**
* 修改时间
*/
@Field(type = FieldType.Date)
@JsonDeserialize(using = JodaDateTimeDeserializer.class)
@JsonSerialize(using = JodaDateTimeSerializer.class)
private DateTime updatedTime;
/**
* 修改人ID
*/
@Field(type = FieldType.Keyword)
private String updatedUserId;
/**
* 修改人姓名
*/
@Field(type = FieldType.Keyword)
private String updatedUserName;
/**
* 业务类型
*/
@Field(type = FieldType.Long)
private Long businessType;
/**
* storeNo
*/
@Field(type = FieldType.Keyword)
@DefinitionQuery(type = QueryTypeEnum.SHOULD)
private String storeNo;
}
package com.lifengdi.document.store;
import lombok.Data;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;
/**
* @author 李锋镝
* @date Create at 18:15 2019/2/18
*/
@Data
public class StoreTags {
@Field(type = FieldType.Keyword)
private String key;
@Field(type = FieldType.Keyword)
private String value;
private String showName;
}
解释一下上面的源码：
@DefinitionQuery(key = "tagCode", mapped = "tags.key", type = QueryTypeEnum.IN)
这行代码的意思是指定一个查询参数 tagCode
，该参数映射到 tags
的 key
字段，查询方式为 IN
，调用接口入参查询的时候只需要入参 tagCode={tagCode}
即可。
请求体：
curl -X POST /
http://localhost:8080/search/store/search /
-H 'Content-Type: application/json' /
-d '{
"tagCode": "1"
}'
构建的ES查询语句：
{
"query": {
"bool": {
"must": [
{
"nested": {
"query": {
"bool": {
"must": [
{
"terms": {
"tags.key": [
"1"
],
"boost": 1
}
}
],
"adjust_pure_negative": true,
"boost": 1
}
},
"path": "tags",
"ignore_unmapped": false,
"score_mode": "none",
"boost": 1
}
}
],
"adjust_pure_negative": true,
"boost": 1
}
}
}
继续说源码
使用了注解，就需要将注解中的参数提取出来，并生成映射数据，目前实现的是将所有的字段全都封装到Map中，查询的时候遍历取值。
源码如下：
package com.lifengdi.search.mapping;
import com.lifengdi.SearchApplication;
import com.lifengdi.model.FieldDefinition;
import com.lifengdi.model.Key;
import com.lifengdi.search.annotation.DefinitionQuery;
import com.lifengdi.search.annotation.DefinitionQueryRepeatable;
import org.apache.commons.lang3.StringUtils;
import org.springframework.data.elasticsearch.annotations.FieldType;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
/**
* @author 李锋镝
* @date Create at 09:15 2019/8/28
*/
public class KeyMapping {
// 启动类所在包
private static final String BOOTSTRAP_PATH = SearchApplication.class.getPackage().getName();
/**
* 字段映射
* @param clazz Class
* @return Map
*/
public static Map<Key, FieldDefinition> mapping(Class clazz) {
Map<Key, FieldDefinition> mappings = mapping(clazz.getDeclaredFields(), "");
mappings.putAll(typeMapping(clazz));
return mappings;
}
/**
* 字段映射
*
* @param fields 字段
* @param parentField 父级字段名
* @return Map
*/
public static Map<Key, FieldDefinition> mapping(Field[] fields, String parentField) {
Map<Key, FieldDefinition> mappings = new HashMap<>();
for (Field field : fields) {
org.springframework.data.elasticsearch.annotations.Field fieldAnnotation = field.getAnnotation
(org.springframework.data.elasticsearch.annotations.Field.class);
String nestedPath = null;
if (Objects.nonNull(fieldAnnotation) && FieldType.Nested.equals(fieldAnnotation.type())) {
nestedPath = parentField + field.getName();
}
DefinitionQuery[] definitionQueries = field.getAnnotationsByType(DefinitionQuery.class);
// 如果属性非BOOTSTRAP_PATH包下的类，说明属性为基础字段 即跳出循环，否则递归调用mapping
if (!field.getType().getName().startsWith(BOOTSTRAP_PATH)) {
for (DefinitionQuery definitionQuery : definitionQueries) {
buildMapping(parentField, mappings, field, nestedPath, definitionQuery);
}
} else {
for (DefinitionQuery definitionQuery : definitionQueries) {
if (StringUtils.isNotBlank(definitionQuery.mapped())) {
buildMapping(parentField, mappings, field, nestedPath, definitionQuery);
}
}
mappings.putAll(mapping(field.getType().getDeclaredFields(), parentField + field.getName() + "."));
}
}
return mappings;
}
/**
* 构建mapping
* @param parentField 父级字段名
* @param mappings mapping
* @param field 字段
* @param nestedPath 默认嵌套路径
* @param definitionQuery 字段定义
*/
private static void buildMapping(String parentField, Map<Key, FieldDefinition> mappings, Field field,
String nestedPath, DefinitionQuery definitionQuery) {
FieldDefinition fieldDefinition;
nestedPath = StringUtils.isNotBlank(definitionQuery.nestedPath()) ? definitionQuery.nestedPath() : nestedPath;
String key = StringUtils.isBlank(definitionQuery.key()) ? field.getName() : definitionQuery.key();
String filedName = StringUtils.isBlank(definitionQuery.mapped()) ? field.getName() : definitionQuery.mapped();
switch (definitionQuery.type()) {
case RANGE:
buildRange(parentField, mappings, definitionQuery, key, filedName);
break;
default:
fieldDefinition = FieldDefinition.builder()
.key(key)
.queryField(parentField + filedName)
.queryType(definitionQuery.type())
.separator(definitionQuery.separator())
.nestedPath(nestedPath)
.build();
mappings.put(new Key(key), fieldDefinition);
break;
}
}
/**
* 构建范围查询
* @param parentField 父级字段名
* @param mappings mapping
* @param definitionQuery 字段定义
* @param key 入参查询字段
* @param filedName 索引文档中字段名
*/
private static void buildRange(String parentField, Map<Key, FieldDefinition> mappings, DefinitionQuery definitionQuery,
String key, String filedName) {
FieldDefinition fieldDefinition;
String queryField = parentField + filedName;
String rangeKeyFrom = key + definitionQuery.fromSuffix();
String rangeKeyTo = key + definitionQuery.toSuffix();
fieldDefinition = FieldDefinition.builder()
.key(rangeKeyFrom)
.queryField(queryField)
.queryType(definitionQuery.type())
.fromSuffix(definitionQuery.fromSuffix())
.toSuffix(definitionQuery.toSuffix())
.build();
mappings.put(new Key(rangeKeyFrom), fieldDefinition);
fieldDefinition = FieldDefinition.builder()
.key(rangeKeyTo)
.queryField(queryField)
.queryType(definitionQuery.type())
.fromSuffix(definitionQuery.fromSuffix())
.toSuffix(definitionQuery.toSuffix())
.build();
mappings.put(new Key(rangeKeyTo), fieldDefinition);
}
/**
* 对象映射
* @param clazz document
* @return Map
*/
public static Map<Key, FieldDefinition> typeMapping(Class clazz) {
DefinitionQueryRepeatable repeatable = (DefinitionQueryRepeatable) clazz.getAnnotation(DefinitionQueryRepeatable.class);
Map<Key, FieldDefinition> mappings = new HashMap<>();
for (DefinitionQuery definitionQuery : repeatable.value()) {
String key = definitionQuery.key();
switch (definitionQuery.type()) {
case RANGE:
buildRange("", mappings, definitionQuery, key, definitionQuery.mapped());
break;
default:
FieldDefinition fieldDefinition = FieldDefinition.builder()
.key(key)
.queryField(key)
.queryType(definitionQuery.type())
.separator(definitionQuery.separator())
.nestedPath(definitionQuery.nestedPath())
.build();
mappings.put(new Key(key), fieldDefinition);
break;
}
}
return mappings;
}
}
定义 Key
对象，解决重复字段在Map中会覆盖的问题：
package com.lifengdi.model;
/**
* @author 李锋镝
* @date Create at 09:25 2019/8/28
*/
public class Key {
private String key;
public Key(String key) {
this.key = key;
}
@Override
public String toString() {
return key;
}
public String getKey() {
return key;
}
}
接下来重头戏来了，根据查询类型的枚举值，来封装对应的ES查询语句，如果需要新增查询类型，则新增枚举，然后新增对应的实现代码；同时也增加了对排序的支持，不过排序字段需要传完整的路径，暂时还未实现通过mapping映射来进行对应的排序。
源码如下：
package com.lifengdi.search;
import com.lifengdi.model.FieldDefinition;
import com.lifengdi.model.Key;
import com.lifengdi.search.enums.QueryTypeEnum;
import org.apache.commons.lang3.StringUtils;
import org.apache.lucene.search.join.ScoreMode;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.index.query.*;
import org.elasticsearch.search.sort.SortBuilders;
import org.elasticsearch.search.sort.SortOrder;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.query.SearchQuery;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import javax.annotation.Resource;
import java.util.*;
import java.util.concurrent.atomic.AtomicBoolean;
import static com.lifengdi.global.Global.*;
/**
* @author 李锋镝
* @date Create at 16:49 2019/8/27
*/
@Service
public class SearchService {
@Resource
private ElasticsearchTemplate elasticsearchTemplate;
/**
* 通用查询
* @param params 查询入参
* @param indexName 索引名称
* @param type 索引类型
* @param defaultSort 默认排序
* @param keyMappings 字段映射
* @param keyMappingsMap 索引对应字段映射
* @return Page
*/
protected Page<Map> commonSearch(Map<String, String> params, String indexName, String type, String defaultSort,
Map<Key, FieldDefinition> keyMappings,
Map<String, Map<Key, FieldDefinition>> keyMappingsMap) {
SearchQuery searchQuery = buildSearchQuery(params, indexName, type, defaultSort, keyMappings, keyMappingsMap);
return elasticsearchTemplate.queryForPage(searchQuery, Map.class);
}
/**
* 数量通用查询
* @param params 查询入参
* @param indexName 索引名称
* @param type 索引类型
* @param defaultSort 默认排序
* @param keyMappings 字段映射
* @param keyMappingsMap 索引对应字段映射
* @return Page
*/
protected long count(Map<String, String> params, String indexName, String type, String defaultSort,
Map<Key, FieldDefinition> keyMappings,
Map<String, Map<Key, FieldDefinition>> keyMappingsMap) {
SearchQuery searchQuery = buildSearchQuery(params, indexName, type, defaultSort, keyMappings, keyMappingsMap);
return elasticsearchTemplate.count(searchQuery);
}
/**
* 根据ID获取索引
* @param id ID
* @param indexName 索引名
* @param type 索引类型
* @return 索引
*/
protected Map get(String id, String indexName, String type) {
return elasticsearchTemplate.getClient()
.prepareGet(indexName, type, id)
.execute()
.actionGet()
.getSourceAsMap();
}
/**
* 根据定义的查询字段封装查询语句
* @param params 查询入参
* @param indexName 索引名称
* @param type 索引类型
* @param defaultSort 默认排序
* @param keyMappings 字段映射
* @param keyMappingsMap 索引对应字段映射
* @return SearchQuery
*/
private SearchQuery buildSearchQuery(Map<String, String> params, String indexName, String type, String defaultSort,
Map<Key, FieldDefinition> keyMappings,
Map<String, Map<Key, FieldDefinition>> keyMappingsMap) {
NativeSearchQueryBuilder searchQueryBuilder = buildSearchField(params, indexName, type, keyMappings, keyMappingsMap);
String sortFiled = params.getOrDefault(SORT, defaultSort);
if (StringUtils.isNotBlank(sortFiled)) {
String[] sorts = sortFiled.split(SPLIT_FLAG_COMMA);
handleQuerySort(searchQueryBuilder, sorts);
}
return searchQueryBuilder.build();
}
/**
* 根据定义的查询字段封装查询语句
* @param params 查询入参
* @param indexName 索引名称
* @param type 索引类型
* @param keyMappings 字段映射
* @param keyMappingsMap 索引对应字段映射
* @return NativeSearchQueryBuilder
*/
private NativeSearchQueryBuilder buildSearchField(Map<String, String> params, String indexName, String type,
Map<Key, FieldDefinition> keyMappings,
Map<String, Map<Key, FieldDefinition>> keyMappingsMap) {
int page = Integer.parseInt(params.getOrDefault(PAGE, "0"));
int size = Integer.parseInt(params.getOrDefault(SIZE, "10"));
AtomicBoolean matchSearch = new AtomicBoolean(false);
String q = params.get(Q);
String missingFields = params.get(MISSING);
String existsFields = params.get(EXISTS);
BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
BoolQueryBuilder boolFilterBuilder = QueryBuilders.boolQuery();
Map<String, BoolQueryBuilder> nestedMustMap = new HashMap<>();
Map<String, BoolQueryBuilder> nestedMustNotMap = new HashMap<>();
List<String> fullTextFieldList = new ArrayList<>();
// 查询条件构建器
NativeSearchQueryBuilder searchQueryBuilder = new NativeSearchQueryBuilder()
.withIndices(params.getOrDefault(INDEX_NAME, indexName))
.withTypes(params.getOrDefault(INDEX_TYPE, type))
.withPageable(PageRequest.of(page, size));
String fields = params.get(FIELDS);
if (Objects.nonNull(fields)) {
searchQueryBuilder.withFields(fields.split(SPLIT_FLAG_COMMA));
}
keyMappingsMap.getOrDefault(params.getOrDefault(INDEX_NAME, indexName), keyMappings)
.entrySet()
.stream()
.filter(m -> m.getValue().getQueryType() == QueryTypeEnum.FULLTEXT
|| m.getValue().getQueryType() != QueryTypeEnum.IGNORE
&& params.get(m.getKey().toString()) != null)
.forEach(m -> {
String k = m.getKey().toString();
FieldDefinition v = m.getValue();
String queryValue = params.get(k);
QueryTypeEnum queryType = v.getQueryType();
String queryName = v.getQueryField();
String nestedPath = v.getNestedPath();
BoolQueryBuilder nestedMustBoolQuery = null;
BoolQueryBuilder nestedMustNotBoolQuery = null;
boolean nested = false;
if (StringUtils.isNotBlank(nestedPath)) {
nested = true;
if (nestedMustMap.containsKey(nestedPath)) {
nestedMustBoolQuery = nestedMustMap.get(nestedPath);
} else {
nestedMustBoolQuery = QueryBuilders.boolQuery();
}
if (nestedMustNotMap.containsKey(nestedPath)) {
nestedMustNotBoolQuery = nestedMustNotMap.get(nestedPath);
} else {
nestedMustNotBoolQuery = QueryBuilders.boolQuery();
}
}
switch (queryType) {
case RANGE:
RangeQueryBuilder rangeQueryBuilder = new RangeQueryBuilder(queryName);
if (k.endsWith(v.getFromSuffix())) {
rangeQueryBuilder.from(queryValue);
} else {
rangeQueryBuilder.to(queryValue);
}
boolFilterBuilder.must(rangeQueryBuilder);
break;
case FUZZY:
if (nested) {
if (k.startsWith(NON_FLAG)) {
nestedMustBoolQuery.mustNot(QueryBuilders.wildcardQuery(queryName, queryValue));
} else {
nestedMustBoolQuery.filter(QueryBuilders.wildcardQuery(queryName,
StringUtils.wrapIfMissing(queryValue, WILDCARD)));
}
} else {
if (k.startsWith(NON_FLAG)) {
boolFilterBuilder.mustNot(QueryBuilders.wildcardQuery(queryName, queryValue));
} else {
boolFilterBuilder.filter(QueryBuilders.wildcardQuery(queryName,
StringUtils.wrapIfMissing(queryValue, WILDCARD)));
}
}
break;
case PREFIX:
boolFilterBuilder.filter(QueryBuilders.prefixQuery(queryName, queryValue));
break;
case AND:
if (nested) {
for (String and : queryValue.split(v.getSeparator())) {
nestedMustBoolQuery.must(QueryBuilders.termQuery(queryName, and));
}
} else {
for (String and : queryValue.split(v.getSeparator())) {
boolFilterBuilder.must(QueryBuilders.termQuery(queryName, and));
}
}
break;
case IN:
String inQuerySeparator = v.getSeparator();
if (nested) {
buildIn(k, queryValue, queryName, nestedMustBoolQuery, inQuerySeparator, nestedMustNotBoolQuery);
} else {
buildIn(k, queryValue, queryName, boolFilterBuilder, inQuerySeparator);
}
break;
case SHOULD:
boolFilterBuilder.should(QueryBuilders.wildcardQuery(queryName,
StringUtils.wrapIfMissing(queryValue, WILDCARD)));
break;
case FULLTEXT:
if (!Q.equalsIgnoreCase(queryName)) {
fullTextFieldList.add(queryName);
}
break;
case MATCH:
boolQueryBuilder.must(QueryBuilders.matchQuery(queryName, queryValue));
matchSearch.set(true);
break;
case EQUAL_IGNORE_CASE:
boolFilterBuilder.must(QueryBuilders.termQuery(queryName, queryValue.toLowerCase()));
break;
default:
boolFilterBuilder.must(QueryBuilders.termQuery(queryName, queryValue));
break;
}
if (nested) {
if (nestedMustBoolQuery.hasClauses()) {
nestedMustMap.put(nestedPath, nestedMustBoolQuery);
}
if (nestedMustNotBoolQuery.hasClauses()) {
nestedMustNotMap.put(nestedPath, nestedMustNotBoolQuery);
}
}
});
if (StringUtils.isNotBlank(q)) {
MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery(q);
fullTextFieldList.forEach(multiMatchQueryBuilder::field);
boolQueryBuilder.should(multiMatchQueryBuilder);
}
if (StringUtils.isNotBlank(q) || matchSearch.get()) {
searchQueryBuilder.withSort(SortBuilders.scoreSort().order(SortOrder.DESC));
}
if (StringUtils.isNotBlank(missingFields)) {
for (String miss : missingFields.split(SPLIT_FLAG_COMMA)) {
boolFilterBuilder.mustNot(QueryBuilders.existsQuery(miss));
}
}
if (StringUtils.isNotBlank(existsFields)) {
for (String exists : existsFields.split(SPLIT_FLAG_COMMA)) {
boolFilterBuilder.must(QueryBuilders.existsQuery(exists));
}
}
if (!CollectionUtils.isEmpty(nestedMustMap)) {
for (String key : nestedMustMap.keySet()) {
if (StringUtils.isBlank(key)) {
continue;
}
boolFilterBuilder.must(QueryBuilders.nestedQuery(key, nestedMustMap.get(key), ScoreMode.None));
}
}
if (!CollectionUtils.isEmpty(nestedMustNotMap)) {
for (String key : nestedMustNotMap.keySet()) {
if (StringUtils.isBlank(key)) {
continue;
}
boolFilterBuilder.mustNot(QueryBuilders.nestedQuery(key, nestedMustNotMap.get(key), ScoreMode.None));
}
}
searchQueryBuilder.withFilter(boolFilterBuilder);
searchQueryBuilder.withQuery(boolQueryBuilder);
return searchQueryBuilder;
}
private void buildIn(String k, String queryValue, String queryName, BoolQueryBuilder boolQuery, String separator) {
buildIn(k, queryValue, queryName, boolQuery, separator, null);
}
private void buildIn(String k, String queryValue, String queryName, BoolQueryBuilder boolQuery, String separator,
BoolQueryBuilder nestedMustNotBoolQuery) {
if (queryValue.contains(separator)) {
if (k.startsWith(NON_FLAG)) {
if (Objects.nonNull(nestedMustNotBoolQuery)) {
nestedMustNotBoolQuery.must(QueryBuilders.termsQuery(queryName, Arrays.asList(queryValue.split(separator))));
} else {
boolQuery.mustNot(QueryBuilders.termsQuery(queryName, Arrays.asList(queryValue.split(separator))));
}
} else {
boolQuery.must(QueryBuilders.termsQuery(queryName, Arrays.asList(queryValue.split(separator))));
}
} else {
if (k.startsWith(NON_FLAG)) {
if (Objects.nonNull(nestedMustNotBoolQuery)) {
nestedMustNotBoolQuery.must(QueryBuilders.termsQuery(queryName, queryValue));
} else {
boolQuery.mustNot(QueryBuilders.termsQuery(queryName, queryValue));
}
} else {
boolQuery.must(QueryBuilders.termsQuery(queryName, queryValue));
}
}
}
/**
* 处理排序
*
* @param sorts 排序字段
*/
private void handleQuerySort(NativeSearchQueryBuilder searchQueryBuilder, String[] sorts) {
for (String sort : sorts) {
sortBuilder(searchQueryBuilder, sort);
}
}
private void sortBuilder(NativeSearchQueryBuilder searchQueryBuilder, String sort) {
switch (sort.charAt(0)) {
case '-': // 字段前有-: 倒序排序
searchQueryBuilder.withSort(SortBuilders.fieldSort(sort.substring(1)).order(SortOrder.DESC));
break;
case '+': // 字段前有+: 正序排序
searchQueryBuilder.withSort(SortBuilders.fieldSort(sort.substring(1)).order(SortOrder.ASC));
break;
default:
searchQueryBuilder.withSort(SortBuilders.fieldSort(sort.trim()).order(SortOrder.ASC));
break;
}
}
/**
* 获取一个符合查询条件的数据
* @param filterBuilder 查询条件
* @param indexName 索引名
* @param type 索引类型
* @return Map
*/
protected Map<String, Object> getOne(TermQueryBuilder filterBuilder, String indexName, String type) {
final SearchResponse searchResponse = elasticsearchTemplate.getClient()
.prepareSearch(indexName)
.setTypes(type)
.setPostFilter(filterBuilder)
.setSize(1)
.get();
final long total = searchResponse.getHits().getTotalHits();
if (total > 0) {
return searchResponse.getHits().getAt(0).getSourceAsMap();
}
return null;
}
}
好了关键的代码就这么些，具体源码可以在我的github上查看。
Git项目地址： search
如果觉得有帮助的话，请帮忙点赞、点星小小的支持一下~
谢谢~~
本文链接： https://www.lifengdi.com/archives/article/919
正文到此结束
- 本文标签： DOM 开发 Word MQ stream 源码 map GitHub Document 参数 多个字段 Collection equals apache cat API parse REST 删除 IO ArrayList update tar Bootstrap 遍历 list http Service 索引 java js IDE HTML value core Action HashMap 2019 spring https 数据 key client Property bus tk git UI App XML build Atom Elasticsearch 递归 Region 时间 json final ACE id tag tab 配置 代码
- 版权声明： 本文为互联网转载文章，出处已在文章中说明(部分除外)。如果侵权，请联系本站长删除，谢谢。
- 本文海报： 生成海报一 生成海报二
热门推荐
相关文章
近期评论
-
文章和留言都翻到11页了 没有OOM
-
-
朋友，翻页到11页，及以后，会出现OOM，无法访问
-
-
搞个gitee的项目
-
-
版本号是多少，你可以下载哪个代码仓库，jdk选1.8 直接跑就行
-
-
-
Loading...
![[HBLOG]公众号](https://www.liuhaihua.cn/img/qrcode_gzh.jpg)
