spring boot-jpa整合QueryDSL来简化复杂操作

                                
                    版权声明:本文为博主原创文章,转载请注明出处。                    https://blog.csdn.net/liuchuanhong1/article/details/70244261                

                                            
                        


                

前言

使用过spring data jpa的同学,都很清楚,对于复杂的sql查询,处理起来还是比较复杂的,而本文中的QueryDSL就是用来简化JPA操作的。

Querydsl定义了一种常用的静态类型语法,用于在持久域模型数据之上进行查询。JDO和JPA是Querydsl的主要集成技术。本文旨在介绍如何使用Querydsl与JPA组合使用。JPA的Querydsl是JPQL和Criteria查询的替代方法。QueryDSL仅仅是一个通用的查询框架,专注于通过Java  API构建类型安全的SQL查询。

要想使用QueryDSL,需要做两个前提操作:

1、pom文件中,加入依赖


  
  
  1. <!--query dsl -->
  2.          <dependency>
  3.              <groupId>com.querydsl </groupId>
  4.              <artifactId>querydsl-jpa </artifactId>
  5.          </dependency>
  6.          <dependency>
  7.              <groupId>com.querydsl </groupId>
  8.              <artifactId>querydsl-apt </artifactId>
  9.              <scope>provided </scope>
  10.          </dependency>
2、pom文件中,加入编译插件


  
  
  1. <plugin>
  2.                  <groupId>com.mysema.maven </groupId>
  3.                  <artifactId>apt-maven-plugin </artifactId>
  4.                  <version>1.1.3 </version>
  5.                  <executions>
  6.                      <execution>
  7.                          <goals>
  8.                              <goal>process </goal>
  9.                          </goals>
  10.                          <configuration>
  11.                              <outputDirectory>target/generated-sources/java </outputDirectory>
  12.                              <processor>com.querydsl.apt.jpa.JPAAnnotationProcessor </processor>
  13.                          </configuration>
  14.                      </execution>
  15.                  </executions>
  16.              </plugin>
该插件会 查找使用javax.persistence.Entity注解的域类型,并为它们生成对应的查询类型。下面以User实体类来说明,生成的查询类型如下:


  
  
  1. package com.chhliu.springboot.jpa.entity;
  2. import static com.querydsl.core.types.PathMetadataFactory.*;
  3. import com.querydsl.core.types.dsl.*;
  4. import com.querydsl.core.types.PathMetadata;
  5. import javax.annotation.Generated;
  6. import com.querydsl.core.types.Path;
  7. /**
  8. * QUser is a Querydsl query type for User
  9. */
  10. @Generated( "com.querydsl.codegen.EntitySerializer")
  11. public class QUser extends EntityPathBase<User> {
  12.     private static final long serialVersionUID = 1153899872L;
  13.     public static final QUser user = new QUser( "user");
  14.     public final StringPath address = createString( "address");
  15.     public final NumberPath<Integer> age = createNumber( "age", Integer.class);
  16.     public final NumberPath<Integer> id = createNumber( "id", Integer.class);
  17.     public final StringPath name = createString( "name");
  18.     public QUser(String variable) {
  19.         super(User.class, forVariable(variable));
  20.    }
  21.     public QUser(Path<? extends User> path) {
  22.         super(path.getType(), path.getMetadata());
  23.    }
  24.     public QUser(PathMetadata metadata) {
  25.         super(User.class, metadata);
  26.    }
  27. }
我们建立好实体类之后,然后运行mvn clean complie命令,就会在
<outputDirectory>target/generated-sources/java</outputDirectory>
  
  
目录下生成对应的查询类型。然后将生成的类都拷贝到项目中,即可。

