Spring Boot + Querydsl 框架，大大简化复杂查询操作！！

概述

本篇博客主要将介绍的是利用spring query dsl框架实现的服务端查询解析和实现介绍。
查询功能是在各种应用程序里面都有应用，且非常重要的功能。用户直接使用的查询功能往往是在我们做好的UI界面上进行查询，UI会将查询请求发给查询实现的服务器，或者专门负责实现查询的一个组件。市场上有专门做查询的框架，其中比较出名，应用也比较广泛的是elasticsearch。
定义查询请求

对于服务端来说，前端UI发送过来的查询请求必然是按一定规则组织起来的，这样的规则后端必须能够支持和解析。换一种说法就是服务调用者和服务发布者之间需要遵循同一个规范才可以。百度的UI查询是这样定义的：

在上图中加了蓝色下划线的地方即为我们在百度当中搜索的字符串内容，可以发现，百度的实现是将搜索的内容当做了http请求的url的参数来处理的，用了一个q作为key，q后面的内容就是所查询的内容。
google的实现是类似的，如下图所示：

对于google和百度这样的只有一个搜索框的查询界面，这样处理是比较合理的，也不是整个查询实现最关键的部分。更为关键的是后续服务器将这个查询内容进行了怎样的处理。对于别的一些产品来说，可能需要对某些关键字进行单独的查询，这个时候肯定就不是一个搜索框能个满足的需求了。
总的来说，我们可以有如下的方式来组织一个查询
google-like查询

这种查询典型的应用是一个查询框，什么都可以查的情形，例如google和百度。对于这样的查询需求来说,在构建查询请求时只需将查询的内容放在http请求的的参数里面即可。
这样的查询解析是非常方便的，难度和需要考虑得事情在于要讲查询的内容放到哪些地方去查询。从数据库的层面来说就是要去哪些数据库的哪些表去查询。
特定字段的类sql查询

这种查询是指定某个字段，然后采用类似于sql语句的写法进行查询，各种查询条件以一定的形式组织在一起，发给服务器进行解析。这样的查询对服务器解析查询的能力要求更高，它提供了一些更加具体的查询条件。
例如我们以冒号表示等于,则一个查询字符串的形式是:

1. name:bill

复制代码

这个查询的意思就是查询名字name等于bill的记录。
我们也可以将多个条件拼接在一起，让他们直接用逻辑关系组合在一起，例如或者和并且的逻辑关系。例如：

1. name:bill AND city:LA

复制代码

或者下面这种或者的关系：

1. name:bill OR city:LA

复制代码

上面的查询语句意味着我们的前后台要定义一套自己的查询逻辑和架构，并且解析它，并将它转换为正确的查询。若我们想实现灵活的查询，则上面的查询语句在符合规则的前提下应当是可以自由组合的。怎么做取决于我们的实际需求。如果一个写死的查询关键字就能满足我们的需求，则在当前那个时期自然也是合理的。
但是从灵活性角度，技术角度，实现成灵活的可解析的，显然是我们更想要的功能。最灵活的当然就是sql语句能支持怎样的查询，我们都能支持对应的查询写法，但是这对服务器的解析逻辑就有了更加高的要求，尤其是当主表子表混在一起查询之后，会更加复杂
使用Spring Data Querydsl

什么是Querydsl呢？Querydsl是一个框架，它可以通过它提供的的API帮助我们构建静态类型的SQL-like查询，也就是在上面我们提到的组织查询方式。可以通过诸如Querydsl之类的流畅API构造查询。
Querydsl是出于以类型安全的方式维护HQL查询的需要而诞生的。 HQL查询的增量构造需要String连接，这导致难以阅读的代码。通过纯字符串对域类型和属性的不安全引用是基于字符串的HQL构造的另一个问题。
随着域模型的不断变化，类型安全性在软件开发中带来了巨大的好处。域更改直接反映在查询中，而查询构造中的自动完成功能使查询构造更快，更安全。
用于Hibernate的HQL是Querydsl的第一个目标语言，如今querydsl支持JPA，JDO，JDBC，Lucene，Hibernate Search，MongoDB，Collections和RDFBean作为它的后端。

其官方网站在这里：http://querydsl.com/

