JPA 之 QueryDSL-JPA 使用指南

// 慎用！qdsl-jpa底层是调用random()函数，MySQL没有该函数，只有rand()函数，会报错，解决方案为使用QDSL-SQL查询NumberExpression random() // 返回０到１内的随机值NumberExpression random(int seed) // 返回一个指定的０到１内的随机值123456789

表达式方法注意：在select()中查询出的结果使用表达式方法处理过后，若要封装到实体类中，则都需要使用 .as(alias) 起别名指定封装到实体类中的哪个字段。

SimpleExpression 简单表达式 extends DslExpression extends Expression

// 给查询字段取别名T as(alias)

BooleanExpression eq(T right) // 等于 equalBooleanExpression eqAll(T... right)BooleanExpression eqAny(T... right)BooleanExpression ne(T right) // 不等于 not equalBooleanExpression neAll(T... right)BooleanExpression neAny(T... right)

BooleanExpression in(T... right)BooleanExpression notIn(T... right)

BooleanExpression isNotNull()BooleanExpression isNull()

// 相当于java中的switch语句。两种写法T when(A).then(B).otherwise(C)

// 该字段的查询结果等于参数则返回null，不等于则返回查询结果。Field == A ? null : FieldSimpleExpression nullif(A)

// 符合过滤条件的的总条数。 select count(table.id) from tableNumberExpression count()

123456789101112131415161718192021222324ComparableExpressionBase extends SimpleExpression

// 设置默认值。返回 Field, A, B ... 顺序中第一个非null的值，若都为null则返回null// 注意：使用该方法兜底Oracle数据库的null为空字符串时会失效，因为Oracle会把空字符串当作nullT coalesce(A, B ...)123NumberExpression 数值表达式 extends ComparableExpressionBase

NumberExpression add(A) // 加

NumberExpression subtract(A) // 减

NumberExpression multiply(A) // 乘

NumberExpression divide(A) // 除

NumberExpression mod(A) // 返回余数

NumberExpression floor() // 向下取整NumberExpression ceil() // 向上取整NumberExpression round() // 四舍五入取整

NumberExpression max() // 返回指定数值列的最大值NumberExpression min() // 返回指定数值列的最小值NumberExpression sqrt() // 返回指定数值列的平方根

NumberExpression sum() // 返回指定数值列（或分组相同数值列）的总数NumberExpression avg() // 返回指定数值列（或分组相同数值列）的平均数

NumberExpression abs() // 返回指定数值列的绝对值NumberExpression negate() // 返回指定数值列的相反数

StringExpression stringValue() // 返回字符串表达式

123456789101112131415161718192021222324ComparableExpression extends ComparableExpressionBase

BooleanExpression lt(T right) // 小于 less thanBooleanExpression ltAll(T... right)BooleanExpression ltAny(T... right)BooleanExpression gt(T right) // 大于 greater thanBooleanExpression gtAll(T... right)BooleanExpression gtAny(T... right)

BooleanExpression loe(T right) // 小于等于 less than or equalBooleanExpression loeAll(T... right)BooleanExpression loeAny(T... right)BooleanExpression goe(T right) // 大于等于 greater than or equalBooleanExpression goeAll(T... right)BooleanExpression goeAny(T... right)

BooleanExpression between(from, to) // from和to之间 [from, to]BooleanExpression notBetween(from, to)

12345678910111213141516BooleanExpression 布尔表达式 extends LiteralExpression (extends ComparableExpression) implements Predicate

BooleanExpression isTrue() // 计算结果若为true，则返回名为eqTrue的Predicate，否则返回名为eqFalse的PredicateBooleanExpression isFalse() // 计算结果若为false，则返回名为eqTrue的Predicate，否则返回名为eqFalse的PredicateBooleanExpression not() // 返回相反的结果

BooleanExpression eq(Boolean right)

BooleanExpression and(Predicate right)BooleanExpression andAnyOf(Predicate... predicates)BooleanExpression or(Predicate right)BooleanExpression orAllOf(Predicate... predicates)12345678910StringExpressions 字符串表达式 extends LiteralExpression extends ComparableExpression

StringExpression contains(String str) // 包含参数字符串

