【DB系列】Jooq初体验

SpringBootDB系列Jooq
Jooq
|
文章目录
  1. I. 项目搭建
    1. 1. pom依赖
    2. 2. 配置
    3. 3. 数据库初始化
  2. II. 体验case
    1. 1. 代码自动生成
    2. 2. CURD
    3. 3. 测试case
    4. 4. 小结
  3. II. 其他
    1. 0. 项目
    2. 1. 一灰灰Blog

java环境中，说到数据库的操作，我们通常会想到的是mybatis或者hibernate，今天给大家介绍一个国内可能用得不太多的操作方式JOOQ，一款基于Java访问关系型数据库的工具包，轻量，简单，并且足够灵活的ORM框架

本文将各位小伙伴演示一下jooq集成springboot的姿势

I. 项目搭建

我们这里借助h2dabase来搭建演示项目，因此有兴趣的小伙伴在文末可以直接获取项目地址启动即可体验，不需要额外的安装和配置mysql了

本文采用SpringBoot 2.2.1.RELEASE + maven 3.5.3 + IDEA进行开发

1. pom依赖

下面给出核心的依赖配置

1
2
3
4
5
6
7
8
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jooq</artifactId>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
</dependency>

2. 配置

接下来设置一下数据库相关的配置信息，在资源目录resources下，新建配置文件application.properties

1
2
3
4
5
#Database Configuration
spring.datasource.url=jdbc:h2:~/h2-jooq-db
spring.datasource.username=test
spring.datasource.password=
spring.datasource.driverClassName=org.h2.Driver

3. 数据库初始化

jooq有一个特点，是需要我们自己来生成表结构对象，所以我们先初始化一下h2dabase的数据结构，详情可以参考博文 【DB系列h2databse集成示例demo】

表结构定义文件schema-h2.sql, 请注意表结构与mysql的表创建姿势不太一样哦

1
2
3
4
5
6
7
DROP TABLE IF EXISTS poet;

CREATE TABLE poet (
  `id` int NOT NULL,
  `name` varchar(20) NOT NULL default '',
  CONSTRAINT pk_t_poet PRIMARY KEY (ID)
);

数据初始化data-h2.sql

1
2
3
4
5
6
7
8
9
10
11
12
INSERT INTO `poet` (`id`, `name`)
VALUES
	(1, '李白'),
	(2, '艾可翁'),
	(3, '敖陶孙'),
	(4, '安稹'),
	(5, '艾性夫'),
	(6, '奥敦周卿'),
	(7, '安鏖'),
	(8, '阿鲁威'),
	(9, '安鸿渐'),
	(10, '安邑坊女');

我们接下来借助maven插件来初始化数据, pom.xml文件中，添加如下配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
<!-- The H2 test schema is loaded here -->
<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>sql-maven-plugin</artifactId>

    <executions>
        <execution>
            <id>create-database-h2</id>
            <phase>generate-sources</phase>
            <goals>
                <goal>execute</goal>
            </goals>
        </execution>
    </executions>

    <configuration>
        <driver>org.h2.Driver</driver>
        <url>jdbc:h2:~/h2-jooq-db</url>
        <username>test</username>
        <password></password>
        <autocommit>true</autocommit>
        <srcFiles>
            <srcFile>src/main/resources/schema-h2.sql</srcFile>
            <srcFile>src/main/resources/data-h2.sql</srcFile>
        </srcFiles>
    </configuration>

    <dependencies>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <version>1.4.200</version>
        </dependency>
    </dependencies>
</plugin>

如下图的case，完成数据的初始化

II. 体验case

在实际开始jooq的curd之前，需要先生成对应的表结构对象，这里也是借助maven插件来完成

1. 代码自动生成

