Spring JPA整合QueryDSL

爱被打了一巴掌 2023-05-31 12:14 62阅读 0赞

# 前言 #

`Spring JPA`是目前比较常用的`ORM`解决方案，但是其对于某些场景并不是特别的方便，例如查询部分字段，联表查询，子查询等。

而接下来我会介绍与`JPA`形成互补，同时也是与`JPA`兼容得很好的框架`QueryDSL`。

同时由于目前主流使用`Spring Boot`，所以本文也会基于`Spring Boot`来进行演示

如果对于长文无感，但是又希望了解`QueryDSL`可以直接查看文章最后的总结

# 环境信息 #

以下为示例的关键环境信息

1.  `JDK 1.8`
2.  `maven 3.6.1`
3.  `SpringBoot 2.2.0.RELEASE`
4.  `IntelliJ IDEA 2019.2.3`
5.  `lombok`
6.  `mysql-5.7`

# 源码地址 #

https://github.com/spring-based-solutions/querydsl-jpa-demo

# 项目整合 #

## pom文件配置 ##

`QueryDSL`本身定位就是对某些技术的补充或者说是完善，其提供了对`JPA`、`JDBC`、`JDO`等技术的支持。这里引入的是`QueryDSL-JPA`，需要注意一定要引入querydsl代码生成器插件。

<properties>
            <java.version>1.8</java.version>
            <querydsl.version>4.2.1</querydsl.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-jpa</artifactId>
            </dependency>
            
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.48</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-configuration-processor</artifactId>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
                <exclusions>
                    <exclusion>
                        <groupId>org.junit.vintage</groupId>
                        <artifactId>junit-vintage-engine</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
    
            
            <dependency>
                <groupId>com.querydsl</groupId>
                <artifactId>querydsl-jpa</artifactId>
                <version>${querydsl.version}</version>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
                
                <plugin>
                    <groupId>com.mysema.maven</groupId>
                    <artifactId>apt-maven-plugin</artifactId>
                    <version>1.1.3</version>
                    <dependencies>
                        <dependency>
                            <groupId>com.querydsl</groupId>
                            <artifactId>querydsl-apt</artifactId>
                            <version>${querydsl.version}</version>
                        </dependency>
                    </dependencies>
                    <executions>
                        
                        <execution>
                            <goals>
                                <goal>process</goal>
                            </goals>
                            <configuration>
                                
                               <outputDirectory>src/generated-sources/java/</outputDirectory>
                                <processor>com.querydsl.apt.jpa.JPAAnnotationProcessor</processor>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>

## application配置文件 ##

spring:
      datasource:
        ## 数据库相关配置
        url: jdbc:mysql://127.0.0.1:3306/example?useSSL=false
        username: root
        password: root
        driver-class-name: com.mysql.jdbc.Driver # 指定驱动类
      jpa:
        hibernate:
          ddl-auto: update # 自动创建表以及更新表结构，生产环境慎用
        show-sql: true # 打印执行的SQL

## 配置类 ##

由于`QueryDSL`不提供`starter`，所以需要自行准备一个配置类，代码如下所示

import com.querydsl.jpa.impl.JPAQueryFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import javax.persistence.EntityManager;
    import javax.persistence.PersistenceContext;
    
    /**
     * QueryDSL配置类
     * @author Null
     * @date 2019-10-24
     */
    @Configuration
    public class QuerydslConfig {
    
        @Autowired
        @PersistenceContext
        private EntityManager entityManager;
    
        @Bean
        public JPAQueryFactory queryFactory(){
            return new JPAQueryFactory(entityManager);
        }
    
    }

## 启动类 ##

启动类很简单，只需要使用`@SpringBootApplication`即可

import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class QuerydslJpaDemoApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(QuerydslJpaDemoApplication.class, args);
        }
    }

## 实体类 ##

主要有讲师和课程，每个课程都有一个讲师，每个讲师有多个课程，即讲师与课程的关系为一对多

### 课程 ###

import lombok.Data;
    
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    
    /**
     * 课程，一个课程对应一个讲师
     * @author Null
     * @date 2019-10-24
     */
    @Data
    @Entity
    public class Course {
        /**
         * 课程ID
         */
        @Id
        @GeneratedValue(strategy= GenerationType.IDENTITY)
        private Long id;
        /**
         * 课程名称
         */
        private String name;
        /**
         * 对应讲师的ID
         */
        private Long lecturerId;
    }

