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

前言

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

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

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

1、pom文件中,加入依赖

[html]  view plain  copy
  1.   
  2.         <dependency>  
  3.             <groupId>com.querydslgroupId>  
  4.             <artifactId>querydsl-jpaartifactId>  
  5.         dependency>  
  6.         <dependency>  
  7.             <groupId>com.querydslgroupId>  
  8.             <artifactId>querydsl-aptartifactId>  
  9.             <scope>providedscope>  
  10.         dependency>  
2、pom文件中,加入编译插件

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

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

本文涉及到的Entity如下:

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

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

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

首先,我们来看单表操作

1、使用spring data jpa

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

[java]  view plain  copy
  1. package com.chhliu.springboot.jpa.repository;  
  2.   
  3. import org.springframework.data.jpa.repository.JpaRepository;  
  4. import org.springframework.data.querydsl.QueryDslPredicateExecutor;  
  5.   
  6. import com.chhliu.springboot.jpa.entity.User;  
  7.   
  8. public interface UserRepositoryDls extends JpaRepository, QueryDslPredicateExecutor{// 继承QueryDslPredicateExecutor接口  
  9.   
  10. }  
QueryDslPredicateExecutor接口提供了如下方法:

[java]  view plain  copy
  1. public interface QueryDslPredicateExecutor {  
  2.   
  3.     T findOne(Predicate predicate);  
  4.   
  5.     Iterable findAll(Predicate predicate);  
  6.   
  7.     Iterable findAll(Predicate predicate, Sort sort);  
  8.   
  9.     Iterable findAll(Predicate predicate, OrderSpecifier... orders);  
  10.   
  11.     Iterable findAll(OrderSpecifier... orders);  
  12.   
  13.     Page findAll(Predicate predicate, Pageable pageable);  
  14.   
  15.     long count(Predicate predicate);  
  16.   
  17.     boolean exists(Predicate predicate);  
  18. }  
以上方法的使用和spring data jpa中的其他接口使用方法类似,详情请参考:

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

测试如下:

[java]  view plain  copy
  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如下:

[java]  view plain  copy
  1. 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=?  
单表操作示例代码如下:

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

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

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

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

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

你可能感兴趣的:(Spring,data,jpa)