BooleanExpression isEmpty() // 判断是否为空BooleanExpression isNotEmpty()

// 正则匹配查询BooleanExpression matches(Expression regex)// 模糊查询。% 为通配符，_ 表一个字符，可以传参escape指定转义字符BooleanExpression like(String str)BooleanExpression like(String str, char escape)BooleanExpression endsWith(str) // 判断字符串的后缀是否为str。注意：必须使用boolean数据类型的字段接收BooleanExpression startsWith(str) // 判断字符串的前缀是否为str。注意：必须使用boolean数据类型的字段接收

// 将字母转换大小写StringExpression toLowerCase()StringExpression toUpperCase()StringExpression lower()StringExpression upper()

StringExpression trim() // 去掉字符串两端的空格StringExpression substring(int beginIndex) // 截取子字符串从索引位置至末尾StringExpression concat(str) // 拼接 strStringExpression append(str) // 在末尾添加 strStringExpression prepend(str) // 在前面添加 str

NumberExpression length() // 返回字符串长度NumberExpression locate(str) // 返回 str 的位置（从1开始），没有返回0NumberExpression indexOf(str) // 返回 str 索引（从0开始），没有返回-1SimpleExpression charAt(int i) // 返回参数索引位置的字符。实体类接收字段需为char或CharacterSS

1234567891011121314151617181920212223242526272829

select() 和 fetch() 的常用写法注意：使用fetch()查询时，数据库没有符合该条件的数据时，返回的是空集合，而不是null。

QMemberDomain qm = QMemberDomain.memberDomain;//查询字段-select()List nameList = queryFactory.select(qm.name).from(qm).fetch();

//查询实体-selectFrom()List memberList = queryFactory.selectFrom(qm).fetch();

//查询并将结果封装至dto中List dtoList = queryFactory.select(Projections.bean(MemberFavoriteDto.class,qm.name,qf.favoriteStoreCode)).from(qm).leftJoin(qm.favoriteInfoDomains, qf).fetch();

//去重查询-selectDistinct()List distinctNameList = queryFactory.selectDistinct(qm.name).from(qm).fetch();

//获取首个查询结果-fetchFirst()MemberDomain firstMember = queryFactory.selectFrom(qm).fetchFirst();

//获取唯一查询结果-fetchOne()//当fetchOne()根据查询条件从数据库中查询到多条匹配数据时，会抛NonUniqueResultException。MemberDomain anotherFirstMember = queryFactory.selectFrom(qm).fetchOne();

1234567891011121314151617181920212223242526272829303132333435363738

where 子句查询条件的常用写法//查询条件示例List 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();1234567891011使用QueryDSL提供的BooleanBuilder来进行查询条件管理。

BooleanBuilder builder = new BooleanBuilder();// likebuilder.and(qm.name.like('%'+"Jack"+'%'));// containbuilder.and(qm.address.contains("厦门"));// equal示例builder.and(qm.status.eq("0013"));// betweenbuilder.and(qm.age.between(20, 30));List memberConditionList = queryFactory.selectFrom(qm).where(builder).fetch();

// 复杂的查询关系BooleanBuilder builder2 = new BooleanBuilder();builder2.or(qm.status.eq("0013"));builder2.or(qm.status.eq("0014"));builder.and(builder2);List memberConditionList = queryFactory.selectFrom(qm).where(builder2).fetch();

123456789101112131415161718

自定义封装查询的结果集方法一：使用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();123456789底层原理：

使用数据封装类的无参构造方法创建对象（如果类上有使用@Builder注解导致@Data无参构造方法被覆盖，则会报错，可以再加上 @AllArgsConstructor，@NoArgsConstructor 注解）使用setter方法封装数据给字段（会校验数据封装字段和Entity对应字段的数据类型是否一致，不一致则会报错）常见问题：

Entity中时间字段的数据类型为 java.util.Date，数据封装类中时间字段的数据类型为 java.sql.Date 或具有指定时间格式的String类型，数据类型不一致，导致数据无法封装成功方案1：修改数据封装类或Entity中时间的数据类型，使其类型一致方案2：数据封装类中新增util.Date类型字段，手动重写其setter方法，处理数据后赋值到原sql.Date类型字段上。注意：查询封装数据到字段时 as(“新增的util.Date字段”)方案3：数据封装类中新增util.Date类型字段，先将数据封装到该字段，再通过getter、setter方法处理数据后赋值到原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();123456789