同样在pom.xml中添加如下配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
<plugin>
      <groupId>org.jooq</groupId>
      <artifactId>jooq-codegen-maven</artifactId>

      <executions>
          <execution>
              <id>generate-h2</id>
              <phase>generate-sources</phase>
              <goals>
                  <goal>generate</goal>
              </goals>
          </execution>
      </executions>
      <configuration>
          <jdbc>
              <!-- 数据库相关配置 -->
              <driver>org.h2.Driver</driver>
              <url>jdbc:h2:~/h2-jooq-db</url>
              <username>test</username>
              <password></password>
          </jdbc>
          <generator>
              <database>
                  <!-- 数据库的基本信息 -->
                  <name>org.jooq.meta.h2.H2Database</name>
                  <includes>.*</includes>
                  <excludes></excludes>
                  <inputSchema>PUBLIC</inputSchema>
              </database>
              <generate>
                  <deprecated>false</deprecated>
                  <instanceFields>true</instanceFields>
                  <pojos>true</pojos>
              </generate>
              <target>
                  <!-- 自动生成的类的包名，以及路径 -->
                  <packageName>com.git.hui.boot.jooq.h2</packageName>
                  <directory>src/main/java</directory>
              </target>
          </generator>
      </configuration>
  </plugin>

如上图的方式执行完毕之后，会得到生成的代码

2. CURD

接下来我们给出CURD的基本使用姿势

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import static com.git.hui.boot.jooq.h2.tables.Poet.POET;

@Service
public class PoetService {

    @Autowired
    DSLContext dsl;

    public int create(int id, String author) {
        return dsl.insertInto(POET).set(POET.ID, id).set(POET.NAME, author).execute();
    }

    public PoetRecord get(int id) {
        return dsl.selectFrom(POET).where(POET.ID.eq(id)).fetchOne();
    }

    public int update(int id, String author) {
        return dsl.update(POET).set(POET.NAME, author).where(POET.ID.eq(id)).execute();
    }

    public int delete(int id) {
        return dsl.delete(POET).where(POET.ID.eq(id)).execute();
    }

    public List<PoetRecord> getAll() {
        return dsl.selectFrom(POET).fetch();
    }
}

注意上面的使用，很好理解了，基本上能愉快的写sql，就可以愉快的使用jooq，上面的这种链式写法，对于sql的阅读是非常友好的；这里的重点是DSLContext，它是JooqAutoConfiguration自动加载的，这里直接拿来使用了（关于更多的配置与多数据源的问题，后面介绍）

3. 测试case

在pom中引入web依赖，设计一些基本的测试case

1
2
3
4
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

增删改查case

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
@RestController
public class PoetRest {
    @Autowired
    private PoetService poetService;

    @RequestMapping(path = "add")
    public int add(Integer id, String name) {
        return poetService.create(id, name);
    }

    @GetMapping(path = "get")
    public String get(Integer id) {
        PoetRecord record = poetService.get(id);
        return r2str(record);
    }

    @GetMapping(path = "list")
    public List<String> list() {
        List<PoetRecord> list = poetService.getAll();
        return list.stream().map(this::r2str).collect(Collectors.toList());
    }


    @GetMapping(path = "update")
    public int update(int id, String author) {
        return poetService.update(id, author);
    }

    @GetMapping(path = "del")
    public int delete(int id) {
        return poetService.delete(id);
    }


    private String r2str(PoetRecord record) {
        return record.getId() + " # " + record.getName();
    }
}

实测结果如下

4. 小结

到此，SpringBoot集成jooq的demo已经完成，并提供了基础的CURD，整体来看，集成比较简单，需要注意的是代码自动生成，我们这里是借助maven插件来实现代码自动生成的， 此外也可以通过官方提供的jooq-xx.jar + xml配置文件来自动生成；后面单独捞一篇博文给与介绍

从jooq的使用姿势来看，最大的感官就是类sql的链式写法，比较的直观，阅读友好；此外需要注意的是自动生成的实体PoetRecord，不要暴露出去哦，一般推荐使用jooq包下面的Poet来代替PoetRecord来作为BO对象使用，可以通过RecordMapper来实现转换，如下

1
2
3
4
5
6
public Poet getById(int id) {
    PoetRecord record = dsl.selectFrom(POET).where(POET.ID.eq(id)).fetchOne();
    RecordMapper<PoetRecord, Poet> mapper =
            dsl.configuration().recordMapperProvider().provide(POET.recordType(), POET.getClass());
    return mapper.map(record);
}

II. 其他

0. 项目

1. 一灰灰Blog

尽信书则不如，以上内容，纯属一家之言，因个人能力有限，难免有疏漏和错误之处，如发现bug或者有更好的建议，欢迎批评指正，不吝感激

下面一灰灰的个人博客，记录所有学习和工作中的博文，欢迎大家前去逛逛

一灰灰blog


打赏 如果觉得我的文章对您有帮助，请随意打赏。
分享到