背景&痛点
通过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 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 mapping(Class clazz) {
Map mappings = mapping(clazz.getDeclaredFields(), "");
mappings.putAll(typeMapping(clazz));
return mappings;
}
/**
* 字段映射
*
* @param fields 字段
* @param parentField 父级字段名
* @return Map
*/
public static Map mapping(Field[] fields, String parentField) {
Map 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 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 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 typeMapping(Class clazz) {
DefinitionQueryRepeatable repeatable = (DefinitionQueryRepeatable) clazz.getAnnotation(DefinitionQueryRepeatable.class);
Map 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好了关键的代码就这么些，具体源码可以在我的github上查看。
Git项目地址：search
如果觉得有帮助的话，请帮忙点赞、点星小小的支持一下~
谢谢~~
本文链接：https://www.lifengdi.com/archives/article/919