封装JpaSpecificationExecutor简化多条件查询

悠悠 2021-10-18 07:56 1021阅读 0赞

一、JpaSpecificationExecutor原生查询及其概述

1.1 概述

Spring Data JPA为我们提供了一系列的接口比如：Repository、CrudRepository、PagingAndSortingRepository、JpaRepository、JPASpecificationExecutor等。我们只需要继承这些接口就可以很方便的对数据库进行操作。但是当我们运用JPASpecificationExecutor接口进行一些比较复杂的条件查询的时候，就会显得有点麻烦，下面先来个查询的demo体验一下：

1.2 原生条件查询

  1. 我们假设usersRepositorySpecification已经继承了相关接口，以name和age为条件进行查询：
  2. /**    
  3.  * JpaSpecificationExecutor   多条件测试
  4.  */
  5. @Test
  6. public void testJpaSpecificationExecutor2() {
  8.     /**
  9.      * Specification<Users>:用于封装查询条件
  10.      */
  11.     Specification<Users> spec = new Specification<Users>() {
  13.         //Predicate:封装了 单个的查询条件
  14.         /**
  15.          * Root<Users> root:查询对象的属性的封装。
  16.          * CriteriaQuery<?> query：封装了我们要执行的查询中的各个部分的信息，select  from order by
  17.          * CriteriaBuilder cb:查询条件的构造器。定义不同的查询条件
  18.          */
  19.         @Override
  20.         public Predicate toPredicate(Root<Users> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
  21.             List<Predicate> list = new ArrayList<>();
  22.             list.add(cb.equal(root.get("name"),"张三三"));
  23.             list.add(cb.equal(root.get("age"),20));
  24.             Predicate[] arr = new Predicate[list.size()];
  25.             return cb.and(list.toArray(arr));
  26.         }
  27.     };
  28.     List<Users> list = this.usersRepositorySpecification.findAll(spec);
  29.     for (Users users : list) {
  30.         System.out.println(users);
  31.     }
  32. }

