Querydsl-JPA 框架（推薦）

官網(wǎng)：傳送門

參考：

• JPA整合Querydsl入門篇
• SpringBoot環(huán)境下QueryDSL-JPA的入門及進(jìn)階

概述及依賴、插件、生成查詢實體

1.Querydsl支持代碼自動完成，因為是純Java API編寫查詢，因此主流Java IDE對起的代碼自動完成功能支持幾乎可以發(fā)揮到極致（因為是純Java代碼，所以支持很好）

2.Querydsl幾乎可以避免所有的SQL語法錯誤（當(dāng)然用錯了Querydsl API除外，因為不寫SQL了，因此想用錯也難）

3.Querydsl采用Domain類型的對象和屬性來構(gòu)建查詢，因此查詢絕對是類型安全的，不會因為條件類型而出現(xiàn)問題

4.Querydsl采用純Java API的作為SQL構(gòu)建的實現(xiàn)可以讓代碼重構(gòu)發(fā)揮到另一個高度

5.Querydsl的領(lǐng)一個優(yōu)勢就是可以更輕松的進(jìn)行增量查詢的定義

使用

在Spring環(huán)境下，可以通過兩種風(fēng)格來使用QueryDSL。

一種是使用JPAQueryFactory的原生QueryDSL風(fēng)格， 另一種是基于Spring Data提供的QueryDslPredicateExecutor<T>的Spring-data風(fēng)格。

使用QueryDslPredicateExecutor<T>可以簡化一些代碼，使得查詢更加優(yōu)雅。 而JPAQueryFactory的優(yōu)勢則體現(xiàn)在其功能的強大，支持更復(fù)雜的查詢業(yè)務(wù)。甚至可以用來進(jìn)行更新和刪除操作。

依賴

 	<dependencies><!-- QueryDSL框架依賴 --><dependency><groupId>com.querydsl</groupId><artifactId>querydsl-apt</artifactId></dependency><dependency><groupId>com.querydsl</groupId><artifactId>querydsl-jpa</artifactId></dependency></dependencies>

添加maven插件（pom.xml）

添加這個插件是為了讓程序自動生成query type(查詢實體，命名方式為：“Q”+對應(yīng)實體名)。

上文引入的依賴中querydsl-apt即是為此插件服務(wù)的。

注：在使用過程中，如果遇到query type無法自動生成的情況，用maven更新一下項目即可解決(右鍵項目->Maven->Update Project)。

<project><build><plugins><plugin> <!--因為QueryDsl是類型安全的，所以還需要加上Maven APT plugin，使用 APT 自動生成Q類:--><groupId>com.mysema.maven</groupId><artifactId>apt-maven-plugin</artifactId><version>1.1.3</version><executions><execution><phase>generate-sources</phase><goals><goal>process</goal></goals><configuration><outputDirectory>target/generated-sources/java</outputDirectory><processor>com.querydsl.apt.jpa.JPAAnnotationProcessor</processor></configuration></execution></executions></plugin></plugins></build>
</project>

補充：

QueryDSL默認(rèn)使用HQL發(fā)出查詢語句。但也支持原生SQL查詢。

若要使用原生SQL查詢，你需要使用下面這個maven插件生成相應(yīng)的query type。

<project><build><plugins><plugin><groupId>com.querydsl</groupId><artifactId>querydsl-maven-plugin</artifactId><version>${querydsl.version}</version><executions><execution><goals><goal>export</goal></goals></execution></executions><configuration><jdbcDriver>org.apache.derby.jdbc.EmbeddedDriver</jdbcDriver><jdbcUrl>jdbc:derby:target/demoDB;create=true</jdbcUrl><packageName>com.mycompany.mydomain</packageName><targetFolder>${project.basedir}/target/generated-sources/java</targetFolder></configuration><dependencies><dependency><groupId>org.apache.derby</groupId><artifactId>derby</artifactId><version>${derby.version}</version></dependency></dependencies></plugin></plugins></build>
</project>

生成查詢實體

idea 工具 為maven project 自動添加了對應(yīng)的功能。添加好依賴和 plugin 插件后，就可以生成查詢實體了。

打開右側(cè)的 Maven Projects，如下圖所示：

雙擊 clean 清除已編譯的 target

雙擊 compile 命令執(zhí)行，執(zhí)行完成后會在 pom.xml 配置文件內(nèi)配置生成目錄內(nèi)生成對應(yīng)實體的 QueryDSL 查詢實體。

生成的查詢實體如下圖所示：

JPAQueryFactory 風(fēng)格

QueryDSL 在支持JPA的同時，也提供了對 Hibernate 的支持。可以通過 HibernateQueryFactory 來使用。

裝配 與 注入

SpringBoot注解方式裝配

/*** 方式一。使用Spring的@Configuration注解注冊實例進(jìn)行容器托管*/
@Configuration
public class QueryDslConfig {@Beanpublic JPAQueryFactory jpaQueryFactory(EntityManager em){return new JPAQueryFactory(em);}
}/*** 方式二。在Dao類中初始化*/// 實體管理@Autowiredprivate EntityManager entityManager;// 查詢工廠private JPAQueryFactory queryFactory;// 初始化JPA查詢工廠@PostConstruct		// Constructor(構(gòu)造方法) -> @Autowired(依賴注入) -> @PostConstruct(注釋的方法)public void init(){queryFactory = new JPAQueryFactory(entityManager);}

注入

    @Autowiredprivate JPAQueryFactory queryFactory;

更新、刪除

JPAQueryFactory 更新

在Querydsl JPA中，更新語句是簡單的 update-set/where-execute 形式。

execute()執(zhí)行后返回的是被更新的實體的數(shù)量。

注意：使用QueryDsl更新實體時需要添加事務(wù)