推荐一个 Spring Boot 基础教程及实战示例：

https://github.com/javastacks/spring-boot-best-practice

Querydsl和spring有什么关系呢？几个Spring Data的模块通过QuerydslPredicateExecutor提供了与Querydsl的集成，如以下示例所示：

1. public interface QuerydslPredicateExecutor<T> {
2. //查找并返回与Predicate匹配的单个entity。
3.   Optional<T> findById(Predicate predicate);
4. //查找并返回与Predicate匹配的所有entity
5.   Iterable<T> findAll(Predicate predicate);
6. //返回与Predicate匹配的数量。
7.   long count(Predicate predicate);
8. //返回是否存在与Predicate匹配的entity。
9.   boolean exists(Predicate predicate);
11.   // … more functionality omitted.
12. }

复制代码

Predicate就是我们需要传入的一个查询的抽象。
在spring当中使用Querydsl，只需要在spring的repository接口继承QuerydslPredicateExecutor，如以下示例所示:

1. interface UserRepository extends CrudRepository<User, Long>, QuerydslPredicateExecutor<User> {
2. }

复制代码

在定义了上面的这个接口之后，我们就可以使用Querydsl Predicate编写type-safe的查询，如以下示例所示：

1. Predicate predicate = user.firstname.equals("dave")
2. .and(user.lastname.startsWith("mathews"));
4. userRepository.findAll(predicate);

复制代码

上面的代码构建出的predicate体现在sql语句里的话就是这样的: where firstname = 'dave' and lastname ='mathews%'。这就是所谓的类sql的查询，用起来非常的直观。
因此，我们可以将我们接收到的查询请求，转化为对应的predicte，且从技术上讲，只要predict支持的查询拼接我们都能支持，难点只在于如何解析查询请求，以及如何将他们转换为对应的predicate.
利用Spring Query DSL实现动态查询

下面是使用spring和Querydsl实现动态查询的一个例子.
现在假设我们有Model类如下:

1. public class Student {
3.     private String id;
5.     private String gender;
7.     private String firstName;
9.     private String lastName;
11.     private Date createdAt;
13.     private Boolean isGraduated;
15. }

复制代码

我们希望可以实现该类所有字段直接自由组合进行查询，且可以按照与和或的逻辑进行查询。且我们约定用冒号表示等于，例如:

1. firstname:li AND lastname:hua
3. firstname:li OR lastname:hua
5. firstname:li AND lastname:hua AND gender:male

复制代码

上面的查询都比较清晰，解析不会有太大难度，下面我们来看这样一个查询：

1. firstname:li OR lastname:hua AND gender:male

复制代码

这个查询的问题在于作为逻辑与的gender查询，到底是只和前面一个条件进行与操作，还是与前面两个条件一起进行一个与操作，显然与的条件往往是作为filter的功能出现的。
因此我们应当将其看作整个其他条件的与操作，因此我们需要先将前面的条在组合在一起，例如，我们可以使用括号表示这个逻辑，那么查询就会变成:

1. (firstname:li AND lastname:hua) AND gender:male

复制代码

这下逻辑就变得清晰了，难题就在于怎么解析了

