添加链接 注册    登录
link管理
链接快照平台
  • 输入网页链接，自动生成快照
  • 标签化管理网页链接
相关文章推荐
酒量大的芹菜  ·  【spring boot ...·  2 周前    · 
微醺的墨镜  ·  诗酒故事穿越千年 古窖浓香芬芳岭南 - ...·  3 月前    · 
要出家的移动电源  ·  调查：97%的网络安全公司有数据暴露于暗网 ...·  6 月前    · 
开心的烤土司  ·  婉儿别闹 主题想要 门把手还是麦克风 ...·  8 月前    · 
帅气的蚂蚁  ·  PHP基础知识之————PDO预处理语句 ...·  8 月前    · 
飘逸的饼干  ·  二进制转字符串 - CSDN文库·  9 月前    · 
link管理  ›  spring boot-jpa整合QueryDSL来简化复杂操作_pathmetadatafactory
jpa spring框架
https://blog.csdn.net/xiaoliuliu2050/article/details/79141847
活泼的抽屉
4 月前

使用过spring data jpa的同学，都很清楚，对于复杂的sql查询，处理起来还是比较复杂的，而本文中的QueryDSL就是用来简化JPA操作的。

Querydsl定义了一种常用的静态类型语法，用于在持久域模型数据之上进行查询。JDO和JPA是Querydsl的主要集成技术。本文旨在介绍如何使用Querydsl与JPA组合使用。 JPA的Querydsl是JPQL和Criteria查询的替代方法。QueryDSL仅仅是一个通用的查询框架，专注于通过Java API构建类型安全的SQL查询。

要想使用QueryDSL，需要做两个前提操作：

1、pom文件中，加入依赖

  1. <!--query dsl -->
  2. < dependency >
  3. < groupId > com.querydsl </ groupId >
  4. < artifactId > querydsl-jpa </ artifactId >
  5. </ dependency >
  6. < dependency >
  7. < groupId > com.querydsl </ groupId >
  8. < artifactId > querydsl-apt </ artifactId >
  9. < scope > provided </ scope >
  10. </ dependency >
2、pom文件中，加入编译插件
  1. < plugin >
  2. < groupId > com.mysema.maven </ groupId >
  3. < artifactId > apt-maven-plugin </ artifactId >
  4. < version > 1.1.3 </ version >
  5. < executions >
  6. < execution >
  7. < goals >
  8. < goal > process </ goal >
  9. </ goals >
  10. < configuration >
  11. < outputDirectory > target/generated-sources/java </ outputDirectory >
  12. < processor > com.querydsl.apt.jpa.JPAAnnotationProcessor </ processor >
  13. </ configuration >
  14. </ execution >
  15. </ executions >
  16. </ plugin >
查找使用javax.persistence.Entity注解的域类型，并为它们生成对应的查询类型。下面以User实体类来说明，生成的查询类型如下：
  1. package com.chhliu.springboot.jpa.entity;
  3. import static com.querydsl.core.types.PathMetadataFactory.*;
  5. import com.querydsl.core.types.dsl.*;
  7. import com.querydsl.core.types.PathMetadata;
  8. import javax.annotation.Generated;
  9. import com.querydsl.core.types.Path;
  12. /**
  13. * QUser is a Querydsl query type for User
  14. */
  15. @Generated ( "com.querydsl.codegen.EntitySerializer" )
  16. public class QUser extends EntityPathBase<User> {
  18. private static final long serialVersionUID = 1153899872L;
  20. public static final QUser user = new QUser( "user" );
  22. public final StringPath address = createString( "address" );
  24. public final NumberPath<Integer> age = createNumber( "age" , Integer. class );
  26. public final NumberPath<Integer> id = createNumber( "id" , Integer. class );
  28. public final StringPath name = createString( "name" );
  30. public QUser(String variable) {
  31. super (User. class , forVariable(variable));
  32. }
  34. public QUser(Path<? extends User> path) {
  35. super (path.getType(), path.getMetadata());
  36. }
  38. public QUser(PathMetadata metadata) {
  39. super (User. class , metadata);
  40. }
  42. }