方法三：使用Projections的constructor方法，注意构造方法中参数的顺序

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

方式四：使用集合的stream转换

从方法开始到fetch()结束完全跟QueryDSL没有任何区别，采用了最原始的方式进行返回结果集，但是从fetch()获取到结果集后处理的方式就有所改变了。

fetch()方法返回的类型是泛型List（List），List继承了Collection，完全存在使用Collection内非私有方法的权限，通过调用stream方法可以将集合转换成Stream泛型对象，该对象的map方法可以操作集合内单个对象的转换，具体的转换代码可以根据业务逻辑进行编写。

在map方法内有个lambda表达式参数tuple，通过tuple对象get方法就可以获取对应select方法内的查询字段。

注意：tuple只能获取select内存在的字段，如果select内为一个实体对象，tuple无法获取指定字段的值。

/**

* 使用java8新特性Collection内stream方法转换dto

*/

public List 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

.collect(Collectors.toList());

}

12345678910111213141516171819202122232425262728293031323334353637

排序、分页排序

.asc() // 升序.desc() // 降序.asc().nullsFirst() // 升序，空值放前面.asc().nullsLast() // 降序，空值放前面1234//排序List orderList = queryFactory.selectFrom(qm).orderBy(qm.name.asc()).fetch();1234

分页

.limit(long limit) // 限制查询结果返回的数量。即一页多少条记录（pageSize）.offset(long offset) // 跳过多少行。offset = ( pageNum - 1 ) * pageSize // pageNum：第几页12QMemberDomain qm = QMemberDomain.memberDomain;//写法一JPAQuery query = queryFactory.selectFrom(qm).orderBy(qm.age.asc());// 查询总条数。fetchCount时，orderBy不会被执行long total = query.fetchCount();// 获取过滤后的查询结果集List list0= query.offset(2).limit(5).fetch();

//写法二。fetchResults()自动实现count查询和结果查询，并封装到QueryResults中

QueryResults results = queryFactory

.selectFrom(qm)

.orderBy(qm.age.asc())

.offset(2)

.limit(5)

.fetchResults();

List list = results.getResults(); // 过滤后的查询结果集

logger.debug("total:"+results.getTotal()); // 符合过滤条件的的总条数

logger.debug("offset:"+results.getOffset()); // 跳过多少条符合过滤条件的查询结果

logger.debug("limit:"+results.getLimit()); // 限制查询结果返回的条数

123456789101112131415161718192021写法一和二都会发出两条sql进行查询，一条查询count，一条查询具体数据。

写法二的getTotal()等价于写法一的fetchCount。

无论是哪种写法，在查询count的时候，orderBy、limit、offset这三个都不会被执行。可以大胆使用。

子查询// 子查询作为where条件内容@Testpublic void selectJPAExpressions() {List 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 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();}

1234567891011121314151617181920212223242526272829303132333435363738394041

联表动态查询// JPA查询工厂@Autowiredprivate JPAQueryFactory queryFactory;

/**

* 关联查询示例，查询出城市和对应的旅店

*/

@Test

public void findCityAndHotel() {

QTCity qtCity = QTCity.tCity;

QTHotel qtHotel = QTHotel.tHotel;

JPAQuery jpaQuery = queryFactory

.select(qtCity, qtHotel)

.from(qtCity)

.leftJoin(qtHotel)

.on(qtHotel.city.longValue().eq(qtCity.id.longValue()));

// 分离式 添加查询条件

jpaQuery.where(QTCity.tCity.name.like("shanghai"));

// 获取查询结果

List result = jpaQuery.fetch();

// 对多元组取出数据，这个和select时的数据相匹配

for (Tuple row : result) {

System.out.println("qtCity:" + row.get(qtCity));

System.out.println("qtHotel:" + row.get(qtHotel));

System.out.println("--------------------");

}

}

12345678910111213141516171819202122232425262728293031

联表一对多查询封装方式一：查询结果返回类型为List

List 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"))));

