JPA之QueryDSL-JPA使用指南
更新時間：2023年11月29日 11:03:02 作者：墨鴉_Cormorant
Springdata-JPA是對JPA使用的封裝,Querydsl-JPA也是基于各種ORM之上的一個通用查詢框架,使用它的API類庫可以寫出Java代碼的sql,下面就來介紹一下JPA之QueryDSL-JPA使用指南
官網(wǎng)：傳送門
概述及依賴、插件、生成查詢實體
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)勢就是可以更輕松的進行增量查詢的定義
使用
在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ù)。甚至可以用來進行更新和刪除操作。
依賴
<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默認使用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注解注冊實例進行容器托管
*/
@Configuration
public class QueryDslConfig {
@Bean
public JPAQueryFactory jpaQueryFactory(EntityManager em){
return new JPAQueryFactory(em);
}
}
/**
* 方式二。在Dao類中初始化
*/
// 實體管理
@Autowired
private EntityManager entityManager;
// 查詢工廠
private JPAQueryFactory queryFactory;
// 初始化JPA查詢工廠
@PostConstruct // Constructor(構(gòu)造方法) -> @Autowired(依賴注入) -> @PostConstruct(注釋的方法)
public void init(){
queryFactory = new JPAQueryFactory(entityManager);
}
注入
@Autowired
private 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);
}
查詢
表達式工具類
Expressions 表達式工具類
// when-then 條件表達式函數(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é)表達式工具類
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)的隨機值
表達式方法
注意：在select()中查詢出的結(jié)果使用表達式方法處理過后，若要封裝到實體類中，則都需要使用 .as(alias) 起別名指定封裝到實體類中的哪個字段。
SimpleExpression 簡單表達式 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è)置默認值。返回 Field, A, B ... 順序中第一個非null的值，若都為null則返回null // 注意：使用該方法兜底Oracle數(shù)據(jù)庫的null為空字符串時會失效，因為Oracle會把空字符串當(dāng)作null T coalesce(A, B ...)
NumberExpression 數(shù)值表達式 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() // 返回字符串表達式
// 數(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 布爾表達式 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 字符串表達式 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) // 在前面添加 str
NumberExpression<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來進行查詢條件管理。
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();
底層原理：
- 使用數(shù)據(jù)封裝類的無參構(gòu)造方法創(chuàng)建對象（如果類上有使用@Builder注解導(dǎo)致@Data無參構(gòu)造方法被覆蓋，則會報錯，可以再加上 @AllArgsConstructor，@NoArgsConstructor 注解）
- 使用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ū)別，采用了最原始的方式進行返回結(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ù)邏輯進行編寫。
在map方法內(nèi)有個lambda表達式參數(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)建商品dto
GoodDTO 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)建的dto
return 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進行查詢，一條查詢count，一條查詢具體數(shù)據(jù)。
寫法二的getTotal()等價于寫法一的fetchCount。
無論是哪種寫法，在查詢count的時候，orderBy、limit、offset這三個都不會被執(zhí)行?？梢源竽懯褂?。
子查詢
// 子查詢作為where條件內(nèi)容
@Test
public void selectJPAExpressions() {
List<MemberDomain> subList = queryFactory
.selectFrom(qm)
.where(qm.status.in(
JPAExpressions.select(qm.status).from(qm)))
.fetch();
}
// 子查詢作為select查詢字段
@Test
public 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查詢工廠
@Autowired
private JPAQueryFactory queryFactory;
/**
* 關(guān)聯(lián)查詢示例，查詢出城市和對應(yīng)的旅店
*/
@Test
public 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表達式。這樣就可以無縫使用Mysql中的函數(shù)了。
使用 Template 實現(xiàn)自定義語法
QueryDSL并沒有對數(shù)據(jù)庫的所有函數(shù)提供支持，好在它提供了Template特性。
可以使用Template來實現(xiàn)各種QueryDSL未直接支持的語法。
Template的局限性：
由于Template中使用了{}來作為占位符（內(nèi)部序號從0開始），而正則表達式中也可能使用了{}，因而會產(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 來進行條件分支管理。
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 {
@Bean
public 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(){
@Override
public 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));
}
}
注入
@Autowired
private SQLQueryFactory sqlQueryFactory;
SQLQueryFactory 基本使用
/**
* 子查詢作為臨時表傳入from()中
*/
@Test
public 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
*/
@Test
public 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 表達式工具類
// 合并多張表記錄。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>）。
@Test
public 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);
}參考：
到此這篇關(guān)于JPA之QueryDSL-JPA使用指南的文章就介紹到這了,更多相關(guān)QueryDSL-JPA使用 內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
這篇文章主要介紹了Java繼承的實現(xiàn)與繼承限制,結(jié)合具體實例形式分析了Java繼承的定義、實現(xiàn)以及繼承的相關(guān)限制,需要的朋友可以參考下2019-01-01
SpringBoot3整合EasyExcel動態(tài)實現(xiàn)表頭重命名
這篇文章主要為大家詳細介紹了SpringBoot3整合EasyExcel如何通過WriteHandler動態(tài)實現(xiàn)表頭重命名,文中的示例代碼講解詳細,有需要的可以了解下2025-03-03
Spring Boot實現(xiàn)郵件服務(wù)（附：常見郵箱的配置）
這篇文章主要給大家介紹了關(guān)于Spring Boot實現(xiàn)郵件服務(wù)的相關(guān)資料，文中還附上了常見郵箱的配置，通過示例代碼介紹的非常詳細，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2018-12-12
詳解使用Spring的BeanPostProcessor優(yōu)雅的實現(xiàn)工廠模式
這篇文章主要介紹了詳解使用Spring的BeanPostProcessor優(yōu)雅的實現(xiàn)工廠模式，文中通過示例代碼介紹的非常詳細，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2020-07-07
在spring boot中使用java線程池ExecutorService的講解
今天小編就為大家分享一篇關(guān)于在spring boot中使用java線程池ExecutorService的講解，小編覺得內(nèi)容挺不錯的，現(xiàn)在分享給大家，具有很好的參考價值，需要的朋友一起跟隨小編來看看吧2019-03-03
這篇文章給大家介紹SpringCloud Config使用及構(gòu)建配置中心的方法，本文給大家介紹的非常詳細，對大家的學(xué)習(xí)或工作具有一定的參考借鑒價值，需要的朋友參考下吧2021-07-07
這篇文章主要介紹了SpringBoot項目整合Redis教程詳解，Redis?是完全開源的，遵守?BSD?協(xié)議，是一個高性能的?key-value?數(shù)據(jù)庫。感興趣的小伙伴可以參考閱讀本文2023-03-03
使用IntelliJ IDEA調(diào)式Stream流的方法步驟
本文主要介紹了使用IntelliJ IDEA調(diào)式Stream流的方法步驟，文中通過示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2022-05-05
java?stream?distinct()如何按一個或多個指定對象字段進行去重
這篇文章主要介紹了java?stream?distinct()如何按一個或多個指定對象字段進行去重問題,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2023-12-12
本文介紹了Spring中多種排序機制,包括Ordered接口、PriorityOrdered接口、@Order注解和@Priority注解,提供了詳細示例,并指導(dǎo)如何選擇合適的排序機制來控制Bean的加載順序和優(yōu)先級,感興趣的朋友一起看看吧2025-02-02