@Test
@Transactional
public void testUpdate() {QStudent qStudent = QStudent.student;Long result = queryFactory.update(qStudent).set(qStudent.name, "haha")		// 可以用if條件判斷更新值來確定字段是否.set().setnull(qStudent.age)			// 設(shè)置null值.where(qStudent.id.eq(111L)).execute();assertThat(result, equalTo(1L));
}

JPAQueryFactory 刪除

刪除語句是簡單的 delete-where-execute 形式。

注意：使用QueryDsl刪除實體時需要添加事務(wù)

@Test
@Transactional
public void testDelete() {QStudent qStudent = QStudent.student;//刪除指定條件的記錄Long result = queryFactory.delete(qStudent).where(qStudent.id.eq(111L)).execute();assertThat(result, equalTo(1L));//刪除所有記錄。即不加where條件Long totalResult = queryFactory.delete(qStudent).execute();System.out.println(totalResult);
}

查詢

表達(dá)式工具類

Expressions 表達(dá)式工具類

// when-then 條件表達(dá)式函數(shù)。when傳參必須為名為eqTrue或eqFalse的Predicate
T cases().when(Predicate).then(T a).otherwise(T b)DateExpression<Date> currentDate()			// 返回當(dāng)前日歷（年-月-日）的 DateExpression
TimeExpression<Time> currentTime()			// 返回當(dāng)前時刻（時:分:秒）的 TimeExpression
DateTimeExpression<Date> currentTimestamp()	// 返回當(dāng)前時間（年-月-日 時:分:秒）的 DateTimeExpression// exprs 均為名為eqTrue的Predicate ，則返回名為eqTrue的Predicate，否則返回eqFalse的Predicate
BooleanExpression allOf(BooleanExpression... exprs)
// exprs 至少存在一個名為eqTrue的Predicate，則返回名為eqTrue的Predicate，否則返回eqFalse的Predicate
BooleanExpression anyOf(BooleanExpression... exprs)// 轉(zhuǎn)類型為 BooleanExpression。特別注意：asBoolean(Boolean).isTrue() 才是可用Predicate
BooleanExpression asBoolean(Boolean)			// asBoolean(true)  <==等價==>  booleanPath("true")
NumberExpression asNumber(T)
StringrExpression asString(T)
DateExpression asDate(T)
TimeExpression asTime(T)
DateTimeExpression asDateTime(T)// 自定義語法
StringTemplate stringTemplate(String template, Object... args)
NumberTemplate<T> numberTemplate(Class<? extends T> cl, String template, Object... args)
BooleanTemplate booleanTemplate(String template, ImmutableList<?> args)

MathExpressions 數(shù)學(xué)表達(dá)式工具類

NumberExpression<A> round(Expression<A> num)			// 四舍五入取整
NumberExpression<A> round(Expression<A> num, int s)		// 四舍五入保留 s 位小數(shù)NumberExpression<Double> asin(Expression<A> num)		// 返回num的反正弦值。-1 <= num <= 1，否則返回null
NumberExpression<Double> acos(Expression<A> num)		// 返回num的反余弦值。-1 <= num <= 1，否則返回null// 慎用！qdsl-jpa底層是調(diào)用random()函數(shù)，MySQL沒有該函數(shù)，只有rand()函數(shù)，會報錯，解決方案為使用QDSL-SQL查詢
NumberExpression<Double> random()			// 返回０到１內(nèi)的隨機值
NumberExpression<Double> random(int seed)	// 返回一個指定的０到１內(nèi)的隨機值

表達(dá)式方法

注意：在select()中查詢出的結(jié)果使用表達(dá)式方法處理過后，若要封裝到實體類中，則都需要使用 .as(alias) 起別名指定封裝到實體類中的哪個字段。

SimpleExpression 簡單表達(dá)式 extends DslExpression extends Expression

// 給查詢字段取別名
T as(alias)BooleanExpression eq(T right)	// 等于 equal
BooleanExpression eqAll(T... right)
BooleanExpression eqAny(T... right)
BooleanExpression ne(T right)	// 不等于	not equal 
BooleanExpression neAll(T... right)
BooleanExpression neAny(T... right)BooleanExpression in(T... right)
BooleanExpression notIn(T... right)BooleanExpression isNotNull()
BooleanExpression isNull()// 相當(dāng)于java中的switch語句。兩種寫法
T when(A).then(B).otherwise(C)// 該字段的查詢結(jié)果等于參數(shù)則返回null，不等于則返回查詢結(jié)果。Field == A ? null : Field
SimpleExpression<T> nullif(A)// 符合過濾條件的的總條數(shù)。		select count(table.id) from table
NumberExpression<Long> count()

ComparableExpressionBase extends SimpleExpression

// 設(shè)置默認(rèn)值。返回 Field, A, B ... 順序中第一個非null的值，若都為null則返回null
// 注意：使用該方法兜底Oracle數(shù)據(jù)庫的null為空字符串時會失效，因為Oracle會把空字符串當(dāng)作null
T coalesce(A, B ...)

NumberExpression 數(shù)值表達(dá)式 extends ComparableExpressionBase