我们建立好实体类之后，然后运行mvn clean complie命令，就会在 [html] view plain
  1. < outputDirectory > target/generated-sources/java </ outputDirectory >
目录下生成对应的查询类型。然后将生成的类都拷贝到项目中，即可。

本文涉及到的Entity如下：

  1. package com.chhliu.springboot.jpa.entity;
  3. import java.io.Serializable;
  5. import javax.persistence.Entity;
  6. import javax.persistence.GeneratedValue;
  7. import javax.persistence.GenerationType;
  8. import javax.persistence.Id;
  9. import javax.persistence.Table;
  11. @Entity
  12. @Table (name= "t_user" )
  13. public class User implements Serializable{
  15. /**
  16. *
  17. */
  18. private static final long serialVersionUID = 1L;
  20. @Id ()
  21. @GeneratedValue (strategy = GenerationType.AUTO)
  22. private int id;
  23. private String name;
  24. private String address;
  25. private int age;
  26. …………省略getter，setter方法…………
  27. /**
  28. * attention:
  29. * Details：方便查看测试结果
  30. * @author chhliu
  31. */
  32. @Override
  33. public String toString() {
  34. return "User [id=" + id + ", name=" + name + ", address=" + address + ", age=" + age + "]" ;
  35. }
  36. }
上面的这个实体类，主要用于单表操作。
  1. package com.chhliu.springboot.jpa.entity;
  3. import javax.persistence.CascadeType;
  4. import javax.persistence.Entity;
  5. import javax.persistence.GeneratedValue;
  6. import javax.persistence.Id;
  7. import javax.persistence.OneToOne;
  8. import javax.persistence.Table;
  10. /**
  11. * 描述：TODO
  12. * @author chhliu
  13. */
  14. @Entity
  15. @Table (name= "PERSON" )
  16. public class Person {
  17. @Id
  18. @GeneratedValue
  19. private Integer id;
  20. private String name;
  21. private String address;
  23. @OneToOne (mappedBy= "person" , cascade={CascadeType.PERSIST, CascadeType.REMOVE, CascadeType.MERGE})
  24. private IDCard idCard;
  26. …………省略getter，setter方法…………
  28. @Override
  29. public String toString() {
  30. return "Person [id=" + id + ", name=" + name + ", address=" + address + ", idCard=" + idCard + "]" ;
  31. }
  32. }
  1. package com.chhliu.springboot.jpa.entity;
  3. import javax.persistence.CascadeType;
  4. import javax.persistence.Entity;
  5. import javax.persistence.FetchType;
  6. import javax.persistence.GeneratedValue;
  7. import javax.persistence.Id;
  8. import javax.persistence.OneToOne;
  9. import javax.persistence.Table;
  11. /**
  12. * 描述：
  13. * @author chhliu
  14. */
  15. @Entity
  16. @Table (name= "IDCARD" )
  17. public class IDCard {
  18. @Id
  19. @GeneratedValue
  20. private Integer id;
  21. private String idNo;
  22. @OneToOne (cascade={CascadeType.MERGE, CascadeType.REMOVE, CascadeType.PERSIST}, fetch=FetchType.EAGER)
  23. private Person person;
  25. …………省略getter，setter方法…………
  27. @Override
  28. public String toString() {
  29. return "IDCard [id=" + id + ", idNo=" + idNo + ", person=" + person + "]" ;
  30. }
  31. }
