程序博客网 > 华润网络 百度国际大厦

QueryDSL的DEMO示例

来源：互联网 发布：华润网络 百度国际大厦 编辑：程序博客网 时间：2024/05/16 01:53

原文:http://blog.csdn.net/liuchuanhong1/article/details/70244261?utm_source=gold_browser_extension(支持原创)

使用过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. <!--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文件中，加入编译插件

[html] view plain copy
  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实体类来说明，生成的查询类型如下：

[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<User> {  
  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<Integer> age = createNumber("age", Integer.class);  
  25.   
  26.     public final NumberPath<Integer> 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(Path<? extends 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/java</outputDirectory>  
目录下生成对应的查询类型。然后将生成的类都拷贝到项目中，即可。

本文涉及到的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<OrderItem> 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<User, Integer>, QueryDslPredicateExecutor<User>{// 继承<span id="result_box" lang="zh-CN"><span><span id="result_box" lang="zh-CN"><span></span></span></span></span>QueryDslPredicateExecutor<span id="result_box" lang="zh-CN"><span><span id="result_box" lang="zh-CN"></span></span></span>接口  
  9.   
  10. }  
QueryDslPredicateExecutor接口提供了如下方法：

[java] view plain copy
  1. public interface QueryDslPredicateExecutor<T> {  
  2.   
  3.     T findOne(Predicate predicate);  
  4.   
  5.     Iterable<T> findAll(Predicate predicate);  
  6.   
  7.     Iterable<T> findAll(Predicate predicate, Sort sort);  
  8.   
  9.     Iterable<T> findAll(Predicate predicate, OrderSpecifier<?>... orders);  
  10.   
  11.     Iterable<T> findAll(OrderSpecifier<?>... orders);  
  12.   
  13.     Page<T> 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<User> 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<User> 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<User> 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<String> 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<User> 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<Tuple> findAllPersonAndIdCard(){  
  39.         Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());  
  40.         JPAQuery<Tuple> 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<PersonIDCardDto> findByDTO(){  
  50.         Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());  
  51.         JPAQuery<Tuple> jpaQuery = queryFactory.select(QIDCard.iDCard.idNo, QPerson.person.address, QPerson.person.name)  
  52.                 .from(QIDCard.iDCard, QPerson.person)  
  53.                 .where(predicate);  
  54.         List<Tuple> tuples = jpaQuery.fetch();  
  55.         List<PersonIDCardDto> dtos = new ArrayList<PersonIDCardDto>();  
  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<Tuple> 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<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来实现，非常灵活。
一对多示例：

[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<Tuple> findOrderAndOrderItemByOrderName(String orderName){  
  37.         //添加查询条件  
  38.         Predicate predicate = QOrder.order.orderName.eq(orderName);  
  39.         JPAQuery<Tuple> 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<Tuple> findAllByOrderName(String orderName){  
  51.         //添加查询条件  
  52.         Predicate predicate = QOrder.order.orderName.eq(orderName);  
  53.         JPAQuery<Tuple> 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大大的简化了我们的操作

阅读全文
0 0
华润网络 百度国际大厦 华润网络 百度国际大厦
原创粉丝点击
热门IT博客
网络婚姻介绍所网络婚姻介绍所
自行车风火轮编程软件自行车风火轮编程软件
2015珠三角经济数据
新手程序员必看书籍
linux用户权限设置
java获取数据库表字段
程序员对联
鬼影实录 知乎
适合学生党的口红 知乎
linux创建软链接改名称
linux删除整个目录
redflag linux
单片机 型号
ubuntu安装wine1.7
手机免流软件
python replace 正则
炫浪网络社区在线阅读
神魔诛天神器进阶数据
淘宝3大组装电脑卖家
淘宝双十一大红包
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 华融湘江银行电话 华融湘江电话 华融董事长相当于什么级别 华融湘江银行app 华融资产一般员工收入 华融证券软件下载 华融资产管理公司招聘 华融证券股份有限公司 华融同花顺软件下载 中国华融资产 华融期货有限责任公司 重庆华融现代城 深圳华融资产管理有限公司 中国华融资产管理公司 华融证券怎么样 华融证券交易 华融投资有限公司 华融证券交易软件 华融湘江银行理财产品 华融证券同花顺下载 华融国际信托有限责任公司 华融证券客服电话 华融湘江银行理财 华融资产管理股份有限公司 华融湘江银行信用卡申请 华融大智慧手机版下载 华融大智慧下载 华融大智慧专业版 华融湘江银行招聘 华融湘江银行下载 华融湘江银行股份有限公司 华融证券大智慧手机版 华融同花顺下载安装 华融建筑工程集团有限公司 华融资产待遇 华融集团董事长 华融贵金属经营有限公司 华融信托待遇 赖小民 华融融德资产管理有限公司 华表

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里