1234567891011121314151617

方式二：查询结果返回类型为Map

map的key为分组字段，一般为主键ID

Map 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"))));

12345678910111213141516

实体类：

@Data@Builder@AllArgsConstructor@NoArgsConstructorpublic class UserAddressDTO {

private Integer id;

private String username;

private String password;

private String phone;

private List userAddresses;

}12345678910111213

使用聚合函数//聚合函数-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()String date = queryFactory.select(Expressions.stringTemplate("DATE_FORMAT({0},'%Y-%m-%d')",qm.registerDate)).from(qm).fetchOne();

12345678910111213141516171819当用到DATE_FORMAT这类QueryDSL似乎没有提供支持的Mysql函数时，可以手动拼一个String表达式。这样就可以无缝使用Mysql中的函数了。

使用 Template 实现自定义语法QueryDSL并没有对数据库的所有函数提供支持，好在它提供了Template特性。

可以使用Template来实现各种QueryDSL未直接支持的语法。

Template的局限性：

由于Template中使用了{}来作为占位符（内部序号从0开始），而正则表达式中也可能使用了{}，因而会产生冲突。

QMemberDomain qm = QMemberDomain.memberDomain;

//使用booleanTemplate充当where子句或where子句的一部分List list = queryFactory.selectFrom(qm).where(Expressions.booleanTemplate("{0} = "tofu"", qm.name)).fetch();

//上面的写法，当booleanTemplate中需要用到多个占位时List 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子句中使用stringTemplateString id = queryFactory.select(qm.id).from(qm).where(Expressions.stringTemplate("DATE_FORMAT({0},'%Y-%m-%d')",qm.registerDate).eq("2018-03-19")).fetchFirst();

123456789101112131415161718192021222324252627282930313233

QueryDslPredicateExecutor 风格通常使用Repository来继承QueryDslPredicateExecutor接口。通过注入Repository来使用。

Repository 接口

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

public interface tityRepository extends JpaRepository, QuerydslPredicateExecutor {}1

QueryDslPredicateExecutor接口提供了findOne()，findAll()，count()，exists()四个方法来支持查询。并可以使用更优雅的BooleanBuilder 来进行条件分支管理。

count()会返回满足查询条件的数据行的数量exists()会根据所要查询的数据是否存在返回一个boolean值

findOne()、findAll()findOne

从数据库中查出一条数据。没有重载方法。

Optional findOne(Predicate var1);1和JPAQuery的fetchOne()一样，当根据查询条件从数据库中查询到多条匹配数据时，会抛NonUniqueResultException。使用的时候需要慎重。

findAll()

findAll是从数据库中查出匹配的所有数据。提供了以下几个重载方法。

Iterable findAll(Predicate var1);

Iterable findAll(Predicate var1, Sort var2);

Iterable findAll(Predicate var1, OrderSpecifier... var2);

Iterable findAll(OrderSpecifier... var1);

Page findAll(Predicate var1, Pageable var2);123456789使用示例：

QMemberDomain qm = QMemberDomain.memberDomain;// QueryDSL 提供的排序实现OrderSpecifier order = new OrderSpecifier<>(Order.DESC, qm.age);Iterable iterable = memberRepo.findAll(qm.status.eq("0013"),order);

QMemberDomain qm = QMemberDomain.memberDomain;// Spring Data 提供的排序实现Sort sort = new Sort(new Sort.Order(Sort.Direction.ASC, "age"));Iterable iterable = memberRepo.findAll(qm.status.eq("0013"), sort);123456789

单表动态分页查询单表动态查询示例：

//动态条件QTCity qtCity = QTCity.tCity; //SDL实体类//该Predicate为querydsl下的类,支持嵌套组装复杂查询条件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);//查找结果Page tCityPage = tCityRepository.findAll(predicate, pageRequest);123456789

Querydsl SQL 查询Querydsl SQL 模块提供与 JDBC API 的集成。可以使用更多的 JDBC SQL方法。比如可以实现 from 的查询主体为子查询出来的临时表、union、union All 等Querydsl-JPA限制的相关操作。还可以根据 JDBC API 获取数据库的类型使用不同的数据库语法模板。

依赖及配置依赖：