上面两个Entity主要用于一对一关系的示例操作
  1. package com.chhliu.springboot.jpa.entity;
  3. import java.util.List;
  5. import javax.persistence.CascadeType;
  6. import javax.persistence.Column;
  7. import javax.persistence.Entity;
  8. import javax.persistence.FetchType;
  9. import javax.persistence.GeneratedValue;
  10. import javax.persistence.Id;
  11. import javax.persistence.OneToMany;
  12. import javax.persistence.Table;
  14. /**
  15. * 描述：Order实体类
  16. * @author chhliu
  17. */
  18. @Entity
  19. @Table (name= "ORDER_C" )
  20. public class Order {
  21. @Id
  22. @GeneratedValue
  23. @Column (name= "ID" )
  24. private Integer id;
  26. @Column (length= 20 , name= "ORDER_NAME" )
  27. private String orderName;
  29. @Column (name= "COUNT" )
  30. private Integer count;
  32. @OneToMany (mappedBy = "order" ,cascade={CascadeType.PERSIST,CascadeType.REMOVE},fetch = FetchType.EAGER)
  33. private List<OrderItem> orderItems;
  35. …………省略getter，setter方法…………
  36. }
  1. package com.chhliu.springboot.jpa.entity;
  3. import javax.persistence.CascadeType;
  4. import javax.persistence.Column;
  5. import javax.persistence.Entity;
  6. import javax.persistence.FetchType;
  7. import javax.persistence.GeneratedValue;
  8. import javax.persistence.Id;
  9. import javax.persistence.JoinColumn;
  10. import javax.persistence.ManyToOne;
  11. import javax.persistence.Table;
  13. /**
  14. * 描述：OrderItem实体类
  15. * @author chhliu
  16. */
  17. @Entity
  18. @Table (name= "ORDER_ITEM" )
  19. public class OrderItem {
  20. @Id
  21. @GeneratedValue
  22. @Column (name= "ID" , nullable= false )
  23. private Integer id;
  25. @Column (name= "ITEM_NAME" , length= 20 )
  26. private String itemName;
  28. @Column (name= "PRICE" )
  29. private Integer price;
  31. @ManyToOne (cascade={CascadeType.PERSIST,CascadeType.REMOVE, CascadeType.MERGE}, fetch=FetchType.EAGER)
  32. @JoinColumn (name = "ORDER_ID" )
  33. private Order order;
  35. …………省略getter，setter方法…………
  36. }
上面两个Entity用于展示一对多关系的示例操作。

首先，我们来看单表操作

1、使用spring data jpa

要想使用spring data jpa提供的QueryDSL功能，很简单，直接继承接口即可。Spring Data JPA中提供了QueryDslPredicateExecutor接口,用于支持QueryDSL的查询操作接口，如下：

  1. package com.chhliu.springboot.jpa.repository;
  3. import org.springframework.data.jpa.repository.JpaRepository;
  4. import org.springframework.data.querydsl.QueryDslPredicateExecutor;
  6. import com.chhliu.springboot.jpa.entity.User;
  8. public interface UserRepositoryDls extends JpaRepository<User, Integer>, QueryDslPredicateExecutor<User>{ // 继承<span id="result_box" lang="zh-CN"><span><span id="result_box" lang="zh-CN"><span></span></span></span></span>QueryDslPredicateExecutor<span id="result_box" lang="zh-CN"><span><span id="result_box" lang="zh-CN"></span></span></span>接口
  10. }
QueryDslPredicateExecutor接口提供了如下方法：
  1. public interface QueryDslPredicateExecutor<T> {
  3. T findOne(Predicate predicate);
  5. Iterable<T> findAll(Predicate predicate);
  7. Iterable<T> findAll(Predicate predicate, Sort sort);
  9. Iterable<T> findAll(Predicate predicate, OrderSpecifier<?>... orders);
  11. Iterable<T> findAll(OrderSpecifier<?>... orders);
  13. Page<T> findAll(Predicate predicate, Pageable pageable);
  15. long count(Predicate predicate);
  17. boolean exists(Predicate predicate);
  18. }
以上方法的使用和spring data jpa中的其他接口使用方法类似，详情请参考：

http://blog.csdn.net/liuchuanhong1/article/details/52042477

测试如下：

  1. public User findUserByUserName( final String userName){
  2. /**
  3. * 该例是使用spring data QueryDSL实现
  4. */
  5. QUser quser = QUser.user;
  6. Predicate predicate = quser.name.eq(userName); // 根据用户名，查询user表
  7. return repository.findOne(predicate);
  8. }
对应的sql如下：
  1. select user0_.id as id1_5_, user0_.address as address2_5_, user0_.age as age3_5_, user0_.name as name4_5_ from t_user user0_ where  user0_.name=?