1. public class QueryAnalysis{
2.     private static final String EMPTY_STRING = "";
4.     private static final String BLANK_STRING = " ";
6.     private static final String COLON = ":";
8.     private static final String BP_CATEGORY_CODE = "categoryCode";
10.     private static final String OPEN_PARENTTHESIS = "(";
12.     private static final String CLOSE_PARENTTHESIS = ")";
14.     private static final String QUERY_REGEX = "([\\w.]+?)(:|<|>|!:)([^ ]*)";
15.     //it has to lie between two blanks
16.     private static final String QUERY_LOGIC_AND = " AND ";
18.     private void generateQueryBuilderWithQueryString(PredicateBuilder builder, String q,
19.             List<String> queryStringList) {
20.         StringBuilder stringBuilder = new StringBuilder();
21.         String queryTerm = q;
22.         if (q == null) {
23.             return;
24.         }
26.         if (!q.contains(" AND ") && !q.startsWith("(") && !q.endsWith(")")) {
27.             queryTerm = stringBuilder.append("(").append(q).append(")").toString();
28.         }
30.         Map<String, Matcher> matcherMap = getMatcherWithQueryStr(queryTerm);
31.         Matcher matcherOr = matcherMap.get("matcherOr");
32.         Matcher matcherAnd = matcherMap.get("matcherAnd");
34.         while (matcherOr.find()) {
36.             builder.withOr(matcherOr.group(1), matcherOr.group(2), matcherOr.group(3));
37.         }
38.         while (matcherAnd.find()) {
40.             builder.withAnd(matcherAnd.group(1), matcherAnd.group(2), matcherAnd.group(3));
41.             isSearchParameterValid = true;
42.         }
43.    }
45.     private static Map<String, Matcher> getMatcherWithQueryStr(String q) {
46.         StringBuilder stringBuilder = new StringBuilder();
47.         Pattern pattern = Pattern.compile(QUERY_REGEX);
48.         // inside the subString is "or",outside them are "and"
49.         String[] queryStringArraySplitByAnd = q.split(QUERY_LOGIC_AND);
50.         String queryStringOr = EMPTY_STRING;
51.         String queryStringAnd = EMPTY_STRING;
52.         for (String string : queryStringArraySplitByAnd) {
53.             if (string.trim().startsWith(OPEN_PARENTTHESIS) && string.trim().endsWith(CLOSE_PARENTTHESIS)) {
54.                 //only support one OR sentence
55.                 queryStringOr = string.trim().substring(1,string.length()-1);
56.             } else {
57.                 queryStringAnd = stringBuilder.append(string).append(BLANK_STRING).toString();
58.             }
59.         }
61.         String queryStringAndTrim = queryStringAnd.trim();
62.         if(queryStringAndTrim.startsWith(OPEN_PARENTTHESIS) && queryStringAndTrim.endsWith(CLOSE_PARENTTHESIS)){
63.             queryStringAnd = queryStringAndTrim.substring(1,queryStringAndTrim.length()-1);
64.         }
66.         Matcher matcherOr = pattern.matcher(queryStringOr);
67.         Matcher matcherAnd = pattern.matcher(queryStringAnd);
69.         Map<String, Matcher> matcherMap = new ConcurrentHashMap<>();
70.         matcherMap.put("matcherOr", matcherOr);
71.         matcherMap.put("matcherAnd", matcherAnd);
72.         return matcherMap;
73.     }
74. }

复制代码

Predicate的逻辑如下：