NumberExpression<T> add(A)			// 加    
NumberExpression<T> subtract(A)		// 減  
NumberExpression<T> multiply(A)		// 乘  
NumberExpression<T> divide(A)		// 除  
NumberExpression<T> mod(A)			// 返回余數(shù)NumberExpression<T> floor()		// 向下取整
NumberExpression<T> ceil()		// 向上取整
NumberExpression<T> round()		// 四舍五入取整NumberExpression<T> max()			// 返回指定數(shù)值列的最大值
NumberExpression<T> min()			// 返回指定數(shù)值列的最小值
NumberExpression<T> sqrt()			// 返回指定數(shù)值列的平方根NumberExpression<T> sum()			// 返回指定數(shù)值列（或分組相同數(shù)值列）的總數(shù)
NumberExpression<T> avg()			// 返回指定數(shù)值列（或分組相同數(shù)值列）的平均數(shù)NumberExpression<T> abs()			// 返回指定數(shù)值列的絕對值
NumberExpression<T> negate()		// 返回指定數(shù)值列的相反數(shù)StringExpression stringValue()	// 返回字符串表達(dá)式// 數(shù)據(jù)類型轉(zhuǎn)換為數(shù)字類型。type為數(shù)字基本類型的包裝類.class。實體類接收字段需與type的類型一致。
NumberExpression<T> castToNum(Class<A> type)

ComparableExpression extends ComparableExpressionBase

BooleanExpression lt(T right)	// 小于 less than
BooleanExpression ltAll(T... right)
BooleanExpression ltAny(T... right)
BooleanExpression gt(T right) 	// 大于 greater than
BooleanExpression gtAll(T... right)
BooleanExpression gtAny(T... right)BooleanExpression loe(T right)	// 小于等于 less than or equal
BooleanExpression loeAll(T... right)
BooleanExpression loeAny(T... right)
BooleanExpression goe(T right)	// 大于等于 greater than or equal
BooleanExpression goeAll(T... right)
BooleanExpression goeAny(T... right)BooleanExpression between(from, to)		// from和to之間  [from, to]
BooleanExpression notBetween(from, to)

BooleanExpression 布爾表達(dá)式 extends LiteralExpression (extends ComparableExpression) implements Predicate

BooleanExpression isTrue()		// 計算結(jié)果若為true，則返回名為eqTrue的Predicate，否則返回名為eqFalse的Predicate
BooleanExpression isFalse()		// 計算結(jié)果若為false，則返回名為eqTrue的Predicate，否則返回名為eqFalse的Predicate
BooleanExpression not()			// 返回相反的結(jié)果BooleanExpression eq(Boolean right)BooleanExpression and(Predicate right)
BooleanExpression andAnyOf(Predicate... predicates)
BooleanExpression or(Predicate right)
BooleanExpression orAllOf(Predicate... predicates)

StringExpressions 字符串表達(dá)式 extends LiteralExpression extends ComparableExpression

StringExpression contains(String str)	// 包含參數(shù)字符串BooleanExpression isEmpty()		// 判斷是否為空
BooleanExpression isNotEmpty()	// 正則匹配查詢
BooleanExpression matches(Expression<String> regex)
// 模糊查詢。% 為通配符，_ 表一個字符，可以傳參escape指定轉(zhuǎn)義字符
BooleanExpression like(String str)
BooleanExpression like(String str, char escape)
BooleanExpression endsWith(str)		// 判斷字符串的后綴是否為str。注意：必須使用boolean數(shù)據(jù)類型的字段接收
BooleanExpression startsWith(str)	// 判斷字符串的前綴是否為str。注意：必須使用boolean數(shù)據(jù)類型的字段接收// 將字母轉(zhuǎn)換大小寫
StringExpression toLowerCase()
StringExpression toUpperCase()
StringExpression lower()
StringExpression upper()StringExpression trim()			// 去掉字符串兩端的空格
StringExpression substring(int beginIndex)		// 截取子字符串從索引位置至末尾
StringExpression concat(str)	// 拼接 str
StringExpression append(str)	// 在末尾添加 str
StringExpression prepend(str)	// 在前面添加 strNumberExpression<Integer> length()			// 返回字符串長度
NumberExpression<Integer> locate(str)		// 返回 str 的位置（從1開始），沒有返回0
NumberExpression<Integer> indexOf(str)		// 返回 str 索引（從0開始），沒有返回-1
SimpleExpression<Character> charAt(int i)	// 返回參數(shù)索引位置的字符。實體類接收字段需為char或CharacterSS

select() 和 fetch() 的常用寫法

注意：使用fetch()查詢時，數(shù)據(jù)庫沒有符合該條件的數(shù)據(jù)時，返回的是空集合，而不是null。

QMemberDomain qm = QMemberDomain.memberDomain;
//查詢字段-select()
List<String> nameList = queryFactory.select(qm.name).from(qm).fetch();//查詢實體-selectFrom()
List<MemberDomain> memberList = queryFactory.selectFrom(qm).fetch();//查詢并將結(jié)果封裝至dto中
List<MemberFavoriteDto> dtoList = queryFactory.select(Projections.bean(MemberFavoriteDto.class, qm.name, qf.favoriteStoreCode)).from(qm).leftJoin(qm.favoriteInfoDomains, qf).fetch();//去重查詢-selectDistinct()
List<String> distinctNameList = queryFactory.selectDistinct(qm.name).from(qm).fetch();//獲取首個查詢結(jié)果-fetchFirst()
MemberDomain firstMember = queryFactory.selectFrom(qm).fetchFirst();//獲取唯一查詢結(jié)果-fetchOne()
//當(dāng)fetchOne()根據(jù)查詢條件從數(shù)據(jù)庫中查詢到多條匹配數(shù)據(jù)時，會拋`NonUniqueResultException`。
MemberDomain anotherFirstMember = queryFactory.selectFrom(qm).fetchOne();

where 子句查詢條件的常用寫法

//查詢條件示例
List<MemberDomain> memberConditionList = queryFactory.selectFrom(qm)//like示例.where(qm.name.like('%'+"Jack"+'%')//contain示例.and(qm.address.contains("廈門"))//equal示例.and(qm.status.eq("0013"))//between.and(qm.age.between(20, 30)))               .fetch();

使用QueryDSL提供的BooleanBuilder來進(jìn)行查詢條件管理。