本文涉及到的Entity如下:


  
  
  1. package com.chhliu.springboot.jpa.entity;
  2. import java.io.Serializable;
  3. import javax.persistence.Entity;
  4. import javax.persistence.GeneratedValue;
  5. import javax.persistence.GenerationType;
  6. import javax.persistence.Id;
  7. import javax.persistence.Table;
  8. @Entity
  9. @Table(name= "t_user")
  10. public class User implements Serializable{
  11.     /**
  12.      *
  13.      */
  14.      private static final long serialVersionUID = 1L;
  15.     
  16.      @Id()
  17.     @GeneratedValue(strategy = GenerationType.AUTO)
  18.     private int id;
  19.     private String name;
  20.     private String address;
  21.     private int age;
  22.     …………省略getter,setter方法…………
  23.      /**
  24.      * attention:
  25.      * Details:方便查看测试结果
  26.      * @author chhliu
  27.      */
  28.      @Override
  29.      public String toString() {
  30.          return "User [id=" + id + ", name=" + name + ", address=" + address + ", age=" + age + "]";
  31.     }
  32. }
上面的这个实体类,主要用于单表操作。


  
  
  1. package com.chhliu.springboot.jpa.entity;
  2. import javax.persistence.CascadeType;
  3. import javax.persistence.Entity;
  4. import javax.persistence.GeneratedValue;
  5. import javax.persistence.Id;
  6. import javax.persistence.OneToOne;
  7. import javax.persistence.Table;
  8. /**
  9. * 描述:TODO
  10. * @author chhliu
  11. */
  12. @Entity
  13. @Table(name= "PERSON")
  14. public class Person {
  15.      @Id
  16.      @GeneratedValue
  17.      private Integer id;
  18.      private String name;
  19.      private String address;
  20.     
  21.      @OneToOne(mappedBy= "person", cascade={CascadeType.PERSIST, CascadeType.REMOVE, CascadeType.MERGE})
  22.      private IDCard idCard;
  23.    
  24.        …………省略getter,setter方法…………
  25.      @Override
  26.      public String toString() {
  27.          return "Person [id=" + id + ", name=" + name + ", address=" + address + ", idCard=" + idCard + "]";
  28.     }
  29. }

  
  
  1. package com.chhliu.springboot.jpa.entity;
  2. import javax.persistence.CascadeType;
  3. import javax.persistence.Entity;
  4. import javax.persistence.FetchType;
  5. import javax.persistence.GeneratedValue;
  6. import javax.persistence.Id;
  7. import javax.persistence.OneToOne;
  8. import javax.persistence.Table;
  9. /**
  10. * 描述:
  11. * @author chhliu
  12. */
  13. @Entity
  14. @Table(name= "IDCARD")
  15. public class IDCard {
  16.      @Id
  17.      @GeneratedValue
  18.      private Integer id;
  19.      private String idNo;
  20.      @OneToOne(cascade={CascadeType.MERGE, CascadeType.REMOVE, CascadeType.PERSIST}, fetch=FetchType.EAGER)
  21.      private Person person;
  22.     
  23.       …………省略getter,setter方法…………
  24.      @Override
  25.      public String toString() {
  26.          return "IDCard [id=" + id + ", idNo=" + idNo + ", person=" + person + "]";
  27.     }
  28. }
上面两个Entity主要用于一对一关系的示例操作


  
  
  1. package com.chhliu.springboot.jpa.entity;
  2. import java.util.List;
  3. import javax.persistence.CascadeType;
  4. import javax.persistence.Column;
  5. import javax.persistence.Entity;
  6. import javax.persistence.FetchType;
  7. import javax.persistence.GeneratedValue;
  8. import javax.persistence.Id;
  9. import javax.persistence.OneToMany;
  10. import javax.persistence.Table;
  11. /**
  12. * 描述:Order实体类
  13. * @author chhliu
  14. */
  15. @Entity
  16. @Table(name= "ORDER_C")
  17. public class Order {
  18.      @Id
  19.      @GeneratedValue
  20.      @Column(name= "ID")
  21.      private Integer id;
  22.     
  23.      @Column(length= 20, name= "ORDER_NAME")
  24.      private String orderName;
  25.     
  26.      @Column(name= "COUNT")
  27.      private Integer count;
  28.     
  29.      @OneToMany(mappedBy = "order",cascade={CascadeType.PERSIST,CascadeType.REMOVE},fetch = FetchType.EAGER)
  30.      private List<OrderItem> orderItems;
  31.        
  32.        …………省略getter,setter方法…………
  33. }

  
  
  1. package com.chhliu.springboot.jpa.entity;
  2. import javax.persistence.CascadeType;
  3. import javax.persistence.Column;
  4. import javax.persistence.Entity;
  5. import javax.persistence.FetchType;
  6. import javax.persistence.GeneratedValue;
  7. import javax.persistence.Id;
  8. import javax.persistence.JoinColumn;
  9. import javax.persistence.ManyToOne;
  10. import javax.persistence.Table;
  11. /**
  12. * 描述:OrderItem实体类
  13. * @author chhliu
  14. */
  15. @Entity
  16. @Table(name= "ORDER_ITEM")
  17. public class OrderItem {
  18.      @Id
  19.      @GeneratedValue
  20.      @Column(name= "ID", nullable= false)
  21.      private Integer id;
  22.     
  23.      @Column(name= "ITEM_NAME", length= 20)
  24.      private String itemName;
  25.     
  26.      @Column(name= "PRICE")
  27.      private Integer price;
  28.     
  29.      @ManyToOne(cascade={CascadeType.PERSIST,CascadeType.REMOVE, CascadeType.MERGE}, fetch=FetchType.EAGER)
  30.     @JoinColumn(name = "ORDER_ID")
  31.      private Order order;
  32.        …………省略getter,setter方法…………
  33. }