1. import java.util.ArrayList;
2. import java.util.List;
4. import com.querydsl.core.types.dsl.BooleanExpression;
6. /**
7. * This class is mainly used to classify all the query parameters
8. */
9. public class PredicateBuilder {
11.     private static final String BLANK_STRING = " ";
13.     private static final String TILDE_STRING = "~~";
15.     private List<SearchCriteria> paramsOr;
17.     private List<SearchCriteria> paramsAnd;
19.     private BusinessPartnerMessageProvider messageProvider;
21.     public PredicateBuilder(BusinessPartnerMessageProvider messageProvider){
22.         paramsOr = new ArrayList<>();
23.         paramsAnd = new ArrayList<>();
24.     }
26.     public PredicateBuilder withOr(
27.             String key, String operation, Object value) {
28.         String keyAfterConverted = keyConverter(key);
29.         Object valueAfterConverted = value.toString().replaceAll(TILDE_STRING,BLANK_STRING).trim();
30.         paramsOr.add(new SearchCriteria(keyAfterConverted, operation, valueAfterConverted));
31.         return this;
32.     }
34.     public PredicateBuilder withAnd(
35.             String key, String operation, Object value) {
36.         String keyAfterConverted = keyConverter(key);
37.         Object valueAfterConverted = value.toString().replaceAll(TILDE_STRING,BLANK_STRING).trim();
38.         paramsAnd.add(new SearchCriteria(keyAfterConverted, operation, valueAfterConverted));
39.         return this;
40.     }
42.     protected String keyConverter(String key){
43.         return key;
44.     }
46.     public BooleanExpression buildOr(Class classType) {
48.         return handleBPBooleanExpressionOr(classType);
49.     }
51.     public BooleanExpression buildAnd(Class classType) {
53.         return handleBPBooleanExpressionAnd(classType);
54.     }
56.     private BooleanExpression handleBPBooleanExpressionOr(Class classType) {
58.         if (paramsOr.isEmpty()) {
59.             return null;
60.         }
61.         return buildBooleanExpressionOr(paramsOr, classType);
63.     }
65.     private BooleanExpression handleBPBooleanExpressionAnd(Class classType) {
66.         if (paramsAnd.isEmpty()) {
67.             return null;
68.         }
69.         return buildBooleanExpressionAnd(paramsAnd, classType);
71.     }
73.     private BooleanExpression buildBooleanExpressionOr(List<SearchCriteria> paramsOr, Class classType){
74.         List<BooleanExpression> predicates = new ArrayList<>();
75.         BooleanExpressionBuilder predicate;
76.         for (SearchCriteria param : paramsOr) {
78.             predicate = new BooleanExpressionBuilder(param, messageProvider);
80.             BooleanExpression exp = predicate.buildPredicate(classType);
82.             if (exp != null) {
83.                 predicates.add(exp);
84.             }
85.         }
86.         BooleanExpression result = null;
87.         if(!predicates.isEmpty()) {
88.             result = predicates.get(0);
89.             for (int i = 1; i < predicates.size(); i++) {
90.                 result = result.or(predicates.get(i));
91.             }
92.         }
93.         return result;
94.     }
96.     private BooleanExpression buildBooleanExpressionAnd(List<SearchCriteria> paramsAnd, Class classType){
97.         List<BooleanExpression> predicates = new ArrayList<>();
98.         BooleanExpressionBuilder predicate;
99.         for (SearchCriteria param : paramsAnd) {
101.             predicate = new BooleanExpressionBuilder(param, messageProvider);
103.             BooleanExpression exp = predicate.buildPredicate(classType);
105.             if (exp != null) {
106.                 predicates.add(exp);
107.             }
108.         }
109.         BooleanExpression result = null;
110.         if(!predicates.isEmpty()) {
111.             result = predicates.get(0);
112.             for (int i = 1; i < predicates.size(); i++) {
113.                 result = result.and(predicates.get(i));
114.             }
115.         }
116.         return result;
117.     }
119. }

复制代码

BooleanExpressionBuilder的逻辑如下：
[code]import java.text.ParseException;import java.text.SimpleDateFormat;import java.time.ZoneOffset;import java.util.Date;import java.util.TimeZone;import com.querydsl.core.types.dsl.BooleanExpression;import com.querydsl.core.types.dsl.BooleanPath;import com.querydsl.core.types.dsl.DateTimePath;import com.querydsl.core.types.dsl.NumberPath;import com.querydsl.core.types.dsl.PathBuilder;import com.querydsl.core.types.dsl.StringPath;public class BooleanExpressionBuilder {    private SearchCriteria criteria;    private BusinessPartnerMessageProvider messageProvider;    private static final String NO_SUCH_FILED_MESSAGE = "NO_SUCH_FIELD_FOR_QUERY_PARAMETER";    public BooleanExpressionBuilder(final SearchCriteria criteria ) {        this.criteria = new SearchCriteria(criteria.getKey(),criteria.getOperation(),criteria.getValue());    }    public BooleanExpression buildPredicate(Class classType) {        // the second param for PathBuilder constructor is the binding path.        PathBuilder entityPath = new PathBuilder(classType, classType.getSimpleName());        Boolean isValueMatchEndWith = criteria.getValue().toString().endsWith("*");        Boolean isValueMatchStartWith = criteria.getValue().toString().startsWith("*");        Boolean isOperationColon = ":".equalsIgnoreCase(criteria.getOperation());        int searchValueLength = criteria.getValue().toString().length();        StringPath stringPath = entityPath.getString(criteria.getKey());        DateTimePath timePath = entityPath.getDateTime(criteria.getKey(), Date.class);        NumberPath numberPath = entityPath.getNumber(criteria.getKey(), Integer.class);        if ((isOperationColon) && (!isValueMatchStartWith) && (!isValueMatchEndWith)) {            return getEqualBooleanExpression(classType, entityPath, stringPath, timePath, numberPath);        }        if (">".equalsIgnoreCase(criteria.getOperation())) {            return getGreaterThanBooleanExpression(classType, timePath, numberPath);        }        if ("