BooleanBuilder builder = new BooleanBuilder();
// like
builder.and(qm.name.like('%'+"Jack"+'%'));
// contain
builder.and(qm.address.contains("廈門"));
// equal示例
builder.and(qm.status.eq("0013"));
// between
builder.and(qm.age.between(20, 30));
List<MemberDomain> memberConditionList = queryFactory.selectFrom(qm).where(builder).fetch();// 復(fù)雜的查詢關(guān)系
BooleanBuilder builder2 = new BooleanBuilder();
builder2.or(qm.status.eq("0013"));
builder2.or(qm.status.eq("0014"));
builder.and(builder2);
List<MemberDomain> memberConditionList = queryFactory.selectFrom(qm).where(builder2).fetch();

自定義封裝查詢的結(jié)果集

方法一：使用Projections的Bean方法

JPAQueryFactory查詢工廠的select方法可以將Projections方法返回的QBean作為參數(shù)，通過Projections的bean方法來構(gòu)建返回的結(jié)果集映射到實體內(nèi)，有點像Mybatis內(nèi)的ResultMap的形式，不過內(nèi)部處理機制肯定是有著巨大差別的！

bean方法第一個參數(shù)需要傳遞一個實體的泛型類型作為返回集合內(nèi)的單個對象類型，如果QueryDSL查詢實體內(nèi)的字段與DTO實體的字段名字不一樣時，可以采用as方法來處理，為查詢的結(jié)果集指定的字段添加別名，這樣就會自動映射到DTO實體內(nèi)。

return queryFactory.select(Projections.bean(PersonIDCardDto.class, QIDCard.iDCard.idNo, QPerson.person.address, QPerson.person.name.as("userName")))		// 使用別名對應(yīng)dto內(nèi)的userName.from(QIDCard.iDCard, QPerson.person).where(predicate).fetch();

底層原理：

1. 使用數(shù)據(jù)封裝類的無參構(gòu)造方法創(chuàng)建對象（如果類上有使用@Builder注解導(dǎo)致@Data無參構(gòu)造方法被覆蓋，則會報錯，可以再加上 @AllArgsConstructor，@NoArgsConstructor 注解）
2. 使用setter方法封裝數(shù)據(jù)給字段（會校驗數(shù)據(jù)封裝字段和Entity對應(yīng)字段的數(shù)據(jù)類型是否一致，不一致則會報錯）

常見問題：

• Entity中時間字段的數(shù)據(jù)類型為 java.util.Date，數(shù)據(jù)封裝類中時間字段的數(shù)據(jù)類型為 java.sql.Date 或具有指定時間格式的String類型，數(shù)據(jù)類型不一致，導(dǎo)致數(shù)據(jù)無法封裝成功
  • 方案1：修改數(shù)據(jù)封裝類或Entity中時間的數(shù)據(jù)類型，使其類型一致
  • 方案2：數(shù)據(jù)封裝類中新增util.Date類型字段，手動重寫其setter方法，處理數(shù)據(jù)后賦值到原sql.Date類型字段上。注意：查詢封裝數(shù)據(jù)到字段時 as(“新增的util.Date字段”)
  • 方案3：數(shù)據(jù)封裝類中新增util.Date類型字段，先將數(shù)據(jù)封裝到該字段，再通過getter、setter方法處理數(shù)據(jù)后賦值到原sql.Date類型字段上。

方法二：使用Projections的fields方法

return queryFactory.select(Projections.fields(PersonIDCardDto.class, QIDCard.iDCard.idNo, QPerson.person.address, QPerson.person.name)).from(QIDCard.iDCard, QPerson.person).where(predicate).fetch();

方法三：使用Projections的constructor方法，注意構(gòu)造方法中參數(shù)的順序

return queryFactory.select(Projections.constructor(PersonIDCardDto.class, QPerson.person.name, QPerson.person.address, QIDCard.iDCard.idNo)).from(QIDCard.iDCard, QPerson.person).where(predicate).fetch();

方式四：使用集合的stream轉(zhuǎn)換

從方法開始到fetch()結(jié)束完全跟QueryDSL沒有任何區(qū)別，采用了最原始的方式進(jìn)行返回結(jié)果集，但是從fetch()獲取到結(jié)果集后處理的方式就有所改變了。

fetch()方法返回的類型是泛型List（List），List繼承了Collection，完全存在使用Collection內(nèi)非私有方法的權(quán)限，通過調(diào)用stream方法可以將集合轉(zhuǎn)換成Stream泛型對象，該對象的map方法可以操作集合內(nèi)單個對象的轉(zhuǎn)換，具體的轉(zhuǎn)換代碼可以根據(jù)業(yè)務(wù)邏輯進(jìn)行編寫。

在map方法內(nèi)有個lambda表達(dá)式參數(shù)tuple，通過tuple對象get方法就可以獲取對應(yīng)select方法內(nèi)的查詢字段。