### 讲师 ###

import lombok.Data;
    
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    
    /**
     * 讲师，一个讲师有多个课程
     * @author Null
     * @date 2019-10-24
     */
    @Data
    @Entity
    public class Lecturer {
        /**
         * 讲师ID
         */
        @Id
        @GeneratedValue(strategy= GenerationType.IDENTITY)
        private Long id;
        /**
         * 讲师名字
         */
        private String name;
        /**
         * 性别，true（1）为男性，false（0）为女性
         */
        private Boolean sex;
    }

## Repository接口 ##

如果要使用`QuerDSL`需要`Repository`接口除了继承`JpaRepository`接口（此接口为`Spring-JPA`提供的接口）外，还需要继承`QuerydslPredicateExecutor`接口。关键示例如下：

### 课程Repository ###

import com.example.querydsl.jpa.entity.Course;
    import org.springframework.data.jpa.repository.JpaRepository;
    import org.springframework.data.querydsl.QuerydslPredicateExecutor;
    
    /**
     * 课程Repository
     *
     * @author Null
     * @date 2019-10-24
     */
    public interface CourseRepository extends
            JpaRepository<Course, Integer>,
            QuerydslPredicateExecutor<Course> {
    }

### 讲师Repository ###

import com.example.querydsl.jpa.entity.Lecturer;
    import org.springframework.data.jpa.repository.JpaRepository;
    import org.springframework.data.querydsl.QuerydslPredicateExecutor;
    
    /**
     * 讲师Repository
     * @author Null
     * @date 2019-10-24
     */
    public interface LecturerRepository extends
            JpaRepository<Lecturer,Integer>,
            QuerydslPredicateExecutor<Lecturer> {
    }

## 代码生成 ##

前面配置`QueryDSL`代码生成器就是用于这一步，每次实体类有变更最好重复执行本步骤重新生成新的代码。由于个人习惯使用`IDEA`，所以以`IDEA`作为演示。

1.  双击下图内容即可生成代码了，  
    ![执行指令][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ExNTgxMjM_size_16_color_FFFFFF_t_70]
2.  然后就会在`src/generated-sources`目录可以看到生成的代码，包名与实体包名一致，但是类名为`Q`开头的文件  
    ![介绍][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ExNTgxMjM_size_16_color_FFFFFF_t_70 1]
3.  上一步的截图我们可以看到其实生成的代码被`IDEA`识别为普通文件了，所以我们需要标记`src/generated-sources/java`目录的用途，如下图所示  
    ![生成代码][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ExNTgxMjM_size_16_color_FFFFFF_t_70 2]
    
    标记后，效果如下，可以看到代码被正确识别了  
    ![在这里插入图片描述][20191024215638967.png]  
    到了这一步其实已经完成整合了，下面就开始验证是否正确整合以及展示`QueryDSL`的优势了

## 验证整合与演示 ##

下面我会使用单元测试来验证`QueryDSL`是否正确整合以及演示一下`QueryDSL`的优势

## 单元测试类 ##

这里主要是单元测试类的关键内容，需要注意`@BeforeEach`是`Junit5`的注解，表示每个单元测试用例执行前会执行的方法其实对应`Junit4`的`@Before`

/**
     * @SpringBootTest 默认不支持事务且自动回滚
     * 使用@Transactional 开启事务，
     * 使用@Rollback(false) 关闭自动回滚
     * @author Null
     * @date 2019-10-24
     */
    @SpringBootTest
    class QuerydslJpaDemoApplicationTests {
    
        @Autowired
        private CourseRepository courseRepository;
    
        @Autowired
        private LecturerRepository lecturerRepository;
        
        @Autowired
        private JPAQueryFactory queryFactory;
    
        /**
         * 初始化数据
         */
        @BeforeEach
        public void initData(){
            // 清空数据表
            courseRepository.deleteAll();
            lecturerRepository.deleteAll();
    
            // 初始化讲师
            Lecturer tom=new Lecturer();
            tom.setName("Tom");
            tom.setSex(true);
            lecturerRepository.save(tom);
    
            Lecturer marry=new Lecturer();
            marry.setName("Marry");
            marry.setSex(false);
            lecturerRepository.save(marry);
    
            // 初始化课程
            Course chinese=new Course();
            chinese.setName("Chinese");
            chinese.setLecturerId(tom.getId());
            courseRepository.save(chinese);
    
            Course physics=new Course();
            physics.setName("Physics");
            physics.setLecturerId(tom.getId());
            courseRepository.save(physics);
    
            Course english=new Course();
            english.setName("English");
            english.setLecturerId(marry.getId());
            courseRepository.save(english);
        }
        
        ...省略各个用例
        
    }