二、对上述查询进行封装简化

  1. QueryWraper类，包装用于构建JPA动态查询时所需的对象

    1. public class QueryWraper<T> {
    3.      public QueryWraper(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb, List<Predicate> predicates) {
    4.          this.root = root;
    5.          this.query = query;
    6.          this.cb = cb;
    7.          this.predicates = predicates;
    8.      }
    10.      /**
    11.       * JPA Root
    12.       */
    13.      private Root<T> root;
    14.      /**
    15.       * JPA CriteriaBuilder
    16.       */
    17.      private CriteriaBuilder cb;
    18.      /**
    19.       * JPA Predicate 集合
    20.       */
    21.      private List<Predicate> predicates;
    22.      /**
    23.       * JPA 查询对象
    24.       */
    25.      private CriteriaQuery<?> query;
    27.      /**
    28.       * <pre>
    29.       *        增加查询条件
    30.       * <pre>
    31.       * @param predicate
    32.       * @author jojo 2014-8-12 下午3:12:36
    33.       */
    34.      public void addPredicate(Predicate predicate) {
    35.          this.predicates.add(predicate);
    36.      }
    38.      public Root<T> getRoot() {
    39.          return root;
    40.      }
    42.      public void setRoot(Root<T> root) {
    43.          this.root = root;
    44.      }
    46.      public CriteriaBuilder getCb() {
    47.          return cb;
    48.      }
    50.      public void setCb(CriteriaBuilder cb) {
    51.          this.cb = cb;
    52.      }
    54.      public List<Predicate> getPredicates() {
    55.          return predicates;
    56.      }
    58.      public void setPredicates(List<Predicate> predicates) {
    59.          this.predicates = predicates;
    60.      }
    62.      public CriteriaQuery<?> getQuery() {
    63.          return query;
    64.      }
    66.      public void setQuery(CriteriaQuery<?> query) {
    67.          this.query = query;
    68.      }
    70.  }

  2. AbstractConditionBuilder抽象类，提供比如:in条件、between条件、like条件等一系列复杂查询条件

    1. public abstract class AbstractConditionBuilder<T> {
    3.  /**
    4.   * 添加in条件
    5.   * @param queryWraper
    6.   * @param column  哪个属性
    7.   * @param values  在(in)哪些值里面
    8.   */
    9.  protected void addInConditionToColumn(QueryWraper<T> queryWraper, String column, Object values) {
    10.      if (needAddCondition(values)) {
    11.          Path<?> fieldPath = getPath(queryWraper.getRoot(), column);  //得到最终的路径
    12.          if(values.getClass().isArray()) {
    13.              queryWraper.addPredicate(fieldPath.in((Object[])values));  //in :创建Predicate以测试表达式是否为参数列表的成员,返回Predicate 
    14.          }else if(values instanceof Collection) {
    15.              queryWraper.addPredicate(fieldPath.in((Collection<?>)values));
    16.          }
    17.      }
    18.  }
    20.  /**
    21.   * 添加between条件查询
    22.   * @param queryWraper
    23.   * @param experssion
    24.   * @param minValue  范围下限
    25.   * @param maxValue  范围上限
    26.   */
    27.  @SuppressWarnings({ "rawtypes", "unchecked" })
    28.  protected void addBetweenConditionToColumn(QueryWraper<T> queryWraper, String column, Comparable minValue, Comparable maxValue) {
    29.      if (minValue != null || maxValue != null) {
    30.          Path<? extends Comparable> fieldPath = getPath(queryWraper.getRoot(), column);
    31.          if(minValue != null && maxValue != null){
    32.              queryWraper.addPredicate(queryWraper.getCb().between(fieldPath, minValue, processMaxValueOnDate(maxValue)));
    33.          }else if(minValue != null){
    34.              queryWraper.addPredicate(queryWraper.getCb().greaterThanOrEqualTo(fieldPath, minValue));
    35.          }else if(maxValue != null){
    36.              queryWraper.addPredicate(queryWraper.getCb().lessThanOrEqualTo(fieldPath, processMaxValueOnDate(maxValue)));
    37.          }
    38.      }
    39.  }
    41.  /**
    42.   * 当范围查询的条件是小于，并且值的类型是Date时，将传入的Date值变为当天的夜里12点的值。
    43.   * @param maxValue
    44.   * @return
    45.   * @author zhailiang
    46.   * @since 2016年12月14日
    47.   */
    48.  @SuppressWarnings("rawtypes")
    49.  private Comparable processMaxValueOnDate(Comparable maxValue) {
    50.      if(maxValue instanceof Date) {
    51.          maxValue = new DateTime(maxValue).withTimeAtStartOfDay().plusDays(1).plusSeconds(-1).toDate();
    52.      }
    53.      return maxValue;
    54.  }
    56.  /**
    57.   * 添加大于条件查询
    58.   * @param queryWraper
    59.   * @param experssion
    60.   * @param minValue
    61.   */
    62.  @SuppressWarnings({ "rawtypes", "unchecked" })
    63.  protected void addGreaterThanConditionToColumn(QueryWraper<T> queryWraper, String column,  Comparable minValue) {
    64.      if (minValue != null) {
    65.          Path<? extends Comparable> fieldPath = getPath(queryWraper.getRoot(), column);
    66.          queryWraper.addPredicate(queryWraper.getCb().greaterThan(fieldPath, minValue));
    67.      }
    68.  }
    70.  /**
    71.   * 添加大于等于条件查询
    72.   * @param queryWraper
    73.   * @param experssion
    74.   * @param minValue
    75.   */
    76.  @SuppressWarnings({ "rawtypes", "unchecked" })
    77.  protected void addGreaterThanOrEqualConditionToColumn(QueryWraper<T> queryWraper, String column,  Comparable minValue) {
    78.      if (minValue != null) {
    79.          Path<? extends Comparable> fieldPath = getPath(queryWraper.getRoot(), column);
    80.          queryWraper.addPredicate(queryWraper.getCb().greaterThanOrEqualTo(fieldPath, minValue));
    81.      }
    82.  }
    84.  /**
    85.   * 添加小于条件查询
    86.   * @param queryWraper
    87.   * @param experssion
    88.   * @param maxValue
    89.   */
    90.  @SuppressWarnings({ "unchecked", "rawtypes" })
    91.  protected void addLessThanConditionToColumn(QueryWraper<T> queryWraper, String column,  Comparable maxValue) {
    92.      if (maxValue != null) {
    93.          Path<? extends Comparable> fieldPath = getPath(queryWraper.getRoot(), column);
    94.          queryWraper.addPredicate(queryWraper.getCb().lessThan(fieldPath, processMaxValueOnDate(maxValue)));
    95.      }
    96.  }
    98.  /**
    99.   * 添加小于等于条件查询
    100.   * @param queryWraper
    101.   * @param experssion
    102.   * @param maxValue
    103.   */
    104.  @SuppressWarnings({ "unchecked", "rawtypes" })
    105.  protected void addLessThanOrEqualConditionToColumn(QueryWraper<T> queryWraper, String column,  Comparable maxValue) {
    106.      if (maxValue != null) {
    107.          Path<? extends Comparable> fieldPath = getPath(queryWraper.getRoot(), column);
    108.          queryWraper.addPredicate(queryWraper.getCb().lessThanOrEqualTo(fieldPath, processMaxValueOnDate(maxValue)));
    109.      }
    110.  }
    112.  /**
    113.   * <pre>
    114.   * 添加like条件
    115.   * <pre>
    116.   * @param queryWraper
    117.   * @param column 指出要向哪个字段添加包含(like)条件
    118.   * @param value  like什么
    119.   * @author jojo 2014-8-12 下午3:13:44
    120.   */
    121.  protected void addLikeConditionToColumn(QueryWraper<T> queryWraper, String column, String value) {
    122.      if (StringUtils.isNotBlank(value)) {
    123.          queryWraper.addPredicate(createLikeCondition(queryWraper, column, value));
    124.      }
    125.  }
    127.  /**
    128.   * @param queryWraper
    129.   * @param column  查哪个字段
    130.   * @param value  字段like什么
    131.   * @return
    132.   * @author zhailiang
    133.   * @since 2016年12月13日
    134.   */
    135.  @SuppressWarnings("unchecked")
    136.  protected Predicate createLikeCondition(QueryWraper<T> queryWraper, String column, String value) {
    137.      Path<String> fieldPath = getPath(queryWraper.getRoot(), column);
    138.      Predicate condition = queryWraper.getCb().like(fieldPath, "%" + value + "%");
    139.      return condition;
    140.  }
    142.  /**
    143.   * <pre>
    144.   * 添加like条件
    145.   * <pre>
    146.   * @param queryWraper
    147.   * @param column
    148.   * @param value
    149.   * @author jojo 2014-8-12 下午3:13:44
    150.   */
    151.  @SuppressWarnings("unchecked")
    152.  protected void addStartsWidthConditionToColumn(QueryWraper<T> queryWraper, String column, String value) {
    153.      if (StringUtils.isNotBlank(value)) {
    154.          Path<String> fieldPath = getPath(queryWraper.getRoot(), column);
    155.          queryWraper.addPredicate(queryWraper.getCb().like(fieldPath,  value + "%"));
    156.      }
    157.  }
  1.      /**
  2.       *  添加等于条件
  3.       * @param queryWraper
  4.       * @param column 指出要向哪个字段添加条件
  5.       * @param value 指定字段的值
  6.       */
  7.      protected void addEqualsConditionToColumn(QueryWraper<T> queryWraper, String column, Object value) {
  8.          if(needAddCondition(value)) {
  9.              Path<?> fieldPath = getPath(queryWraper.getRoot(), column);
  10.              queryWraper.addPredicate(queryWraper.getCb().equal(fieldPath, value));
  11.          }
  12.      }
  14.      /**
  15.       *  添加不等于条件
  16.       * @param queryWraper
  17.       * @param column 指出要向哪个字段添加条件
  18.       * @param value 指定字段的值
  19.       */
  20.      protected void addNotEqualsConditionToColumn(QueryWraper<T> queryWraper, String column, Object value) {
  21.          if(needAddCondition(value)) {
  22.              Path<?> fieldPath = getPath(queryWraper.getRoot(), column);
  23.              queryWraper.addPredicate(queryWraper.getCb().notEqual(fieldPath, value));
  24.          }
  25.      }
  27.      /**
  28.       * <pre>
  29.       *
  30.       * <pre>  得到属性的路径
  31.       * @param root
  32.       * @param property
  33.       * @return
  34.       * @author jojo 2014-8-12 下午3:06:58
  35.       */
  36.      @SuppressWarnings("rawtypes")
  37.      protected Path getPath(Root root, String property){
  38.          //Path代表一个简单或者复杂的属性路径
  39.          String[] names = StringUtils.split(property, ".");  //比如路径是admin.role.resource，需要为resource创建path 
  40.          Path path = root.get(names[0]);
  41.          for (int i = 1; i < names.length; i++) {
  42.              path = path.get(names[i]);   //创建与引用属性相对应的路径
  43.          }
  44.          return path;
  45.      }
  47.      /**
  48.       * <pre>
  49.       * 判断是否需要添加where条件
  50.       * <pre>
  51.       * @param value
  52.       * @return
  53.       * @author jojo 2014-8-12 下午3:07:00
  54.       */
  55.      @SuppressWarnings("rawtypes")
  56.      protected boolean needAddCondition(Object value) {
  57.          boolean addCondition = false;
  58.          if (value != null) {
  59.              if(value instanceof String) {
  60.                  if(StringUtils.isNotBlank(value.toString())) {
  61.                      addCondition = true;
  62.                  }
  63.              }else if(value.getClass().isArray()) {
  64.                  if(ArrayUtils.isNotEmpty((Object[]) value)) {
  65.                      addCondition = true;
  66.                  }
  67.              }else if(value instanceof Collection) {
  68.                  if(CollectionUtils.isNotEmpty((Collection) value)) {
  69.                      addCondition = true;
  70.                  }
  71.              }else {
  72.                  addCondition = true;
  73.              }
  74.          }
  75.          return addCondition;
  76.      }
  78.      }

  1. AbstractEventConditionBuilder抽象类，继承AbstractConditionBuilder类，根据传上来的条件对象，对AbstractConditionBuilder查询方法进行进一步封装。

    1. public abstract class AbstractEventConditionBuilder<T, C> extends AbstractConditionBuilder<T> {
    3.      /**
    4.       * 查询条件
    5.       */
    6.      private C condition;
    8.      /**
    9.       * @param condition 查询条件
    10.       */
    11.      public AbstractEventConditionBuilder(C condition){
    12.          this.condition = condition;
    13.      }
    15.      /**
    16.       * 向查询中添加包含(like)条件
    17.       * 
    18.       * @param queryWraper
    19.       * @param field 指出查询条件的值从condition对象的哪个字段里取，并且指出要向哪个字段添加包含(like)条件。(同一个字段名称)
    20.       * @throws NoSuchMethodException 
    21.       * @throws InvocationTargetException 
    22.       * @throws IllegalAccessException 
    23.       */
    24.      protected void addLikeCondition(QueryWraper<T> queryWraper, String field){
    25.          addLikeCondition(queryWraper, field, field);
    26.      }
    28.      /**
    29.       * 向查询中添加包含(like)条件
    30.       * 
    31.       * @param queryWraper
    32.       * @param field 指出查询条件的值从condition对象的哪个字段里取
    33.       * @param column 指出要向哪个字段添加包含(like)条件
    34.       * @throws NoSuchMethodException 
    35.       * @throws InvocationTargetException 
    36.       * @throws IllegalAccessException 
    37.       */
    38.      protected void addLikeCondition(QueryWraper<T> queryWraper, String field, String column){
    39.          addLikeConditionToColumn(queryWraper, column, (String) 
    40.                  getValue(getCondition(), field));   //得到condition里面 field字段的值
    41.      }
  1.          /**
  2.           * 向查询中添加包含(like)条件,%放在值后面
  3.           * 
  4.           * @param queryWraper
  5.           * @param field 指出查询条件的值从condition对象的哪个字段里取，并且指出要向哪个字段添加包含(like)条件。(同一个字段名称)
  6.           * @throws NoSuchMethodException 
  7.           * @throws InvocationTargetException 
  8.           * @throws IllegalAccessException 
  9.           */
  10.          protected void addStartsWidthCondition(QueryWraper<T> queryWraper, String field){
  11.              addStartsWidthCondition(queryWraper, field, field);
  12.          }
  14.          /**
  15.           * 向查询中添加包含(like)条件,%放在值后面
  16.           * 
  17.           * @param queryWraper
  18.           * @param field 指出查询条件的值从condition对象的哪个字段里取
  19.           * @param column 指出要向哪个字段添加包含(like)条件
  20.           * @throws NoSuchMethodException 
  21.           * @throws InvocationTargetException 
  22.           * @throws IllegalAccessException 
  23.           */
  24.          protected void addStartsWidthCondition(QueryWraper<T> queryWraper, String field, String column){
  25.              addStartsWidthConditionToColumn(queryWraper, column, (String) 
  26.                      getValue(getCondition(), field));
  27.          }
  29.          /**
  30.           * 向查询中添加等于(=)条件
  31.           * 
  32.           * @param queryWraper
  33.           * @param field 指出查询条件的值从condition对象的哪个字段里取，并且指出要向哪个字段添加条件。(同一个字段名称)
  34.           * @throws NoSuchMethodException 
  35.           * @throws InvocationTargetException 
  36.           * @throws IllegalAccessException 
  37.           */
  38.          protected void addEqualsCondition(QueryWraper<T> queryWraper, String field){
  39.              addEqualsCondition(queryWraper, field, field);
  40.          }
  42.          /**
  43.           * 向查询中添加等于(=)条件
  44.           * 
  45.           * @param queryWraper
  46.           * @param field 指出查询条件的值从condition对象的哪个字段里取
  47.           * @param column 指出要向哪个字段添加条件
  48.           * @throws NoSuchMethodException 
  49.           * @throws InvocationTargetException 
  50.           * @throws IllegalAccessException 
  51.           */
  52.          protected void addEqualsCondition(QueryWraper<T> queryWraper, String field, String column){
  53.              addEqualsConditionToColumn(queryWraper, column, 
  54.                      getValue(getCondition(), field));
  55.          }
  57.          /**
  58.           * 向查询中添加不等于(!=)条件
  59.           * 
  60.           * @param queryWraper
  61.           * @param field 指出查询条件的值从condition对象的哪个字段里取，并且指出要向哪个字段添加条件。(同一个字段名称)
  62.           * @throws NoSuchMethodException 
  63.           * @throws InvocationTargetException 
  64.           * @throws IllegalAccessException 
  65.           */
  66.          protected void addNotEqualsCondition(QueryWraper<T> queryWraper, String field){
  67.              addNotEqualsCondition(queryWraper, field, field);
  68.          }
  70.          /**
  71.           * 向查询中添加等于(=)条件
  72.           * 
  73.           * @param queryWraper
  74.           * @param field 指出查询条件的值从condition对象的哪个字段里取
  75.           * @param column 指出要向哪个字段添加条件
  76.           * @throws NoSuchMethodException 
  77.           * @throws InvocationTargetException 
  78.           * @throws IllegalAccessException 
  79.           */
  80.          protected void addNotEqualsCondition(QueryWraper<T> queryWraper, String field, String column){
  81.              addNotEqualsConditionToColumn(queryWraper, column, getValue(getCondition(), field));
  82.          }
  84.          /**
  85.           * <pre>
  86.           * 向查询中添加in条件
  87.           * <pre>
  88.           * @param queryWraper
  89.           * @param field
  90.           * @author jojo 2014-8-12 下午3:26:50
  91.           */
  92.          protected void addInCondition(QueryWraper<T> queryWraper, String field) {
  93.              addInCondition(queryWraper, field, field);
  94.          }
  95.          /**
  96.           * <pre>
  97.           * 向查询中添加in条件
  98.           * <pre>
  99.           * @param queryWraper
  100.           * @param field
  101.           * @param column
  102.           * @author jojo 2014-8-12 下午3:27:46
  103.           */
  104.          protected void addInCondition(QueryWraper<T> queryWraper, String field, String column) {
  105.              addInConditionToColumn(queryWraper, column, 
  106.                      getValue(getCondition(), field));
  107.          }
  109.          /**
  110.           * <pre>
  111.           * 向查询中添加between条件
  112.           * <pre>
  113.           * @param queryWraper
  114.           * @param field
  115.           * @author jojo 2014-8-12 下午3:26:50
  116.           */
  117.          protected void addBetweenCondition(QueryWraper<T> queryWraper, String field) {
  118.              addBetweenCondition(queryWraper, field, field+"To", field);
  119.          }
  120.          /**
  121.           * <pre>
  122.           * 向查询中添加between条件
  123.           * <pre>
  124.           * @param queryWraper
  125.           * @param field
  126.           * @param column
  127.           * @author jojo 2014-8-12 下午3:27:46
  128.           */
  129.          @SuppressWarnings("rawtypes")
  130.          protected void addBetweenCondition(QueryWraper<T> queryWraper, String startField, String endField, String column) {
  131.              addBetweenConditionToColumn(queryWraper, column, 
  132.                      (Comparable)getValue(getCondition(), startField), 
  133.                      (Comparable)getValue(getCondition(), endField));
  134.          }
  136.          /**
  137.           * <pre>
  138.           * 向查询中添加大于条件
  139.           * <pre>
  140.           * @param queryWraper
  141.           * @param field
  142.           * @author jojo 2014-8-12 下午3:26:50
  143.           */
  144.          protected void addGreaterThanCondition(QueryWraper<T> queryWraper, String field) {
  145.              addGreaterThanCondition(queryWraper, field, field);
  146.          }
  147.          /**
  148.           * <pre>
  149.           * 向查询中添加大于条件
  150.           * <pre>
  151.           * @param queryWraper
  152.           * @param field
  153.           * @param column
  154.           * @author jojo 2014-8-12 下午3:27:46
  155.           */
  156.          @SuppressWarnings("rawtypes")
  157.          protected void addGreaterThanCondition(QueryWraper<T> queryWraper, String field, String column) {
  158.              addGreaterThanConditionToColumn(queryWraper, column, 
  159.                      (Comparable)getValue(getCondition(), field));
  160.          }
  162.          /**
  163.           * <pre>
  164.           * 向查询中添加大于等于条件
  165.           * <pre>
  166.           * @param queryWraper
  167.           * @param field
  168.           * @author jojo 2014-8-12 下午3:26:50
  169.           */
  170.          protected void addGreaterThanOrEqualCondition(QueryWraper<T> queryWraper, String field) {
  171.              addGreaterThanOrEqualCondition(queryWraper, field, field);
  172.          }
  174.          /**
  175.           * <pre>
  176.           * 向查询中添加大于等于条件
  177.           * <pre>
  178.           * @param queryWraper
  179.           * @param field
  180.           * @param column
  181.           * @author jojo 2014-8-12 下午3:27:46
  182.           */
  183.          @SuppressWarnings("rawtypes")
  184.          protected void addGreaterThanOrEqualCondition(QueryWraper<T> queryWraper, String field, String column) {
  185.              addGreaterThanOrEqualConditionToColumn(queryWraper, column, 
  186.                      (Comparable)getValue(getCondition(), field));
  187.          }
  189.          /**
  190.           * <pre>
  191.           * 向查询中添加小于条件
  192.           * <pre>
  193.           * @param queryWraper
  194.           * @param field
  195.           * @author jojo 2014-8-12 下午3:26:50
  196.           */
  197.          protected void addLessThanCondition(QueryWraper<T> queryWraper, String field) {
  198.              addLessThanCondition(queryWraper, field, field);
  199.          }
  200.          /**
  201.           * <pre>
  202.           * 向查询中添加小于条件
  203.           * <pre>
  204.           * @param queryWraper
  205.           * @param field
  206.           * @param column
  207.           * @author jojo 2014-8-12 下午3:27:46
  208.           */
  209.          @SuppressWarnings("rawtypes")
  210.          protected void addLessThanCondition(QueryWraper<T> queryWraper, String field, String column) {
  211.              addLessThanConditionToColumn(queryWraper, column, 
  212.                      (Comparable)getValue(getCondition(), field));
  213.          }
  215.          /**
  216.           * <pre>
  217.           * 向查询中添加小于等于条件
  218.           * <pre>
  219.           * @param queryWraper
  220.           * @param field
  221.           * @author jojo 2014-8-12 下午3:26:50
  222.           */
  223.          protected void addLessThanOrEqualCondition(QueryWraper<T> queryWraper, String field) {
  224.              addLessThanOrEqualCondition(queryWraper, field, field);
  225.          }
  227.          /**
  228.           * <pre>
  229.           * 向查询中添加小于等于条件
  230.           * <pre>
  231.           * @param queryWraper
  232.           * @param field
  233.           * @param column
  234.           * @author jojo 2014-8-12 下午3:27:46
  235.           */
  236.          @SuppressWarnings("rawtypes")
  237.          protected void addLessThanOrEqualCondition(QueryWraper<T> queryWraper, String field, String column) {
  238.              addLessThanOrEqualConditionToColumn(queryWraper, column, 
  239.                      (Comparable)getValue(getCondition(), field));
  240.          }
  242.          /**
  243.           * 
  244.           * @param condition 从这个对象里面查
  245.           * @param field  要查询的属性
  246.           * @return
  247.           */
  248.          private Object getValue(C condition, String field) {
  249.              try {
  250.                  //得到condition对象中field属性的值
  251.                  //使用示例：getProperty(book,"authors[0].favorites(food)")
  252.                  return PropertyUtils.getProperty(condition, field);
  253.              } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
  254.                  e.printStackTrace();
  255.              }
  256.              return null;
  257.          }
  259.          /**
  260.           * @return the condition
  261.           */
  262.          public C getCondition() {
  263.              return condition;
  264.          }
  266.          /**
  267.           * @param condition the condition to set
  268.           */
  269.          public void setCondition(C condition) {
  270.              this.condition = condition;
  271.          }
  273.          }

  1. MyImoocSpecification类，继承AbstractEventConditionBuilder类，并实现Specification接口，重写toPredicate()方法，使用时继承该类即可

    1. public abstract class MySpecification<T, C> extends AbstractEventConditionBuilder<T, C> implements Specification<T> {
    2.          //AbstractEventConditionBuilder里面封装了添加各种查询条件的方法
    3.      /**
    4.       * @param condition
    5.       */
    6.      public MySpecification(C condition) {
    7.          super(condition);
    8.      }
    10.      /**
    11.       * 
    12.       * 构建查询条件，子类必须实现addCondition方法来编写查询的逻辑。
    13.       * 
    14.       * 子类可以通过addFetch方法控制查询的关联和抓取行为。
    15.       * 
    16.       */
    17.      @Override
    18.      public Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
    20.          if (Long.class != query.getResultType()) {
    21.              addFetch(root);
    22.          }
    24.          List<Predicate> predicates = new ArrayList<Predicate>();
    26.          QueryWraper<T> queryWraper = new QueryWraper<T>(root, query, cb, predicates);
    28.          addCondition(queryWraper);
    30.          Predicate permissionCondition = getPermissionCondition(queryWraper);
    31.          if (permissionCondition != null) {
    32.              queryWraper.addPredicate(permissionCondition);
    33.          }
    35.          return cb.and(predicates.toArray(new Predicate[predicates.size()]));
    36.      }
    38.      /**
    39.       * 添加权限条件，如果要查询的domain实现了{@link ManagedByOrgan}接口，那么传入的Condition对象也应该实现
    40.       * {@link ManagedByOrgan}接口，
    41.       * 程序会尝试从Condition对象获取organFullId,然后作为like查询条件添加到查询中。
    42.       * 查出所有以传入的organFullId开头的domain.
    43.       * 
    44.       * @param queryWraper
    45.       * @return
    46.       */
    47.      protected Predicate getPermissionCondition(QueryWraper<T> queryWraper) {
    48.          return null;
    49.      }
    51.      /**
    52.       * <pre>
    53.       * 子类可以通过覆盖此方法实现关联抓取，避免n+1查询
    54.       * 
    55.       * <pre>
    56.       * 
    57.       * @param root
    58.       * @author jojo 2014-7-22 上午9:49:26
    59.       */
    60.      protected void addFetch(Root<T> root) {
    62.      }
    64.      protected abstract void addCondition(QueryWraper<T> queryWraper);  //钩子方法，子类实现 自动调用
    66.  }