com.querydsl

querydsl-sql

${querydsl.version}

joda-time

joda-time

2.10.5

1234567891011yaml配置：

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

SQLQuery 的 Q 类需要自己创建编写（可以基于apt 插件生成的 JPA 的Q类改造），并放到主目录（src）启动类下的包里。

使用 extends RelationalPathBase 的Q类。推荐

需要将数据库表名传入构造方法的table参数里，path 可以传别名，所有的property参数为实体类的属性名（驼峰命名），addMetadata() 中ColumnMetadata.named("FeildNmae") 的 FeildNmae 为数据库字段名。

使用该Q类查询所有字段数据时（即select(Q类)）可以自动映射封装结果集。

使用extends EntityPathBase的Q类。

需要将传入构造方法的variable参数改成数据库表名，并且将所有的property参数改成相对应的数据库字段名。

**注意：**使用 extends EntityPathBase 的实体Q类，直接 select(Q类) 会报错，无法自动映射封装结果集，需要使用Projections.bean(Entity.class，Expression... exprs) 手动封装结果集。

/**

extends RelationalPathBase 的Q类示例*/public class QEmployee extends RelationalPathBase {private static final long serialVersionUID = 1394463749655231079L;public static final QEmployee employee = new QEmployee("EMPLOYEE");public final NumberPath id = createNumber("id", Integer.class);public final StringPath firstname = createString("firstname");public final DatePath datefield = createDate("datefield", java.util.Date.class);public final PrimaryKey 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));}}123456789101112131415161718192021222324252627282930313233/**

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

SQLQueryFactory 方式装配及基本使用装配

@Configuration@Slf4jpublic 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)){// 若非事务连接SQLCloseListener.DEFAULT.end(context);}}});configuration.setExceptionTranslator(new SpringExceptionTranslator());// 创建SQLQueryFactory，且数据库连接由spring管理return new SQLQueryFactory(configuration, () -> DataSourceUtils.getConnection(druidDataSource));}}

123456789101112131415161718192021222324252627注入

@Autowired

private SQLQueryFactory sqlQueryFactory;

12SQLQueryFactory 基本使用

/**

* 子查询作为临时表传入from()中

*/

@Test

public void selectBySqlQueryFactory(){

// 使用 extends RelationalPathBase 的QEntity，自动映射封装

QUserAddressSql uaSql = QUserAddressSql.userAddress;

// 子查询

SQLQuery q = SQLExpressions

.select(

// 查询字段须是数据库表中的字段名（不是实体属性名），且类型一致

uaSql.addressee

, uaSql.userId

)

.from(uaSql);

List 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);

}

/**

* 子查询结果集 union

*/

@Test

public void selectBySqlQueryFactory(){

// 使用 extends EntityPathBase 的改造版QEntity，结果集如需封装到实体类，必须手动指定实体类来接收

QUserAddressSql uaSql = QUserAddressSql.userAddress;

QUserSql uSql = QUserSql.user;

SQLQuery a = SQLExpressions

.select(uaSql.userId.as("user_id") , uaSql.phone)

.from(uaSql)

.where(uaSql.userId.eq(30));

SQLQuery b = SQLExpressions

.select(uSql.id.as("user_id") , uSql.phone)

.from(uSql)

.where(uSql.id.eq(29).or(uSql.id.eq(30)));

Union union = sqlQueryFactory.query().union(a, b);

long count = sqlQueryFactory

.from(union, Expressions.stringPath("q")).fetchCount();

List 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)));

}

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970

SQLExpression 表达式工具类// 合并多张表记录。union为去重合并，unionAll为不去重合并static Union union(SubQueryExpression... sq)static Union union(List> sq)static Union unionAll(SubQueryExpression... sq)static Union unionAll(List> sq)

// 调用函数查询序列static SimpleExpression nextval(String sequence)static SimpleExpression nextval(Class type, String sequence)// 使用示例：SQL写法：select seq_process_no.nextval from dual;Long nextvalReturn = sqlQueryFactory.select(SQLExpressions.nextval("序列名")).fetchOne;

// 将多列记录聚合为一列记录。delimiter为分隔符。Oracle数据库专属，其他数据库报错static WithinGroup