JPA 復雜查詢 - Querydsl

 添加依賴

    <!--query dsl -->  
            <dependency>  
                <groupId>com.querydsl</groupId>  
                <artifactId>querydsl-jpa</artifactId>  
            </dependency>  
            <dependency>  
                <groupId>com.querydsl</groupId>  
                <artifactId>querydsl-apt</artifactId>  
                <scope>provided</scope>  
            </dependency>  

    <plugin>  
                    <groupId>com.mysema.maven</groupId>  
                    <artifactId>apt-maven-plugin</artifactId>  
                    <version>1.1.3</version>  
                    <executions>  
                        <execution>  
                            <goals>  
                                <goal>process</goal>  
                            </goals>  
                            <configuration>  
                                <outputDirectory>target/generated-sources/java</outputDirectory>  
                                <processor>com.querydsl.apt.jpa.JPAAnnotationProcessor</processor>  
                            </configuration>  
                        </execution>  
                    </executions>  
                </plugin>  

 

運行 mvn compile， 將生成Query實體。

 

單表查詢

package com.chhliu.springboot.jpa.repository;

import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import javax.transaction.Transactional;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Component;

import com.chhliu.springboot.jpa.entity.QUser;
import com.chhliu.springboot.jpa.entity.User;
import com.querydsl.core.types.Predicate;
import com.querydsl.jpa.impl.JPAQueryFactory;

/**
 * 描述：QueryDSL JPA
 * @author chhliu
 */
@Component
@Transactional
public class UserRepositoryManagerDsl {
    @Autowired
    private UserRepositoryDls repository;
    
    @Autowired
    @PersistenceContext
    private EntityManager entityManager;

        private JPAQueryFactory queryFactory;
    
     @PostConstruct
     public void init() {
        queryFactory = new JPAQueryFactory(entityManager);
     }

       public User findUserByUserName(final String userName){
         /**
         * 該例是使用spring data QueryDSL實現
         */
        QUser quser = QUser.user;
        Predicate predicate = quser.name.eq(userName);
        return repository.findOne(predicate);
    }
    
    /**
     * attention:
     * Details：查詢user表中的所有記錄
     */
    public List<User> findAll(){
        QUser quser = QUser.user;
        return queryFactory.selectFrom(quser)
                    .fetch();
    }
    
    /**
     * Details：單條件查詢
     */
    public User findOneByUserName(final String userName){
        QUser quser = QUser.user;
        return queryFactory.selectFrom(quser)
            .where(quser.name.eq(userName))
            .fetchOne();
    }
    
    /**
     * Details：單表多條件查詢
     */
    public User findOneByUserNameAndAddress(final String userName, final String address){
        QUser quser = QUser.user;
        return queryFactory.select(quser)
            .from(quser) // 上面兩句代碼等價與selectFrom
            .where(quser.name.eq(userName).and(quser.address.eq(address)))// 這句代碼等同於where(quser.name.eq(userName), quser.address.eq(address))
            .fetchOne();
    }
    
    /**
     * Details：使用join查詢
     */
    public List<User> findUsersByJoin(){
        QUser quser = QUser.user;
        QUser userName = new QUser("name");
        return queryFactory.selectFrom(quser)
            .innerJoin(quser)
            .on(quser.id.intValue().eq(userName.id.intValue()))
            .fetch();
    }
    
    /**
     * Details：將查詢結果排序
     */
    public List<User> findUserAndOrder(){
        QUser quser = QUser.user;
        return queryFactory.selectFrom(quser)
            .orderBy(quser.id.desc())
            .fetch();
    }
    
    /**
     * Details：Group By使用
     */
    public List<String> findUserByGroup(){
        QUser quser = QUser.user;
        return queryFactory.select(quser.name)
                    .from(quser)
                    .groupBy(quser.name)
                    .fetch();
    }
    