单表操作示例代码如下：
  1. package com.chhliu.springboot.jpa.repository;
  3. import java.util.List;
  5. import javax.persistence.EntityManager;
  6. import javax.persistence.PersistenceContext;
  7. import javax.persistence.Query;
  8. import javax.transaction.Transactional;
  10. import org.springframework.beans.factory.annotation.Autowired;
  11. import org.springframework.data.domain.Page;
  12. import org.springframework.data.domain.PageRequest;
  13. import org.springframework.data.domain.Sort;
  14. import org.springframework.stereotype.Component;
  16. import com.chhliu.springboot.jpa.entity.QUser;
  17. import com.chhliu.springboot.jpa.entity.User;
  18. import com.querydsl.core.types.Predicate;
  19. import com.querydsl.jpa.impl.JPAQueryFactory;
  21. /**
  22. * 描述：QueryDSL JPA
  23. * @author chhliu
  24. */
  25. @Component
  26. @Transactional
  27. public class UserRepositoryManagerDsl {
  28. @Autowired
  29. private UserRepositoryDls repository;
  31. @Autowired
  32. @PersistenceContext
  33. private EntityManager entityManager;
  35. private JPAQueryFactory queryFactory;
  37. @PostConstruct
  38. public void init() {
  39. queryFactory = new JPAQueryFactory(entityManager);
  40. }
  42. public User findUserByUserName( final String userName){
  43. /**
  44. * 该例是使用spring data QueryDSL实现
  45. */
  46. QUser quser = QUser.user;
  47. Predicate predicate = quser.name.eq(userName);
  48. return repository.findOne(predicate);
  49. }
  51. /**
  52. * attention:
  53. * Details：查询user表中的所有记录
  54. */
  55. public List<User> findAll(){
  56. QUser quser = QUser.user;
  57. return queryFactory.selectFrom(quser)
  58. .fetch();
  59. }
  61. /**
  62. * Details：单条件查询
  63. */
  64. public User findOneByUserName( final String userName){
  65. QUser quser = QUser.user;
  66. return queryFactory.selectFrom(quser)
  67. .where(quser.name.eq(userName))
  68. .fetchOne();
  69. }
  71. /**
  72. * Details：单表多条件查询
  73. */
  74. public User findOneByUserNameAndAddress( final String userName, final String address){
  75. QUser quser = QUser.user;
  76. return queryFactory.select(quser)
  77. .from(quser) // 上面两句代码等价与selectFrom
  78. .where(quser.name.eq(userName).and(quser.address.eq(address))) // 这句代码等同于where(quser.name.eq(userName), quser.address.eq(address))
  79. .fetchOne();
  80. }
  82. /**
  83. * Details：使用join查询
  84. */
  85. public List<User> findUsersByJoin(){
  86. QUser quser = QUser.user;
  87. QUser userName = new QUser( "name" );
  88. return queryFactory.selectFrom(quser)
  89. .innerJoin(quser)
  90. .on(quser.id.intValue().eq(userName.id.intValue()))
  91. .fetch();
  92. }
  94. /**
  95. * Details：将查询结果排序
  96. */
  97. public List<User> findUserAndOrder(){
  98. QUser quser = QUser.user;
  99. return queryFactory.selectFrom(quser)
  100. .orderBy(quser.id.desc())
  101. .fetch();
  102. }
  104. /**
  105. * Details：Group By使用
  106. */
  107. public List<String> findUserByGroup(){
  108. QUser quser = QUser.user;
  109. return queryFactory.select(quser.name)
  110. .from(quser)
  111. .groupBy(quser.name)
  112. .fetch();
  113. }
  115. /**
  116. * Details：删除用户
  117. */
  118. public long deleteUser(String userName){
  119. QUser quser = QUser.user;
  120. return queryFactory.delete(quser).where(quser.name.eq(userName)).execute();
  121. }
  123. /**
  124. * Details：更新记录
  125. */
  126. public long updateUser( final User u, final String userName){
  127. QUser quser = QUser.user;
  128. return queryFactory.update(quser).where(quser.name.eq(userName))
  129. .set(quser.name, u.getName())
  130. .set(quser.age, u.getAge())
  131. .set(quser.address, u.getAddress())
  132. .execute();
  133. }
  135. /**
  136. * Details：使用原生Query
  137. */
  138. public User findOneUserByOriginalSql( final String userName){
  139. QUser quser = QUser.user;
  140. Query query = queryFactory.selectFrom(quser)
  141. .where(quser.name.eq(userName)).createQuery();
  142. return (User) query.getSingleResult();
  143. }
  145. /**
  146. * Details：分页查询单表
  147. */
  148. public Page<User> findAllAndPager( final int offset, final int pageSize){
  149. Predicate predicate = QUser.user.id.lt( 10 );
  150. Sort sort = new Sort( new Sort.Order(Sort.Direction.DESC, "id" ));
  151. PageRequest pr = new PageRequest(offset, pageSize, sort);
  152. return repository.findAll(predicate, pr);
  153. }
  154. }