三、使用示例

3.1 创建条件封装对象

  1. public class AdminCondition {
  3.     private String username;
  5.     /**
  6.      * @return the username
  7.      */
  8.     public String getUsername() {
  9.         return username;
  10.     }
  12.     /**
  13.      * @param username the username to set
  14.      */
  15.     public void setUsername(String username) {
  16.         this.username = username;
  17.     }
  18. }

3.2 继承MySpecification类

  1. 传入条件封装对象，以及结果实体类型
  2. public class AdminSpec extends ImoocSpecification<Admin, AdminCondition> {
  4.     public AdminSpec(AdminCondition condition) {
  5.         super(condition);
  6.     }
  8.     @Override
  9.     protected void addCondition(QueryWraper<Admin> queryWraper) {
  10.         addLikeCondition(queryWraper, "username");
  11.     }
  13. }

3.3 调用

  1. public class AdminServiceImpl implements AdminService {
  3. @Autowired
  4. private AdminRepository adminRepository;
  6.     public Page<AdminInfo> query(AdminCondition condition, Pageable pageable) {
  7.     Page<Admin> admins = adminRepository.findAll(new AdminSpec(condition), pageable);
  8.     return QueryResultConverter.convert(admins, AdminInfo.class, pageable);
  9.     }
  10. }

发表评论

表情：
评论列表 （有 0 条评论，1021人围观）

还没有评论，来说两句吧...

相关阅读

    相关 多条件查询

    > 多条件查询就是将sql语句进行拼接，在这里需要用到一个where 1=1 表示条件永远成立，这样就少了对where和and的处理 上代码，一目了然 String

    一时失言乱红尘一时失言乱红尘/ 0 赞/ 487 阅读