### 单表模糊查询 ###

/**
         * 根据课程名称模糊查询课程
         */
        @Test
        public void testSelectCourseByNameLike() {
            // 组装查询条件
            QCourse qCourse = QCourse.course;
            // %要自行组装
            BooleanExpression expression = qCourse.name.like("P%");
            System.out.println(courseRepository.findAll(expression));
        }

### 联表查询 ###

/**
         * 根据讲师姓名查课程
         */
        @Test
        public void testSelectCourseByLecturerName(){
            QCourse qCourse = QCourse.course;
            QLecturer qLecturer = QLecturer.lecturer;
            // 这里包含了组装查询条件和执行查询的逻辑，组装好条件后记得执行fetch()
            List<Course> courses=queryFactory.select(qCourse)
                    .from(qCourse)
                    .leftJoin(qLecturer)
                    .on(qCourse.lecturerId.eq(qLecturer.id))
                    .where(qLecturer.name.eq("Tom"))
                    .fetch();
            System.out.println(courses);
        }

### 更新 ###

/**
         * 根据姓名更新讲师性别<br/>
         * 使用@Transactional开启事务<br/>
         * 使用@Rollback(false)关闭自动回滚<br/>
         */
        @Test
        @Transactional
        @Rollback(false)
        public void testUpdateLecturerSexByName(){
            QLecturer qLecturer = QLecturer.lecturer;
            // 更新Tom的性别为女性，返回的是影响记录条数
            long num=queryFactory.update(qLecturer)
                    .set(qLecturer.sex,false)
                    .where(qLecturer.name.eq("Tom"))
                    .execute();
            // 这里输出被更新的记录数
            System.out.println(num);
        }

### 删除 ###

/**
         * 根据根据性别删除讲师
         */
        @Test
        @Transactional
        @Rollback(false)
        public void testDeleteLecturerBySex(){
            QLecturer qLecturer = QLecturer.lecturer;
            // 删除性别为男性的讲师
            long num=queryFactory.delete(qLecturer)
                    .where(qLecturer.sex.eq(true))
                    .execute();
            // 输出被删除的记录数
            System.out.println(num);
        }

### 用例分析 ###

从用例中可以看出其实`QueryDSL`的`API`更加切合原生的`SQL`，基本上从代码上就可以看出你希望执行的`SQL`了。

细心的朋友会发现`QueryDSL`是没有`insert`方法，因为`JPA`提供的`save()`方法已经足够处理了。

同时要记得要组装好你的`SQL`后别忘记调用`fetch()`或者`execute()`方法。

## 总结 ##

*  `Spring Boot JPA`整合`QueryDSL`的关键步骤
    
    1.  引入依赖和插件
    2.  编写配置类
    3.  使用插件生成代码
    4.  标记生成文件为代码
    5.  `Repository`继承`QuerydslPredicateExecutor`
 *  `QueryDSL`的`API`类似原生`SQL`，`API`风格类似`StringBuilder`的`API`（`Fluent API`风格）。但是不提供`insert`对应的操作。
 *  `QueryDSL`对于复杂的`SQL`的支持十分友好，算是对于`JPA`对这块需求的补充和完善。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ExNTgxMjM_size_16_color_FFFFFF_t_70]: /images/20230531/ca6fab566a0b4434b9a4b138dbe203bd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ExNTgxMjM_size_16_color_FFFFFF_t_70 1]: /images/20230531/645065601d6f41e2ad925ac573f6f64b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ExNTgxMjM_size_16_color_FFFFFF_t_70 2]: /images/20230531/05c7af32b4f64bd28a5dfe9912abcc03.png
[20191024215638967.png]: /images/20230531/98df299429994de19a6270d38fcc18f7.png