多表操作示例(一对一)如下：
  1. package com.chhliu.springboot.jpa.repository;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. import javax.annotation.PostConstruct;
  7. import javax.persistence.EntityManager;
  8. import javax.persistence.PersistenceContext;
  10. import org.springframework.beans.factory.annotation.Autowired;
  11. import org.springframework.stereotype.Component;
  13. import com.chhliu.springboot.jpa.dto.PersonIDCardDto;
  14. import com.chhliu.springboot.jpa.entity.QIDCard;
  15. import com.chhliu.springboot.jpa.entity.QPerson;
  16. import com.querydsl.core.QueryResults;
  17. import com.querydsl.core.Tuple;
  18. import com.querydsl.core.types.Predicate;
  19. import com.querydsl.jpa.impl.JPAQuery;
  20. import com.querydsl.jpa.impl.JPAQueryFactory;
  22. @Component
  23. public class PersonAndIDCardManager {
  24. @Autowired
  25. @PersistenceContext
  26. private EntityManager entityManager;
  28. private JPAQueryFactory queryFactory;
  30. @PostConstruct
  31. public void init() {
  32. queryFactory = new JPAQueryFactory(entityManager);
  33. }
  35. /**
  36. * Details：多表动态查询
  37. */
  38. public List<Tuple> findAllPersonAndIdCard(){
  39. Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
  40. JPAQuery<Tuple> jpaQuery = queryFactory.select(QIDCard.iDCard.idNo, QPerson.person.address, QPerson.person.name)
  41. .from(QIDCard.iDCard, QPerson.person)
  42. .where(predicate);
  43. return jpaQuery.fetch();
  44. }
  46. /**
  47. * Details：将查询结果以DTO的方式输出
  48. */
  49. public List<PersonIDCardDto> findByDTO(){
  50. Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
  51. JPAQuery<Tuple> jpaQuery = queryFactory.select(QIDCard.iDCard.idNo, QPerson.person.address, QPerson.person.name)
  52. .from(QIDCard.iDCard, QPerson.person)
  53. .where(predicate);
  54. List<Tuple> tuples = jpaQuery.fetch();
  55. List<PersonIDCardDto> dtos = new ArrayList<PersonIDCardDto>();
  56. if ( null != tuples && !tuples.isEmpty()){
  57. for (Tuple tuple:tuples){
  58. String address = tuple.get(QPerson.person.address);
  59. String name = tuple.get(QPerson.person.name);
  60. String idCard = tuple.get(QIDCard.iDCard.idNo);
  61. PersonIDCardDto dto = new PersonIDCardDto();
  62. dto.setAddress(address);
  63. dto.setIdNo(idCard);
  64. dto.setName(name);
  65. dtos.add(dto);
  66. }
  67. }
  68. return dtos;
  69. }
  71. /**
  72. * Details：多表动态查询，并分页
  73. */
  74. public QueryResults<Tuple> findByDtoAndPager( int offset, int pageSize){
  75. Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
  76. return queryFactory.select(QIDCard.iDCard.idNo, QPerson.person.address, QPerson.person.name)
  77. .from(QIDCard.iDCard, QPerson.person)
  78. .where(predicate)
  79. .offset(offset)
  80. .limit(pageSize)
  81. .fetchResults();
  82. }
  83. }

