POM文件和BEAN
<dependencies>
<!-- QueryDSL框架依赖 -->
<dependency>
<groupId>com.querydsl</groupId>
<artifactId>querydsl-apt</artifactId>
</dependency>
<dependency>
<groupId>com.querydsl</groupId>
<artifactId>querydsl-jpa</artifactId>
</dependency>
</dependencies>
<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>
<options>
<!--修改包前缀 -->
<querydsl.packageSuffix>.dsl</querydsl.packageSuffix>
</options>
</configuration>
</execution>
</executions>
</plugin>idea 工具 为maven project 自动添加了对应的功能。添加好依赖和 plugin 插件后，双击 clean 清除已编译的 target,双击 compile 命令执行，执行完成后会在 pom.xml 配置文件内配置生成目录内生成对应实体的 QueryDSL 查询实体。
JPA在application.yml中配置
spring:
jpa:
hibernate:
ddl-auto: update
show-sql: false
properties:
hibernate:
order_by:
default_null_ordering: last
# generate_statistics: true
jdbc:
batch_size: 500
batch_versioned_data: true
order_inserts: true
order_updates: trueJPAQueryFactory 风格QueryDSL 在支持JPA的同时，也提供了对 Hibernate 的支持。可以通过 HibernateQueryFactory 来使用。
方式一。使用Spring的@Configuration注解注册实例进行容器托管 */
@Configuration
public class QueryDslConfig {
@Bean
@Autowired //不知道为啥要加这个（我现在项目里面是这么写的）
public JPAQueryFactory jpaQueryFactory(EntityManager em){ return new JPAQueryFactory(em); } }
方式二。在Dao类中初始化*/// 实体管理
@Autowired
private EntityManager entityManager;
// 查询工厂
private JPAQueryFactory queryFactory;
// 初始化JPA查询工厂 // Constructor(构造方法) -> @Autowired(依赖注入) -> @PostConstruct(注释的方法)
@PostConstruct
public void init(){queryFactory = new JPAQueryFactory(entityManager);}更新
在Querydsl JPA中，更新语句是简单的 update-set/where-execute 形式。
execute()执行后返回的是被更新的实体的数量。
注意：使用QueryDsl更新实体时需要添加事务
@Transactional
public void testUpdate() {
QStudent qStudent = QStudent.student;
Long result = queryFactory.update(qStudent)
.set(qStudent.name, "haha") // 可以用if条件判断更新值来确定字段是否.set()
.setnull(qStudent.age) // 设置null值
.where(qStudent.id.eq(111L)).execute();
assertThat(result, equalTo(1L));
}
删除
删除语句是简单的 delete-where-execute 形式。使用QueryDsl删除实体时需要添加事务
@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 条件表达式函数。when传参必须为名为eqTrue或eqFalse的Predicate
T cases().when(Predicate).then(T a).otherwise(T b)
DateExpression<Date> currentDate() // 返回当前日历（年-月-日）的 DateExpression
TimeExpression<Time> currentTime() // 返回当前时刻（时:分:秒）的 TimeExpression
DateTimeExpression<Date> currentTimestamp() // 返回当前时间（年-月-日 时:分:秒）的 DateTimeExpression
// exprs 均为名为eqTrue的Predicate ，则返回名为eqTrue的Predicate，否则返回eqFalse的Predicate
BooleanExpression allOf(BooleanExpression... exprs)
// exprs 至少存在一个名为eqTrue的Predicate，则返回名为eqTrue的Predicate，否则返回eqFalse的Predicate
BooleanExpression anyOf(BooleanExpression... exprs)
// 转类型为 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)
123456789101112131415161718192021222324
MathExpressions 数学表达式工具类
NumberExpression<A> round(Expression<A> num) // 四舍五入取整
NumberExpression<A> round(Expression<A> num, int s) // 四舍五入保留 s 位小数
NumberExpression<Double> asin(Expression<A> num) // 返回num的反正弦值。-1 <= num <= 1，否则返回null
NumberExpression<Double> acos(Expression<A> num) // 返回num的反余弦值。-1 <= num <= 1，否则返回null
// 慎用！qdsl-jpa底层是调用random()函数，MySQL没有该函数，只有rand()函数，会报错，解决方案为使用QDSL-SQL查询
NumberExpression<Double> random() // 返回０到１内的随机值
NumberExpression<Double> random(int seed) // 返回一个指定的０到１内的随机值
表达式方法
注意：在select()中查询出的结果使用表达式方法处理过后，若要封装到实体类中，则都需要使用 .as(alias) 起别名指定封装到实体类中的哪个字段，除非属性和名字都对应上他会自己映射
SimpleExpression 简单表达式 extends DslExpression extends Expression
// 相当于java中的switch语句。两种写法 T when(A).then(B).otherwise(C)
// 该字段的查询结果等于参数则返回null，不等于则返回查询结果。Field == A ? null : Field SimpleExpression<T> nullif(A)
// 符合过滤条件的的总条数。 select count(table.id) from table NumberExpression<Long> count()
ComparableExpressionBase extends SimpleExpression
// 设置默认值。返回 Field, A, B ... 顺序中第一个非null的值，若都为null则返回null // 注意：使用该方法兜底Oracle数据库的null为空字符串时会失效，因为Oracle会把空字符串当作null T coalesce(A, B ...) 123
NumberExpression 数值表达式 extends ComparableExpressionBase
// 数据类型转换为数字类型。type为数字基本类型的包装类.class。实体类接收字段需与type的类型一致
NumberExpression<T> castToNum(Class<A> type)
ComparableExpression extends ComparableExpressionBase
BooleanExpression 布尔表达式 extends LiteralExpression (extends ComparableExpression) implements Predicate
StringExpressions 字符串表达式 extends LiteralExpression extends ComparableExpression
tringExpression contains(String str) // 包含参数字符串
BooleanExpression isEmpty() // 判断是否为空
BooleanExpression isNotEmpty()
// 正则匹配查询
BooleanExpression matches(Expression<String> regex)
// 模糊查询。% 为通配符，_ 表一个字符，可以传参escape指定转义字符
// 判断字符串的后缀是否为str。注意：必须使用boolean数据类型的字段接收
BooleanExpression endsWith(str)
// 判断字符串的前缀是否为str。注意：必须使用boolean数据类型的字段接收
BooleanExpression startsWith(str)
/ 将字母转换大小写
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) // 返回参数索引位置的字符。实体类接收字段需为char或CharacterSS
select() 和 fetch() 的常用写法
注意：使用fetch()查询时，数据库没有符合该条件的数据时，返回的是空集合，而不是null。
QMemberDomain qm = QMemberDomain.memberDomain;
//查询字段-select()
List<String> nameList = queryFactory
.select(qm.name)
.from(qm)
.fetch();
//查询实体-selectFrom()
List<MemberDomain> memberList = queryFactory
.selectFrom(qm)
.fetch();
//查询并将结果封装至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();
//获取首个查询结果-fetchFirst()
MemberDomain firstMember = queryFactory
.selectFrom(qm)
.fetchFirst();
//获取唯一查询结果-fetchOne()
//当fetchOne()根据查询条件从数据库中查询到多条匹配数据时，会抛`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();
自定义封装查询的结果集
方法一：使用Projections的Bean方法(常用)
JPAQueryFactory查询工厂的select方法可以将Projections方法返回的QBean作为参数，通过Projections的bean方法来构建返回的结果集映射到实体内，有点像Mybatis内的ResultMap的形式，不过内部处理机制肯定是有着巨大差别的！
bean方法第一个参数需要传递一个实体的泛型类型作为返回集合内的单个对象类型，如果QueryDSL查询实体内的字段与DTO实体的字段名字不一样时，可以采用as方法来处理，为查询的结果集指定的字段添加别名，这样就会自动映射到DTO实体内。
return queryFactory
.select(
Projections.bean(PersonIDCardDto.class,
QIDCard.iDCard.idNo,
QPerson.person.address,
QPerson.person.name.as("userName"))) // 使用别名对应dto内的userName
.from(QIDCard.iDCard, QPerson.person)
.where(predicate)
.fetch();
底层原理：
- 使用数据封装类的无参构造方法创建对象（如果类上有使用@Builder注解导致@Data无参构造方法被覆盖，则会报错，可以再加上 @AllArgsConstructor，@NoArgsConstructor 注解）
- 使用setter方法封装数据给字段（会校验数据封装字段和Entity对应字段的数据类型是否一致，不一致则会报错）
方法二、使用Projections的fields方法，使用Projections的constructor
return queryFactory
.select(
Projections.fields(PersonIDCardDto.class,
QIDCard.iDCard.idNo,
QPerson.person.address,
QPerson.person.name))
.from(QIDCard.iDCard, QPerson.person)
.where(predicate)
.fetch();
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转换
从方法开始到fetch()结束完全跟QueryDSL没有任何区别，采用了最原始的方式进行返回结果集，但是从fetch()获取到结果集后处理的方式就有所改变了。
fetch()方法返回的类型是泛型List（List），List继承了Collection，完全存在使用Collection内非私有方法的权限，通过调用stream方法可以将集合转换成Stream泛型对象，该对象的map方法可以操作集合内单个对象的转换，具体的转换代码可以根据业务逻辑进行编写。
在map方法内有个lambda表达式参数tuple，通过tuple对象get方法就可以获取对应select方法内的查询字段。
注意：tuple只能获取select内存在的字段，如果select内为一个实体对象，tuple无法获取指定字段的值。
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) //构建两表笛卡尔集
.where(goodBean.typeId.eq(goodTypeBean.id)) //关联两表
.orderBy(goodBean.order.desc()) //倒序
.fetch()
.stream()
//转换集合内的数据
.map(tuple -> {
//创建商品dto
GoodDTO dto = new GoodDTO();
//设置商品编号
dto.setId(tuple.get(goodBean.id));
//设置商品价格
dto.setPrice(tuple.get(goodBean.price));
//设置类型编号
dto.setTypeId(tuple.get(goodTypeBean.id));
//设置类型名称
dto.setTypeName(tuple.get(goodTypeBean.name));
//返回本次构建的dto
return dto;
})
//返回集合并且转换为List<GoodDTO>
.collect(Collectors.toList());
}
排序、分页
.asc() // 升序 .desc() // 降序 .asc().nullsFirst() // 升序，空值放前面 .asc().nullsLast() // 降序，空值放前面 .limit(long limit) // 限制查询结果返回的数量。即一页多少条记录（pageSize） .offset(long offset) // 跳过多少行。offset = ( pageNum - 1 ) * pageSize
QMemberDomain qm = QMemberDomain.memberDomain;
//写法一
JPAQuery<MemberDomain> query = queryFactory
.selectFrom(qm)
.orderBy(qm.age.asc());
// 查询总条数。fetchCount时，orderBy不会被执行
long total = query.fetchCount();
// 获取过滤后的查询结果集
List<MemberDomain> list0= query.offset(2).limit(5).fetch();
//写法二。fetchResults()自动实现count查询和结果查询，并封装到QueryResults<T>中
QueryResults<MemberDomain> results = queryFactory
.selectFrom(qm)
.orderBy(qm.age.asc())
.offset(2)
.limit(5)
.fetchResults();
List<MemberDomain> list = results.getResults(); // 过滤后的查询结果集
logger.debug("total:"+results.getTotal()); // 符合过滤条件的的总条数
logger.debug("offset:"+results.getOffset()); // 跳过多少条符合过滤条件的查询结果
logger.debug("limit:"+results.getLimit()); // 限制查询结果返回的条数
注意：写法一和二都会发出两条sql进行查询，一条查询count，一条查询具体数据。在查询count的时候，orderBy、limit、offset这三个都不会被执行。
子查询
// 子查询作为where条件内容
@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接收子查询结果后需要指定数值的数据类型
.as("lon")
// , Expressions.asString( // asString接收子查询结果后不用指定数据类型
// JPAExpressions.
// select(u.username)
// .from(u)
// .where(u.id.eq(ua.userId))
// )
// .as("password")
)
)
.from(ua)
.where(ua.id.eq(38))
.fetch();
}
/**
* 子查询结果集 union
*/
@Test
public void selectBySqlQueryFactory(){
// 使用 extends EntityPathBase<Entity> 的改造版QEntity，结果集如需封装到实体类，必须手动指定实体类来接收
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)));
}
联表一对多查询封装
实体类：
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class UserAddressDTO {
private Integer id;
private String username;
private String password;
private String phone;
private List<UserAddress> userAddresses;
}
查询结果返回类型为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")))
);
查询结果返回类型为Map
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")))
);
使用聚合函数
//聚合函数-avg()
Double averageAge = queryFactory
.select(qm.age.avg())
.from(qm)
.fetchOne();
//聚合函数-concat()
String concat = queryFactory
.select(qm.name.concat(qm.address))
.from(qm)
.fetchOne();
//聚合函数-date_format()
//DATE_FORMAT这类QueryDSL似乎没有提供支持的Mysql函数时，可以手动拼一个String表达式。这样就可以无缝使用Mysql中的函数了
String date = queryFactory
.select(
Expressions.stringTemplate("DATE_FORMAT({0},'%Y-%m-%d')",
qm.registerDate))
.from(qm)
.fetchOne()
使用 Template 实现自定义语法
QueryDSL并没有对数据库的所有函数提供支持，好在它提供了Template特性。
可以使用Template来实现各种QueryDSL未直接支持的语法。
Template的局限性：
由于Template中使用了{}来作为占位符（内部序号从0开始），而正则表达式中也可能使用了{}，因而会产生冲突。
QMemberDomain qm = QMemberDomain.memberDomain;
//使用booleanTemplate充当where子句或where子句的一部分
List<MemberDomain> list = queryFactory
.selectFrom(qm)
.where(Expressions.booleanTemplate("{0} = \"tofu\"", qm.name))
.fetch();
//上面的写法，当booleanTemplate中需要用到多个占位时
List<MemberDomain> list1 = queryFactory
.selectFrom(qm)
.where(
Expressions.booleanTemplate("{0} = \"tofu\" and {1} = \"Amoy\"",
qm.name,
qm.address))
.fetch();
//使用stringTemplate充当查询语句的某一部分
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();
DSL单表查询
使用Repository来继承QueryDslPredicateExecutor<T>接口，比如：
public interface tityRepository extends JpaRepository<City, Integer>, QuerydslPredicateExecutor<city> ,JpaSpecificationExecutor<city>{
}
通过关键字构建单表查询sql
count()会返回满足查询条件的数据行的数量- findOne() 和
JPAQuery的fetchOne()一样，当根据查询条件从数据库中查询到多条匹配数据时，会抛NonUniqueResultException。使用的时候需要慎重。 - findAll()
exists()会根据所要查询的数据是否存在返回一个boolean值
public List<DatRoom> findRooms(TDatRoomInfo datRoom, Set<Long> departmentId) {
return datRoomRepository.findAll(new Specification<DatRoom>() {
@Override
public Predicate toPredicate(Root<DatRoom> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder) {
List<Predicate> predicateList = new ArrayList<>();
List<Predicate> orPredicate = new ArrayList<>();
predicateList.add(root.get(QDatRoom.datRoom.status.getMetadata().getName()).in(GenericStatus.ENABLED.getCode()));
predicateList.add(root.get(QDatRoom.datRoom.departmentid.getMetadata().getName()).in(departmentId));
if (null != datRoom) {
if (!StringUtils.isEmpty(datRoom.getName())) {
predicateList.add(criteriaBuilder.like(root.get(QDatRoom.datRoom.name.getMetadata().getName()), "%" + datRoom.getName() + "%"));
}
if (!StringUtils.isEmpty(datRoom.getDepartmentid())) {
predicateList.add(criteriaBuilder.equal(root.get(QDatRoom.datRoom.departmentid.getMetadata().getName()), datRoom.getDepartmentid()));
}
if (!StringUtils.isEmpty(datRoom.getRoomtype())) {
predicateList.add(root.get(QDatRoom.datRoom.type.getMetadata().getName()).in(datRoom.getRoomtype()));
}
if (null != datRoom.getType()) {
predicateList.add(criteriaBuilder.equal(root.get(QDatRoom.datRoom.type.getMetadata().getName()), datRoom.getType()));
}
if (null != datRoom.getFloor()) {
if (Strings.EMPTY.equals(datRoom.getFloor())) {
predicateList.add(root.get(QDatRoom.datRoom.floor.getMetadata().getName()).isNull());
} else {
predicateList.add(criteriaBuilder.like(root.get(QDatRoom.datRoom.floor.getMetadata().getName()), datRoom.getFloor()));
}
}
if (CollectionUtils.isNotEmpty(datRoom.getFloors())) {
predicateList.add(root.get(QDatRoom.datRoom.floor.getMetadata().getName()).in(datRoom.getFloors()));
}
//查询楼层和手术间 k-v的形式判断是否指定类型和指定楼层，如手术间1楼和介入室2楼可同时查不会有多余数据
if (MapUtils.isNotEmpty(datRoom.getTypefloor())) {
List<Predicate> typeFloorList = new ArrayList<>();
//前端约定传值 key不会为空 value可能为空数组
datRoom.getTypefloor().forEach((k, v) -> {
//指定查询类型
typeFloorList.add(criteriaBuilder.equal(root.get(QDatRoom.datRoom.type.getMetadata().getName()), k));
//如果楼层不为空，查询楼层
if (!CollectionUtils.isEmpty(v)) {
//value 可能是空字符串(无楼层--"")
typeFloorList.add(criteriaBuilder.nullif(root.get(QDatRoom.datRoom.floor.getMetadata().getName()), "").in(v));
}
//楼层和类型之间用and连接
orPredicate.add(criteriaBuilder.and(typeFloorList.toArray(new Predicate[typeFloorList.size()])));
typeFloorList.clear();
});
//多个类型之间 用or连接
Predicate current = criteriaBuilder.or(orPredicate.toArray(new Predicate[orPredicate.size()]));
//拼接前文的查询条件 用and连接
Predicate predicate = criteriaBuilder.and(predicateList.toArray(new Predicate[predicateList.size()]));
return criteriaBuilder.and(predicate, current);
}
}
query.orderBy(criteriaBuilder.asc(root.get(QDatRoom.datRoom.indexs.getMetadata().getName())));
Predicate[] p = new Predicate[predicateList.size()];
return criteriaBuilder.and(predicateList.toArray(p));
}
});
}大部分内容来源：牛客网，作者：敲代码的帅哥
原地址链接：JPA 之 QueryDSL-JPA 使用指南_牛客网
扫一扫
393
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