    /**
     * Details：刪除用戶
     */
    public long deleteUser(String userName){
        QUser quser = QUser.user;
        return queryFactory.delete(quser).where(quser.name.eq(userName)).execute();
    }
    
    /**
     * Details：更新記錄
     */
    public long updateUser(final User u, final String userName){
        QUser quser = QUser.user;
        return queryFactory.update(quser).where(quser.name.eq(userName))
            .set(quser.name, u.getName())
            .set(quser.age, u.getAge())
            .set(quser.address, u.getAddress())
            .execute();
    }
    
    /**
     * Details：使用原生Query
     */
    public User findOneUserByOriginalSql(final String userName){
        QUser quser = QUser.user;
        Query query = queryFactory.selectFrom(quser)
                .where(quser.name.eq(userName)).createQuery();
        return (User) query.getSingleResult();
    }
    
    /**
     * Details：分頁查詢單表
     */
    public Page<User> findAllAndPager(final int offset, final int pageSize){
        Predicate predicate = QUser.user.id.lt(10);
        Sort sort = new Sort(new Sort.Order(Sort.Direction.DESC, "id"));
        PageRequest pr = new PageRequest(offset, pageSize, sort);
        return repository.findAll(predicate, pr);
    }
}

 

多表操作示例(一對一)

package com.chhliu.springboot.jpa.repository;

import java.util.ArrayList;
import java.util.List;

import javax.annotation.PostConstruct;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.chhliu.springboot.jpa.dto.PersonIDCardDto;
import com.chhliu.springboot.jpa.entity.QIDCard;
import com.chhliu.springboot.jpa.entity.QPerson;
import com.querydsl.core.QueryResults;
import com.querydsl.core.Tuple;
import com.querydsl.core.types.Predicate;
import com.querydsl.jpa.impl.JPAQuery;
import com.querydsl.jpa.impl.JPAQueryFactory;

@Component
public class PersonAndIDCardManager {
    @Autowired
    @PersistenceContext
    private EntityManager entityManager;
    
    private JPAQueryFactory queryFactory;
    
    @PostConstruct
    public void init() {
        queryFactory = new JPAQueryFactory(entityManager);
    }
    
    /**
     * Details：多表動態查詢
     */
    public List<Tuple> findAllPersonAndIdCard(){
        Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
        JPAQuery<Tuple> jpaQuery = queryFactory.select(QIDCard.iDCard.idNo, QPerson.person.address, QPerson.person.name)
                .from(QIDCard.iDCard, QPerson.person)
                .where(predicate);
        return jpaQuery.fetch();
    }
    
    /**
     * Details：將查詢結果以DTO的方式輸出
     */
    public List<PersonIDCardDto> findByDTO(){
        Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
        JPAQuery<Tuple> jpaQuery = queryFactory.select(QIDCard.iDCard.idNo, QPerson.person.address, QPerson.person.name)
                .from(QIDCard.iDCard, QPerson.person)
                .where(predicate);
        List<Tuple> tuples = jpaQuery.fetch();
        List<PersonIDCardDto> dtos = new ArrayList<PersonIDCardDto>();
        if(null != tuples && !tuples.isEmpty()){
            for(Tuple tuple:tuples){
                String address = tuple.get(QPerson.person.address);
                String name = tuple.get(QPerson.person.name);
                String idCard = tuple.get(QIDCard.iDCard.idNo);
                PersonIDCardDto dto = new PersonIDCardDto();
                dto.setAddress(address);
                dto.setIdNo(idCard);
                dto.setName(name);
                dtos.add(dto);
            }
        }
        return dtos;
    }
    
    /**
     * Details：多表動態查詢，並分頁
     */
    public QueryResults<Tuple> findByDtoAndPager(int offset, int pageSize){
        Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
        return queryFactory.select(QIDCard.iDCard.idNo, QPerson.person.address, QPerson.person.name)
                .from(QIDCard.iDCard, QPerson.person)
                .where(predicate)
                .offset(offset)
                .limit(pageSize)
                .fetchResults();
    }
}