注意：tuple只能獲取select內(nèi)存在的字段，如果select內(nèi)為一個實體對象，tuple無法獲取指定字段的值。

 	/*** 使用java8新特性Collection內(nèi)stream方法轉(zhuǎn)換dto*/public List<GoodDTO> selectWithStream() {//商品基本信息QGoodInfoBean goodBean = QGoodInfoBean.goodInfoBean;//商品類型QGoodTypeBean goodTypeBean = QGoodTypeBean.goodTypeBean;return queryFactory.select(goodBean.id,goodBean.price,goodTypeBean.name,goodTypeBean.id).from(goodBean,goodTypeBean)	//構(gòu)建兩表笛卡爾集.where(goodBean.typeId.eq(goodTypeBean.id))	//關(guān)聯(lián)兩表.orderBy(goodBean.order.desc())	//倒序.fetch().stream()//轉(zhuǎn)換集合內(nèi)的數(shù)據(jù).map(tuple -> {//創(chuàng)建商品dtoGoodDTO dto = new GoodDTO();//設(shè)置商品編號dto.setId(tuple.get(goodBean.id));//設(shè)置商品價格dto.setPrice(tuple.get(goodBean.price));//設(shè)置類型編號dto.setTypeId(tuple.get(goodTypeBean.id));//設(shè)置類型名稱dto.setTypeName(tuple.get(goodTypeBean.name));//返回本次構(gòu)建的dtoreturn dto;})//返回集合并且轉(zhuǎn)換為List<GoodDTO>.collect(Collectors.toList());}

排序、分頁

排序

.asc()		// 升序
.desc()		// 降序
.asc().nullsFirst()		// 升序，空值放前面
.asc().nullsLast()		// 降序，空值放前面

//排序
List<MemberDomain> orderList = queryFactory.selectFrom(qm).orderBy(qm.name.asc()).fetch();

分頁

.limit(long limit)		// 限制查詢結(jié)果返回的數(shù)量。即一頁多少條記錄（pageSize）
.offset(long offset)	// 跳過多少行。offset = ( pageNum - 1 ) * pageSize		// pageNum：第幾頁

    QMemberDomain qm = QMemberDomain.memberDomain;//寫法一JPAQuery<MemberDomain> query = queryFactory.selectFrom(qm).orderBy(qm.age.asc());// 查詢總條數(shù)。fetchCount時，orderBy不會被執(zhí)行long total = query.fetchCount(); // 獲取過濾后的查詢結(jié)果集List<MemberDomain> list0= query.offset(2).limit(5).fetch();//寫法二。fetchResults()自動實現(xiàn)count查詢和結(jié)果查詢，并封裝到QueryResults<T>中QueryResults<MemberDomain> results = queryFactory.selectFrom(qm).orderBy(qm.age.asc()).offset(2).limit(5).fetchResults();List<MemberDomain> list = results.getResults();	// 過濾后的查詢結(jié)果集logger.debug("total:"+results.getTotal());		// 符合過濾條件的的總條數(shù)logger.debug("offset:"+results.getOffset());	// 跳過多少條符合過濾條件的查詢結(jié)果logger.debug("limit:"+results.getLimit());		// 限制查詢結(jié)果返回的條數(shù)

寫法一和二都會發(fā)出兩條sql進(jìn)行查詢，一條查詢count，一條查詢具體數(shù)據(jù)。

寫法二的getTotal()等價于寫法一的fetchCount。

無論是哪種寫法，在查詢count的時候，orderBy、limit、offset這三個都不會被執(zhí)行?？梢源竽懯褂谩?/p>

子查詢

	// 子查詢作為where條件內(nèi)容@Testpublic void selectJPAExpressions() {List<MemberDomain> subList = queryFactory.selectFrom(qm).where(qm.status.in(JPAExpressions.select(qm.status).from(qm))).fetch();}// 子查詢作為select查詢字段@Testpublic void selectJPAExpressions() {QUserAddress ua = QUserAddress.userAddress;QUser u = QUser.user;List<UserAddressDTO> list = queryFactory.select(Projections.bean(UserAddressDTO.class, ua.addressee, Expressions.asNumber(JPAExpressions.select(u.id.count()).from(u).where(u.id.ne(ua.userId))).longValue()	// asNumber接收子查詢結(jié)果后需要指定數(shù)值的數(shù)據(jù)類型.as("lon")
//                	, Expressions.asString(	// asString接收子查詢結(jié)果后不用指定數(shù)據(jù)類型
//                	    JPAExpressions.
//                	        select(u.username)
//                	        .from(u)
//                	        .where(u.id.eq(ua.userId))
//                	)
//                	    .as("password"))).from(ua).where(ua.id.eq(38)).fetch();}

聯(lián)表動態(tài)查詢

    // JPA查詢工廠@Autowiredprivate JPAQueryFactory queryFactory; /*** 關(guān)聯(lián)查詢示例，查詢出城市和對應(yīng)的旅店*/@Testpublic void findCityAndHotel() {QTCity qtCity = QTCity.tCity;QTHotel qtHotel = QTHotel.tHotel;JPAQuery<Tuple> jpaQuery = queryFactory.select(qtCity, qtHotel).from(qtCity).leftJoin(qtHotel).on(qtHotel.city.longValue().eq(qtCity.id.longValue()));// 分離式 添加查詢條件jpaQuery.where(QTCity.tCity.name.like("shanghai"));// 獲取查詢結(jié)果List<Tuple> result = jpaQuery.fetch();// 對多元組取出數(shù)據(jù)，這個和select時的數(shù)據(jù)相匹配for (Tuple row : result) {System.out.println("qtCity:" + row.get(qtCity));System.out.println("qtHotel:" + row.get(qtHotel));System.out.println("--------------------");}}

聯(lián)表一對多查詢封裝

方式一：查詢結(jié)果返回類型為List

List<UserAddressDTO> list = queryFactory.from(u).join(ua).on(ua.userId.eq(u.id)).where(u.id.eq(31)).transform(GroupBy.groupBy(u.id).list(Projections.bean(UserAddressDTO.class,u.id, u.username,GroupBy.list(Projections.bean(UserAddress.class,ua.address, ua.city, ua.district)).as("userAddresses"))));

方式二：查詢結(jié)果返回類型為Map

map的key為分組字段，一般為主鍵ID

Map<Integer, UserAddressDTO> map = queryFactory.from(u).join(ua).on(ua.userId.eq(u.id)).where(u.id.eq(31)).transform(GroupBy.groupBy(u.id).as(Projections.bean(UserAddressDTO.class,u.id, u.username,GroupBy.list(Projections.bean(UserAddress.class,ua.address, ua.city, ua.district)).as("userAddresses"))));

實體類：

@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class UserAddressDTO {private Integer id;private String username;private String password;private String phone;private List<UserAddress> userAddresses;
}

使用聚合函數(shù)

//聚合函數(shù)-avg()
Double averageAge = queryFactory.select(qm.age.avg()).from(qm).fetchOne();//聚合函數(shù)-concat()
String concat = queryFactory.select(qm.name.concat(qm.address)).from(qm).fetchOne();//聚合函數(shù)-date_format()
String date = queryFactory.select(Expressions.stringTemplate("DATE_FORMAT({0},'%Y-%m-%d')", qm.registerDate)).from(qm).fetchOne();

當(dāng)用到DATE_FORMAT這類QueryDSL似乎沒有提供支持的Mysql函數(shù)時，可以手動拼一個String表達(dá)式。這樣就可以無縫使用Mysql中的函數(shù)了。

使用 Template 實現(xiàn)自定義語法

QueryDSL并沒有對數(shù)據(jù)庫的所有函數(shù)提供支持，好在它提供了Template特性。

可以使用Template來實現(xiàn)各種QueryDSL未直接支持的語法。

Template的局限性：

??由于Template中使用了{}來作為占位符（內(nèi)部序號從0開始），而正則表達(dá)式中也可能使用了{}，因而會產(chǎn)生沖突。

QMemberDomain qm = QMemberDomain.memberDomain;//使用booleanTemplate充當(dāng)where子句或where子句的一部分
List<MemberDomain> list = queryFactory.selectFrom(qm).where(Expressions.booleanTemplate("{0} = \"tofu\"", qm.name)).fetch();//上面的寫法，當(dāng)booleanTemplate中需要用到多個占位時
List<MemberDomain> list1 = queryFactory.selectFrom(qm).where(Expressions.booleanTemplate("{0} = \"tofu\" and {1} = \"Amoy\"", qm.name, qm.address)).fetch();//使用stringTemplate充當(dāng)查詢語句的某一部分
String date = queryFactory.select(Expressions.stringTemplate("DATE_FORMAT({0},'%Y-%m-%d')", qm.registerDate)).from(qm).fetchFirst();//在where子句中使用stringTemplate
String id = queryFactory.select(qm.id).from(qm).where(Expressions.stringTemplate("DATE_FORMAT({0},'%Y-%m-%d')", qm.registerDate).eq("2018-03-19")).fetchFirst();

QueryDslPredicateExecutor 風(fēng)格

通常使用Repository來繼承QueryDslPredicateExecutor<T>接口。通過注入Repository來使用。

Repository 接口

Spring Data JPA中提供了QueryDslPredicateExecutor接口，用于支持QueryDSL的查詢操作。

public interface tityRepository extends JpaRepository<City, Integer>, QuerydslPredicateExecutor<city> {}

QueryDslPredicateExecutor<T>接口提供了findOne()，findAll()，count()，exists()四個方法來支持查詢。并可以使用更優(yōu)雅的BooleanBuilder 來進(jìn)行條件分支管理。

• count()會返回滿足查詢條件的數(shù)據(jù)行的數(shù)量
• exists()會根據(jù)所要查詢的數(shù)據(jù)是否存在返回一個boolean值

findOne()、findAll()

findOne

從數(shù)據(jù)庫中查出一條數(shù)據(jù)。沒有重載方法。

Optional<T> findOne(Predicate var1);

和JPAQuery的fetchOne()一樣，當(dāng)根據(jù)查詢條件從數(shù)據(jù)庫中查詢到多條匹配數(shù)據(jù)時，會拋NonUniqueResultException。使用的時候需要慎重。

findAll()

findAll是從數(shù)據(jù)庫中查出匹配的所有數(shù)據(jù)。提供了以下幾個重載方法。

Iterable<T> findAll(Predicate var1);Iterable<T> findAll(Predicate var1, Sort var2);Iterable<T> findAll(Predicate var1, OrderSpecifier<?>... var2);Iterable<T> findAll(OrderSpecifier<?>... var1);Page<T> findAll(Predicate var1, Pageable var2);

使用示例：

QMemberDomain qm = QMemberDomain.memberDomain;
// QueryDSL 提供的排序?qū)崿F(xiàn)
OrderSpecifier<Integer> order = new OrderSpecifier<>(Order.DESC, qm.age);
Iterable<MemberDomain> iterable = memberRepo.findAll(qm.status.eq("0013"),order);QMemberDomain qm = QMemberDomain.memberDomain;
// Spring Data 提供的排序?qū)崿F(xiàn)
Sort sort = new Sort(new Sort.Order(Sort.Direction.ASC, "age"));
Iterable<MemberDomain> iterable = memberRepo.findAll(qm.status.eq("0013"), sort);

單表動態(tài)分頁查詢

單表動態(tài)查詢示例：

//動態(tài)條件
QTCity qtCity = QTCity.tCity; //SDL實體類
//該Predicate為querydsl下的類,支持嵌套組裝復(fù)雜查詢條件
Predicate predicate = qtCity.id.longValue().lt(3).and(qtCity.name.like("shanghai"));
//分頁排序
Sort sort = new Sort(new Sort.Order(Sort.Direction.ASC,"id"));
PageRequest pageRequest = new PageRequest(0,10,sort);
//查找結(jié)果
Page<TCity> tCityPage = tCityRepository.findAll(predicate, pageRequest);

Querydsl SQL 查詢

Querydsl SQL 模塊提供與 JDBC API 的集成?？梢允褂酶嗟?JDBC SQL方法。比如可以實現(xiàn) from 的查詢主體為子查詢出來的臨時表、union、union All 等Querydsl-JPA限制的相關(guān)操作。還可以根據(jù) JDBC API 獲取數(shù)據(jù)庫的類型使用不同的數(shù)據(jù)庫語法模板。

依賴及配置

依賴：

        <dependency><groupId>com.querydsl</groupId><artifactId>querydsl-sql</artifactId><version>${querydsl.version}</version></dependency><!-- joda-time為querydsl-sql中必需的新版本的時間日期處理庫 --><dependency><groupId>joda-time</groupId><artifactId>joda-time</artifactId><version>2.10.5</version></dependency>

yaml配置：

logging:level:com.querydsl.sql: debug		# 打印日志

SQLQuery 的 Q 類

需要自己創(chuàng)建編寫（可以基于apt 插件生成的 JPA 的Q類改造），并放到主目錄（src）啟動類下的包里。

• 使用 extends RelationalPathBase<Entity> 的Q類。推薦

  需要將數(shù)據(jù)庫表名傳入構(gòu)造方法的table參數(shù)里，path 可以傳別名，所有的property參數(shù)為實體類的屬性名（駝峰命名），addMetadata() 中ColumnMetadata.named("FeildNmae") 的 FeildNmae 為數(shù)據(jù)庫字段名。

  使用該Q類查詢所有字段數(shù)據(jù)時（即select(Q類)）可以自動映射封裝結(jié)果集。

• 使用extends EntityPathBase<Entity>的Q類。

  需要將傳入構(gòu)造方法的variable參數(shù)改成數(shù)據(jù)庫表名，并且將所有的property參數(shù)改成相對應(yīng)的數(shù)據(jù)庫字段名。

  **注意：**使用 extends EntityPathBase<Entity> 的實體Q類，直接 select(Q類) 會報錯，無法自動映射封裝結(jié)果集，需要使用Projections.bean(Entity.class，Expression<?>... exprs) 手動封裝結(jié)果集。

/*** extends RelationalPathBase<Entity> 的Q類示例*/
public class QEmployee extends RelationalPathBase<Employee> {private static final long serialVersionUID = 1394463749655231079L;public static final QEmployee employee = new QEmployee("EMPLOYEE");public final NumberPath<Integer> id = createNumber("id", Integer.class);public final StringPath firstname = createString("firstname");public final DatePath<java.util.Date> datefield = createDate("datefield", java.util.Date.class);public final PrimaryKey<Employee> idKey = createPrimaryKey(id);public QEmployee(String path) {super(Employee.class, PathMetadataFactory.forVariable(path), "PUBLIC", "EMPLOYEE");addMetadata();}public QEmployee(PathMetadata metadata) {super(Employee.class, metadata, "PUBLIC", "EMPLOYEE");addMetadata();}protected void addMetadata() {addMetadata(id, ColumnMetadata.named("ID").ofType(Types.INTEGER));addMetadata(firstname, ColumnMetadata.named("FIRSTNAME").ofType(Types.VARCHAR));addMetadata(datefield, ColumnMetadata.named("DATEFIELD").ofType(Types.DATE));}
}

/*** extends EntityPathBase<Entity> 的Q類示例*/
public class QUserAddressS extends EntityPathBase<UserAddress> {private static final long serialVersionUID = -1295712525L;public static final QUserAddressS userAddress = new QUserAddressS("tb_user_address");public final NumberPath<Integer> id = createNumber("id", Integer.class);public final StringPath address = createString("address");public final DateTimePath<java.util.Date> createTime = createDateTime("create_time", java.util.Date.class);public QUserAddressS(String variable) {super(UserAddress.class, forVariable(variable));}public QUserAddressS(Path<? extends UserAddress> path) {super(path.getType(), path.getMetadata());}public QUserAddressS(PathMetadata metadata) {super(UserAddress.class, metadata);}
}

SQLQueryFactory 方式

裝配及基本使用

裝配

@Configuration
@Slf4j
public class QueryDslConfig {@Beanpublic SQLQueryFactory sqlQueryFactory(DataSource druidDataSource){SQLTemplates t;try(Connection connection = druidDataSource.getConnection()){t = new SQLTemplatesRegistry().getTemplates(connection.getMetaData());}catch (Exception e){log.error("", e);t = SQLTemplates.DEFAULT;}com.querydsl.sql.Configuration configuration = new com.querydsl.sql.Configuration(t);configuration.addListener(new SQLBaseListener(){@Overridepublic void end(SQLListenerContext context) {if (context != null && !DataSourceUtils.isConnectionTransactional(context.getConnection(), druidDataSource)){// 若非事務(wù)連接SQLCloseListener.DEFAULT.end(context);}}});configuration.setExceptionTranslator(new SpringExceptionTranslator());// 創(chuàng)建SQLQueryFactory，且數(shù)據(jù)庫連接由spring管理return new SQLQueryFactory(configuration, () -> DataSourceUtils.getConnection(druidDataSource));}
}

注入

    @Autowiredprivate SQLQueryFactory sqlQueryFactory;

SQLQueryFactory 基本使用

    /*** 子查詢作為臨時表傳入from()中*/@Testpublic void selectBySqlQueryFactory(){// 使用 extends RelationalPathBase<Entity> 的QEntity，自動映射封裝QUserAddressSql uaSql = QUserAddressSql.userAddress;// 子查詢SQLQuery<Tuple> q = SQLExpressions.select(// 查詢字段須是數(shù)據(jù)庫表中的字段名（不是實體屬性名），且類型一致uaSql.addressee, uaSql.userId).from(uaSql);List<Tuple> fetch = sqlQueryFactory.select(// 查詢字段須是臨時表中的字段別名，且類型一致Expressions.template(String.class, "q.addressee").as("addressee"), Expressions.numberTemplate(Integer.class, "q.user_id").as("userId")).from(q, Expressions.stringPath("q"))   // 子查詢作為臨時表.fetch();System.out.println(fetch);}/*** 子查詢結(jié)果集 union*/@Testpublic void selectBySqlQueryFactory(){// 使用 extends EntityPathBase<Entity> 的改造版QEntity，結(jié)果集如需封裝到實體類，必須手動指定實體類來接收QUserAddressSql uaSql = QUserAddressSql.userAddress;QUserSql uSql = QUserSql.user;SQLQuery<Tuple> a = SQLExpressions.select(uaSql.userId.as("user_id") , uaSql.phone).from(uaSql).where(uaSql.userId.eq(30));SQLQuery<Tuple> b = SQLExpressions.select(uSql.id.as("user_id") , uSql.phone).from(uSql).where(uSql.id.eq(29).or(uSql.id.eq(30)));Union<Tuple> union = sqlQueryFactory.query().union(a, b);long count = sqlQueryFactory.from(union, Expressions.stringPath("q")).fetchCount();List<UserAddressDTO> list = sqlQueryFactory.from(union, Expressions.stringPath("q")).orderBy(Expressions.numberPath(Integer.class, "user_id").desc(), Expressions.stringTemplate("phone").desc()).offset(0).limit(5).transform(GroupBy.groupBy(Expressions.template(String.class, "q.user_id")).list(Projections.bean(UserAddressDTO.class, Expressions.template(Integer.class, "q.user_id").as("userId"), GroupBy.list(Projections.bean(UserAddress.class, Expressions.stringTemplate("q.phone").as("phone"))).as("userAddresses"))));System.out.println(count);list.forEach(s -> System.out.println(JSON.toJSONString(s)));}

SQLExpression 表達(dá)式工具類

// 合并多張表記錄。union為去重合并，unionAll為不去重合并
static <T> Union<T> union(SubQueryExpression<T>... sq)
static <T> Union<T> union(List<SubQueryExpression<T>> sq)
static <T> Union<T> unionAll(SubQueryExpression<T>... sq)
static <T> Union<T> unionAll(List<SubQueryExpression<T>> sq)// 調(diào)用函數(shù)查詢序列
static SimpleExpression<Long> nextval(String sequence)
static <T extends Number> SimpleExpression<T> nextval(Class<T> type, String sequence)
// 使用示例：SQL寫法：select seq_process_no.nextval from dual;
Long nextvalReturn = sqlQueryFactory.select(SQLExpressions.nextval("序列名")).fetchOne;// 將多列記錄聚合為一列記錄。delimiter為分隔符。Oracle數(shù)據(jù)庫專屬，其他數(shù)據(jù)庫報錯
static WithinGroup<Object> listagg(Expression<?> expr, String delimiter)
// 使用示例：
SQLExpression.listagg(qEntity.name, ",").withinGroup.OrderBy(qEntity.name.asc()).getValue.as("Name")// 將多列記錄聚合為一列記錄。separator為分隔符。MySQL、PostgreSQL都可用，PostgreSQL會根據(jù)模板翻譯成String_agg函數(shù)
static StringExpression groupConcat(Expression<String> expr, String separator)
static StringExpression groupConcat(Expression<String> expr)static <T> RelationalFunctionCall<T> relationalFunctionCall(Class<? extends T> type, String function, Object... args)static <D extends Comparable> DateExpression<D> date(DateTimeExpression<D> dateTime)
static <D extends Comparable> DateExpression<D> date(Class<D> type, DateTimeExpression<?> dateTime)static <D extends Comparable> DateTimeExpression<D> dateadd(DatePart unit, DateTimeExpression<D> date, int amount)
static <D extends Comparable> DateExpression<D> dateadd(DatePart unit, DateExpression<D> date, int amount)// 獲取兩個日期的時間間隔(end-start)
static <D extends Comparable> NumberExpression<Integer> datediff(DatePart unit, DateTimeExpression<D> start, DateTimeExpression<D> end)

JPASQLQuery 方式

使用 JPASQLQuery 作為查詢引擎時，使用的QEntity（extends EntityPathBase<Entity>），傳入構(gòu)造方法的 variable 參數(shù)可以不為數(shù)據(jù)庫表名（因為 JPASQLQuery 可以找到映射的真實表名，僅把此參數(shù)作為表別名），但所有的 property 參數(shù)仍必需為相對應(yīng)的數(shù)據(jù)庫字段名。

故并不能直接使用 apt 插件生成 的 jpa 使用的 Q類，仍需要使用改造版的 Q類（extends EntityPathBase<Entity>）。

	@Testpublic void selectBySqlQueryFactory(){// 使用 extends EntityPathBase<Entity> 的改造版QEntity，結(jié)果集如需封裝到實體類，必須手動指定實體類來接收QUserAddress ua = QUserAddress.userAddress;// jpa+sql的查詢工具，本例使用的oracle的sql模板JPASQLQuery<?> jpasqlQuery = new JPASQLQuery<Void>(em, new OracleTemplates());// 子查詢SQLQuery<Tuple> q = SQLExpressions.select(// 查詢字段須是數(shù)據(jù)庫表中的字段名（不是實體屬性名），且類型一致。如直接不使用QEntity的屬性，則需手動指定Expressions.stringPath("addressee").as("addressee"), Expressions.numberPath(Integer.class, "user_id").as("user_id")).from(ua);List<Tuple> fetch = jpasqlQuery.select(// 查詢字段須是臨時表中的字段名或別名，且類型一致。結(jié)果集字段需添加別名手動映射封裝Expressions.template(String.class, "q.addressee").as("addressee"), Expressions.numberTemplate(Integer.class, "q.user_id").as("userId")).from(q, Expressions.stringPath("q"))   // 子查詢作為臨時表.fetch();System.out.println(fetch);}