上面将查询结果以DTO的方式输出的示例中，在查询结束后，将查询结果手动的转换成了DTO对象，这种方式其实不太优雅，QueryDSL给我们提供了更好的方式，见下面的示例：

  1. /**
  2. * Details：方式一：使用Bean投影
  3. */
  4. public List<PersonIDCardDto> findByDTOUseBean(){
  5. Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
  6. return queryFactory.select(
  7. Projections.bean(PersonIDCardDto. class , QIDCard.iDCard.idNo, QPerson.person.address, QPerson.person.name))
  8. .from(QIDCard.iDCard, QPerson.person)
  9. .where(predicate)
  10. .fetch();
  11. }
  13. /**
  14. * Details：方式二：使用fields来代替setter
  15. */
  16. public List<PersonIDCardDto> findByDTOUseFields(){
  17. Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
  18. return queryFactory.select(
  19. Projections.fields(PersonIDCardDto. class , QIDCard.iDCard.idNo, QPerson.person.address, QPerson.person.name))
  20. .from(QIDCard.iDCard, QPerson.person)
  21. .where(predicate)
  22. .fetch();
  23. }
  25. /**
  26. * Details：方式三：使用构造方法，注意构造方法中属性的顺序必须和构造器中的顺序一致
  27. */
  28. public List<PersonIDCardDto> findByDTOUseConstructor(){
  29. Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
  30. return queryFactory.select(
  31. Projections.constructor(PersonIDCardDto. class , QPerson.person.name, QPerson.person.address, QIDCard.iDCard.idNo))
  32. .from(QIDCard.iDCard, QPerson.person)
  33. .where(predicate)
  34. .fetch();
  35. }
上面只是提供了几种思路，当然，还可以使用@QueryProjection来实现，非常灵活。 一对多示例：
  1. package com.chhliu.springboot.jpa.repository;
  3. import java.util.List;
  5. import javax.annotation.PostConstruct;
  6. import javax.persistence.EntityManager;
  7. import javax.persistence.PersistenceContext;
  9. import org.springframework.beans.factory.annotation.Autowired;
  10. import org.springframework.stereotype.Component;
  12. import com.chhliu.springboot.jpa.entity.QOrder;
  13. import com.chhliu.springboot.jpa.entity.QOrderItem;
  14. import com.querydsl.core.Tuple;
  15. import com.querydsl.core.types.Predicate;
  16. import com.querydsl.jpa.impl.JPAQuery;
  17. import com.querydsl.jpa.impl.JPAQueryFactory;
  19. @Component
  20. public class OrderAndOrderItemManager {
  22. @Autowired
  23. @PersistenceContext
  24. private EntityManager entityManager;
  26. private JPAQueryFactory queryFactory;
  28. @PostConstruct
  29. public void init() {
  30. queryFactory = new JPAQueryFactory(entityManager);
  31. }
  33. /**
  34. * Details：一对多，条件查询
  35. */
  36. public List<Tuple> findOrderAndOrderItemByOrderName(String orderName){
  37. //添加查询条件
  38. Predicate predicate = QOrder.order.orderName.eq(orderName);
  39. JPAQuery<Tuple> jpaQuery = queryFactory.select(QOrder.order, QOrderItem.orderItem)
  40. .from(QOrder.order, QOrderItem.orderItem)
  41. .where(QOrderItem.orderItem.order.id.intValue().eq(QOrder.order.id.intValue()), predicate);
  43. //拿到结果
  44. return jpaQuery.fetch();
  45. }
  47. /**
  48. * Details：多表连接查询
  49. */
  50. public List<Tuple> findAllByOrderName(String orderName){
  51. //添加查询条件
  52. Predicate predicate = QOrder.order.orderName.eq(orderName);
  53. JPAQuery<Tuple> jpaQuery = queryFactory.select(QOrder.order, QOrderItem.orderItem)
  54. .from(QOrder.order, QOrderItem.orderItem)
  55. .rightJoin(QOrder.order)
  56. .on(QOrderItem.orderItem.order.id.intValue().eq(QOrder.order.id.intValue()));
  57. jpaQuery.where(predicate);
  58. //拿到结果
  59. return jpaQuery.fetch();
  60. }
  61. }