上面將查詢結果以DTO的方式輸出的示例中，在查詢結束后，將查詢結果手動的轉換成了DTO對象，這種方式其實不太優雅，QueryDSL給我們提供了更好的方式，見下面的示例：

 

/**
     * Details：方式一：使用Bean投影
     */
    public List<PersonIDCardDto> findByDTOUseBean(){
        Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
        return queryFactory.select(
                Projections.bean(PersonIDCardDto.class, QIDCard.iDCard.idNo, QPerson.person.address, QPerson.person.name))
                .from(QIDCard.iDCard, QPerson.person)
                .where(predicate)
                .fetch();
    }
    
    /**
     * Details：方式二：使用fields來代替setter
     */
    public List<PersonIDCardDto> findByDTOUseFields(){
        Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
        return queryFactory.select(
                Projections.fields(PersonIDCardDto.class, QIDCard.iDCard.idNo, QPerson.person.address, QPerson.person.name))
                .from(QIDCard.iDCard, QPerson.person)
                .where(predicate)
                .fetch();
    }
    
    /**
     * Details：方式三：使用構造方法，注意構造方法中屬性的順序必須和構造器中的順序一致
     */
    public List<PersonIDCardDto> findByDTOUseConstructor(){
        Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
        return queryFactory.select(
                Projections.constructor(PersonIDCardDto.class, QPerson.person.name, QPerson.person.address, QIDCard.iDCard.idNo))
                .from(QIDCard.iDCard, QPerson.person)
                .where(predicate)
                .fetch();
    }

上面只是提供了幾種思路，當然，還可以使用@QueryProjection來實現，非常靈活。
一對多示例：

package com.chhliu.springboot.jpa.repository;

import java.util.List;

import javax.annotation.PostConstruct;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.chhliu.springboot.jpa.entity.QOrder;
import com.chhliu.springboot.jpa.entity.QOrderItem;
import com.querydsl.core.Tuple;
import com.querydsl.core.types.Predicate;
import com.querydsl.jpa.impl.JPAQuery;
import com.querydsl.jpa.impl.JPAQueryFactory;

@Component
public class OrderAndOrderItemManager {
    
    @Autowired
    @PersistenceContext
    private EntityManager entityManager;
    
    private JPAQueryFactory queryFactory;
    
    @PostConstruct
    public void init() {
        queryFactory = new JPAQueryFactory(entityManager);
    }
    
    /**
     * Details：一對多，條件查詢
     */
    public List<Tuple> findOrderAndOrderItemByOrderName(String orderName){
        //添加查詢條件
        Predicate predicate = QOrder.order.orderName.eq(orderName);
        JPAQuery<Tuple> jpaQuery = queryFactory.select(QOrder.order, QOrderItem.orderItem)
                                        .from(QOrder.order, QOrderItem.orderItem)
                                        .where(QOrderItem.orderItem.order.id.intValue().eq(QOrder.order.id.intValue()), predicate);
        
        //拿到結果
        return jpaQuery.fetch();
    }
    
    /**
     * Details：多表連接查詢
     */
    public List<Tuple> findAllByOrderName(String orderName){
        //添加查詢條件
        Predicate predicate = QOrder.order.orderName.eq(orderName);
        JPAQuery<Tuple> jpaQuery = queryFactory.select(QOrder.order, QOrderItem.orderItem)
                                        .from(QOrder.order, QOrderItem.orderItem)
                                        .rightJoin(QOrder.order)
                                        .on(QOrderItem.orderItem.order.id.intValue().eq(QOrder.order.id.intValue()));
        jpaQuery.where(predicate);
        //拿到結果
        return jpaQuery.fetch();
    }
}

 

 

鏈接

Querydsl Reference Guide

使用QueryDSL

復雜查詢的封裝

spring boot-jpa整合QueryDSL來簡化復雜操作

Spring Boot JPA - 使用 Querydsl 處理復雜的操作