上面两个Entity用于展示一对多关系的示例操作。

首先,我们来看单表操作

1、使用spring data jpa

要想使用spring data jpa提供的QueryDSL功能,很简单,直接继承接口即可。Spring Data JPA中提供了QueryDslPredicateExecutor接口,用于支持QueryDSL的查询操作接口,如下:


  
  
  1. package com.chhliu.springboot.jpa.repository;
  2. import org.springframework.data.jpa.repository.JpaRepository;
  3. import org.springframework.data.querydsl.QueryDslPredicateExecutor;
  4. import com.chhliu.springboot.jpa.entity.User;
  5. public interface UserRepositoryDls extends JpaRepository<User, Integer>, QueryDslPredicateExecutor<User>{ // 继承 QueryDslPredicateExecutor 接口
  6. }
QueryDslPredicateExecutor接口提供了如下方法:


  
  
  1. public interface QueryDslPredicateExecutor<T> {
  2.      T findOne(Predicate predicate);
  3.      Iterable<T> findAll(Predicate predicate);
  4.      Iterable<T> findAll(Predicate predicate, Sort sort);
  5.      Iterable<T> findAll(Predicate predicate, OrderSpecifier<?>... orders);
  6.      Iterable<T> findAll(OrderSpecifier<?>... orders);
  7.      Page<T> findAll(Predicate predicate, Pageable pageable);
  8.      long count(Predicate predicate);
  9.      boolean exists(Predicate predicate);
  10. }
以上方法的使用和spring data jpa中的其他接口使用方法类似,详情请参考:

http://blog.csdn.net/liuchuanhong1/article/details/52042477

测试如下:


  
  
  1. public User findUserByUserName(final String userName){
  2.          /**
  3.          * 该例是使用spring data QueryDSL实现
  4.          */
  5.         QUser quser = QUser.user;
  6.         Predicate predicate = quser.name.eq(userName); // 根据用户名,查询user表
  7.          return repository.findOne(predicate);
  8.     }
对应的sql如下:

select user0_.id as id1_5_, user0_.address as address2_5_, user0_.age as age3_5_, user0_.name as name4_5_ from t_user user0_ where  user0_.name=?
  
  
单表操作示例代码如下:


  
  
  1. package com.chhliu.springboot.jpa.repository;
  2. import java.util.List;
  3. import javax.persistence.EntityManager;
  4. import javax.persistence.PersistenceContext;
  5. import javax.persistence.Query;
  6. import javax.transaction.Transactional;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.data.domain.Page;
  9. import org.springframework.data.domain.PageRequest;
  10. import org.springframework.data.domain.Sort;
  11. import org.springframework.stereotype.Component;
  12. import com.chhliu.springboot.jpa.entity.QUser;
  13. import com.chhliu.springboot.jpa.entity.User;
  14. import com.querydsl.core.types.Predicate;
  15. import com.querydsl.jpa.impl.JPAQueryFactory;
  16. /**
  17. * 描述:QueryDSL JPA
  18. * @author chhliu
  19. */
  20. @Component
  21. @Transactional
  22. public class UserRepositoryManagerDsl {
  23.      @Autowired
  24.      private UserRepositoryDls repository;
  25.     
  26.      @Autowired
  27.      @PersistenceContext
  28.      private EntityManager entityManager;
  29.         private JPAQueryFactory queryFactory;
  30.     
  31.      @PostConstruct
  32.       public void init() {
  33.         queryFactory = new JPAQueryFactory(entityManager);
  34.      }
  35.         public User findUserByUserName(final String userName){
  36.           /**
  37.          * 该例是使用spring data QueryDSL实现
  38.          */
  39.         QUser quser = QUser.user;
  40.         Predicate predicate = quser.name.eq(userName);
  41.          return repository.findOne(predicate);
  42.     }
  43.     
  44.      /**
  45.      * attention:
  46.      * Details:查询user表中的所有记录
  47.      */
  48.      public List<User> findAll(){
  49.         QUser quser = QUser.user;
  50.          return queryFactory.selectFrom(quser)
  51.                     .fetch();
  52.     }
  53.     
  54.      /**
  55.      * Details:单条件查询
  56.      */
  57.      public User findOneByUserName(final String userName){
  58.         QUser quser = QUser.user;
  59.          return queryFactory.selectFrom(quser)
  60.             .where(quser.name.eq(userName))
  61.             .fetchOne();
  62.     }
  63.     
  64.      /**
  65.      * Details:单表多条件查询
  66.      */
  67.      public User findOneByUserNameAndAddress(final String userName, final String address){
  68.         QUser quser = QUser.user;
  69.          return queryFactory.select(quser)
  70.             .from(quser) // 上面两句代码等价与selectFrom
  71.             .where(quser.name.eq(userName).and(quser.address.eq(address))) // 这句代码等同于where(quser.name.eq(userName), quser.address.eq(address))
  72.             .fetchOne();
  73.     }
  74.     
  75.      /**
  76.      * Details:使用join查询
  77.      */
  78.      public List<User> findUsersByJoin(){
  79.         QUser quser = QUser.user;
  80.         QUser userName = new QUser( "name");
  81.          return queryFactory.selectFrom(quser)
  82.             .innerJoin(quser)
  83.             .on(quser.id.intValue().eq(userName.id.intValue()))
  84.             .fetch();
  85.     }
  86.     
  87.      /**
  88.      * Details:将查询结果排序
  89.      */
  90.      public List<User> findUserAndOrder(){
  91.         QUser quser = QUser.user;
  92.          return queryFactory.selectFrom(quser)
  93.             .orderBy(quser.id.desc())
  94.             .fetch();
  95.     }
  96.     
  97.      /**
  98.      * Details:Group By使用
  99.      */
  100.      public List<String> findUserByGroup(){
  101.         QUser quser = QUser.user;
  102.          return queryFactory.select(quser.name)
  103.                     .from(quser)
  104.                     .groupBy(quser.name)
  105.                     .fetch();
  106.     }
  107.     
  108.      /**
  109.      * Details:删除用户
  110.      */
  111.      public long deleteUser(String userName){
  112.         QUser quser = QUser.user;
  113.          return queryFactory.delete(quser).where(quser.name.eq(userName)).execute();
  114.     }
  115.     
  116.      /**
  117.      * Details:更新记录
  118.      */
  119.      public long updateUser(final User u, final String userName){
  120.         QUser quser = QUser.user;
  121.          return queryFactory.update(quser).where(quser.name.eq(userName))
  122.             .set(quser.name, u.getName())
  123.             .set(quser.age, u.getAge())
  124.             .set(quser.address, u.getAddress())
  125.             .execute();
  126.     }
  127.     
  128.      /**
  129.      * Details:使用原生Query
  130.      */
  131.      public User findOneUserByOriginalSql(final String userName){
  132.         QUser quser = QUser.user;
  133.         Query query = queryFactory.selectFrom(quser)
  134.                 .where(quser.name.eq(userName)).createQuery();
  135.          return (User) query.getSingleResult();
  136.     }
  137.     
  138.      /**
  139.      * Details:分页查询单表
  140.      */
  141.      public Page<User> findAllAndPager(final int offset, final int pageSize){
  142.         Predicate predicate = QUser.user.id.lt( 10);
  143.         Sort sort = new Sort( new Sort.Order(Sort.Direction.DESC, "id"));
  144.         PageRequest pr = new PageRequest(offset, pageSize, sort);
  145.          return repository.findAll(predicate, pr);
  146.     }
  147. }