从上面的示例中，我们可以看出，QueryDSL大大的简化了我们的操作

原文链接:http://www.jianshu.com/p/2b68af9aa0f5 (支持原创) 1.问题的提出 最近再看公司项目中有如下代码,看了后简直不能忍.缺点列出来的话,如下: 返回类型Object[]数组,至于每一个下标对应哪个字段,没法直观的看到,例如object[11]是什么类型?字段名是什么?这个就无法直观得知.sql中 复杂 的关系导致不可维护,每一个接手的人都要研究sq
private final BaseDao dao; private final JPA Query Factory factory ; private final QUser qUser; private final QFile qFile; @Autowired public UserServiceImpl(BaseDao dao) { this...
SpirngData- JPA QueryDSL 快速入门 不可否认的是 JPA 使用是非常方便的，极 简化 的配置，只需要使用注解，无需任何 xml 的配置文件，语义简单易懂，但是，以上的一切都建立在单表查询的前提下的，我们可以使用 JPA 默认提供的方法，简单加轻松的完成 CRUD 操作 。 但是如果涉及到多表动态查询， JPA 的功能就显得有些捉襟见肘了，虽然我们可以使用注解 @Query ，在这个注解中写 SQL 或者 HQL 都是在拼接字符串，并且拼接后的字符串可读性非常的差，当然 JPA 还为我们提供了
QueryDSL 仅仅是一个通用的查询框架，专注于通过Java API构建类型安全的SQL查询。 Querydsl 可以通过一组通用的查询API为用户构建出适合不同类型ORM框架或者是SQL的查询语句，也就是说 QueryDSL 是基于各种ORM框架以及SQL之上的一个通用的查询框架。 借助 QueryDSL 可以在任何支持的ORM框架或者SQL平台上以一种通用的API方式来构建查询。目前 QueryDSL 支持的平台包括 JPA ，JDO，SQL，Java Collections，Mongodb，L
querydsl 是个不错sql动态生成拼装工具，网上很多方法都是类似hibernate或mybatis类的orm 操作 ，这里直接用它的动态生成方式，直接引入core包就行 Map<String,SQLTemplates> sqlTemplatesMap = new LinkedHashMap<>(); sqlTemplatesMap.put("mysql", ...
scoratesc: 讲的有点乱哦 刚开始讲，修改配置文件 /etc/default/docker 或者 /etc/sysconfig/docker 新增DOCKER_OPTS="-H 0.0.0.0:5555" 下面具体讲例子时，又说修改 -H fd://，可修改为：-H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock -H fd:// --label name=server_1 但是怎么修改却没讲 8 Docker Remote API 吃蘑菇的小龙虾: 图片都没啦 网络学习 tcpdump 抓包工具 CSDN-Ada助手: 哇, 你的文章质量真不错，值得学习！不过这么高质量的文章, 还值得进一步提升, 以下的改进点你可以参考下: (1)增加条理清晰的目录；(2)使用标准目录。
 
推荐文章
酒量大的芹菜  ·  【spring boot 系列】Spring boot 集成 redis — 云码
2 周前
微醺的墨镜  ·  诗酒故事穿越千年 古窖浓香芬芳岭南 - 广州市人民政府门户网站
3 月前
要出家的移动电源  ·  调查：97%的网络安全公司有数据暴露于暗网 - 安全内参 | 决策者的网络安全知识库
6 月前
开心的烤土司  ·  婉儿别闹 主题想要 门把手还是麦克风 吮吸噗呲2024.1.3_哔哩哔哩_bilibili
8 月前
帅气的蚂蚁  ·  PHP基础知识之————PDO预处理语句 - Tinywan - 博客园
8 月前
飘逸的饼干  ·  二进制转字符串 - CSDN文库
9 月前
Link管理   ·   51好读   ·   Sov5搜索   ·   小百科
link管理 - 链接快照平台