多表操作示例(一对一)如下:


  
  
  1. package com.chhliu.springboot.jpa.repository;
  2. import java.util.ArrayList;
  3. import java.util.List;
  4. import javax.annotation.PostConstruct;
  5. import javax.persistence.EntityManager;
  6. import javax.persistence.PersistenceContext;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.stereotype.Component;
  9. import com.chhliu.springboot.jpa.dto.PersonIDCardDto;
  10. import com.chhliu.springboot.jpa.entity.QIDCard;
  11. import com.chhliu.springboot.jpa.entity.QPerson;
  12. import com.querydsl.core.QueryResults;
  13. import com.querydsl.core.Tuple;
  14. import com.querydsl.core.types.Predicate;
  15. import com.querydsl.jpa.impl.JPAQuery;
  16. import com.querydsl.jpa.impl.JPAQueryFactory;
  17. @Component
  18. public class PersonAndIDCardManager {
  19.      @Autowired
  20.      @PersistenceContext
  21.      private EntityManager entityManager;
  22.     
  23.      private JPAQueryFactory queryFactory;
  24.     
  25.      @PostConstruct
  26.     public void init() {
  27.         queryFactory = new JPAQueryFactory(entityManager);
  28.     }
  29.     
  30.      /**
  31.      * Details:多表动态查询
  32.      */
  33.      public List<Tuple> findAllPersonAndIdCard(){
  34.         Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
  35.         JPAQuery<Tuple> jpaQuery = queryFactory.select(QIDCard.iDCard.idNo, QPerson.person.address, QPerson.person.name)
  36.                 .from(QIDCard.iDCard, QPerson.person)
  37.                 .where(predicate);
  38.          return jpaQuery.fetch();
  39.     }
  40.     
  41.      /**
  42.      * Details:将查询结果以DTO的方式输出
  43.      */
  44.      public List<PersonIDCardDto> findByDTO(){
  45.         Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
  46.         JPAQuery<Tuple> jpaQuery = queryFactory.select(QIDCard.iDCard.idNo, QPerson.person.address, QPerson.person.name)
  47.                 .from(QIDCard.iDCard, QPerson.person)
  48.                 .where(predicate);
  49.         List<Tuple> tuples = jpaQuery.fetch();
  50.         List<PersonIDCardDto> dtos = new ArrayList<PersonIDCardDto>();
  51.          if( null != tuples && !tuples.isEmpty()){
  52.              for(Tuple tuple:tuples){
  53.                 String address = tuple.get(QPerson.person.address);
  54.                 String name = tuple.get(QPerson.person.name);
  55.                 String idCard = tuple.get(QIDCard.iDCard.idNo);
  56.                 PersonIDCardDto dto = new PersonIDCardDto();
  57.                 dto.setAddress(address);
  58.                 dto.setIdNo(idCard);
  59.                 dto.setName(name);
  60.                 dtos.add(dto);
  61.             }
  62.         }
  63.          return dtos;
  64.     }
  65.     
  66.      /**
  67.      * Details:多表动态查询,并分页
  68.      */
  69.      public QueryResults<Tuple> findByDtoAndPager(int offset, int pageSize){
  70.         Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
  71.          return queryFactory.select(QIDCard.iDCard.idNo, QPerson.person.address, QPerson.person.name)
  72.                 .from(QIDCard.iDCard, QPerson.person)
  73.                 .where(predicate)
  74.                 .offset(offset)
  75.                 .limit(pageSize)
  76.                 .fetchResults();
  77.     }
  78. }

上面将查询结果以DTO的方式输出的示例中,在查询结束后,将查询结果手动的转换成了DTO对象,这种方式其实不太优雅,QueryDSL给我们提供了更好的方式,见下面的示例:


  
  
  1. /**
  2.      * Details:方式一:使用Bean投影
  3.      */
  4.      public List<PersonIDCardDto> findByDTOUseBean(){
  5.         Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
  6.          return queryFactory.select(
  7.                 Projections.bean(PersonIDCardDto.class, QIDCard.iDCard.idNo, QPerson.person.address, QPerson.person.name))
  8.                 .from(QIDCard.iDCard, QPerson.person)
  9.                 .where(predicate)
  10.                 .fetch();
  11.     }
  12.     
  13.      /**
  14.      * Details:方式二:使用fields来代替setter
  15.      */
  16.      public List<PersonIDCardDto> findByDTOUseFields(){
  17.         Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
  18.          return queryFactory.select(
  19.                 Projections.fields(PersonIDCardDto.class, QIDCard.iDCard.idNo, QPerson.person.address, QPerson.person.name))
  20.                 .from(QIDCard.iDCard, QPerson.person)
  21.                 .where(predicate)
  22.                 .fetch();
  23.     }
  24.     
  25.      /**
  26.      * Details:方式三:使用构造方法,注意构造方法中属性的顺序必须和构造器中的顺序一致
  27.      */
  28.      public List<PersonIDCardDto> findByDTOUseConstructor(){
  29.         Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
  30.          return queryFactory.select(
  31.                 Projections.constructor(PersonIDCardDto.class, QPerson.person.name, QPerson.person.address, QIDCard.iDCard.idNo))
  32.                 .from(QIDCard.iDCard, QPerson.person)
  33.                 .where(predicate)
  34.                 .fetch();
  35.     }
上面只是提供了几种思路,当然,还可以使用@QueryProjection来实现,非常灵活。
一对多示例:

  
  
  1. package com.chhliu.springboot.jpa.repository;
  2. import java.util.List;
  3. import javax.annotation.PostConstruct;
  4. import javax.persistence.EntityManager;
  5. import javax.persistence.PersistenceContext;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.stereotype.Component;
  8. import com.chhliu.springboot.jpa.entity.QOrder;
  9. import com.chhliu.springboot.jpa.entity.QOrderItem;
  10. import com.querydsl.core.Tuple;
  11. import com.querydsl.core.types.Predicate;
  12. import com.querydsl.jpa.impl.JPAQuery;
  13. import com.querydsl.jpa.impl.JPAQueryFactory;
  14. @Component
  15. public class OrderAndOrderItemManager {
  16.     
  17.      @Autowired
  18.      @PersistenceContext
  19.      private EntityManager entityManager;
  20.     
  21.      private JPAQueryFactory queryFactory;
  22.     
  23.      @PostConstruct
  24.     public void init() {
  25.         queryFactory = new JPAQueryFactory(entityManager);
  26.     }
  27.     
  28.      /**
  29.      * Details:一对多,条件查询
  30.      */
  31.      public List<Tuple> findOrderAndOrderItemByOrderName(String orderName){
  32.          //添加查询条件
  33.         Predicate predicate = QOrder.order.orderName.eq(orderName);
  34.         JPAQuery<Tuple> jpaQuery = queryFactory.select(QOrder.order, QOrderItem.orderItem)
  35.                                         .from(QOrder.order, QOrderItem.orderItem)
  36.                                         .where(QOrderItem.orderItem.order.id.intValue().eq(QOrder.order.id.intValue()), predicate);
  37.         
  38.         //拿到结果
  39.         return jpaQuery.fetch();
  40.     }
  41.     
  42.      /**
  43.      * Details:多表连接查询
  44.      */
  45.      public List<Tuple> findAllByOrderName(String orderName){
  46.          //添加查询条件
  47.         Predicate predicate = QOrder.order.orderName.eq(orderName);
  48.         JPAQuery<Tuple> jpaQuery = queryFactory.select(QOrder.order, QOrderItem.orderItem)
  49.                                         .from(QOrder.order, QOrderItem.orderItem)
  50.                                         .rightJoin(QOrder.order)
  51.                                         .on(QOrderItem.orderItem.order.id.intValue().eq(QOrder.order.id.intValue()));
  52.         jpaQuery.where(predicate);
  53.         //拿到结果
  54.         return jpaQuery.fetch();
  55.     }
  56. }

从上面的示例中,我们可以看出,QueryDSL大大的简化了我们的操作

           


               
  • 1
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
评论 3
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值