【DB系列】Jooq代码自动生成

SpringBootDB系列Jooq
Jooq
|
文章目录
  1. I. 前期准备
    1. 1. 数据表准备
    2. 2. 数据库相关信息
  2. II. 代码自动生成
    1. 1. maven插件
      1. a. 驱动器
      2. b. jdbc配置
      3. c. generate配置
    2. 2. jar包生成
    3. 3. 小结
  3. II. 其他
    1. 0. 项目
    2. 1. 一灰灰Blog

Jooq提供了非常简单的方式来自动生成对应的代码，就我个人的使用感触，比mybatis-plus用起来爽，下面介绍两种殊途同归的自动生成方式

  • jooq jar包生成方式
  • maven插件生成方式

I. 前期准备

在前面体验篇中介绍的是maven插件 + h2database的代码自动生成方式；本文则将数据库替换为最常见的mysql，使用姿势上差别也不会太大

1. 数据表准备

不管使用前面说的两种方式的哪一种，前提是mysql中必须存在对应的表结构，我们这里指定两个简单的表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
CREATE TABLE `user` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(80) NOT NULL DEFAULT '' COMMENT '用户名',
  `pwd` varchar(26) NOT NULL DEFAULT '' COMMENT '密码',
  `isDeleted` tinyint(1) NOT NULL DEFAULT '0',
  `created` varchar(13) NOT NULL DEFAULT '0',
  `updated` varchar(13) NOT NULL DEFAULT '0',
  PRIMARY KEY (`id`),
  KEY `name` (`name`)
) ENGINE=InnoDB AUTO_INCREMENT=30 DEFAULT CHARSET=utf8mb4;

CREATE TABLE `money` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(20) NOT NULL DEFAULT '' COMMENT '用户名',
  `money` int(26) NOT NULL DEFAULT '0' COMMENT '钱',
  `is_deleted` tinyint(1) NOT NULL DEFAULT '0',
  `create_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  PRIMARY KEY (`id`),
  KEY `name` (`name`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

2. 数据库相关信息

数据库连接信息

1
2
3
4
5
6
spring:
  datasource:
    # 注意指定时区
    url: jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=Asia/Shanghai
    username: root
    password:

II. 代码自动生成

本文主要介绍的是基于SpringBoot的jooq集成，本文使用 SpringBoot 2.2.1.RELEASE

1. maven插件

首先需要创建一个SpringBoot项目，在pom.xml配置文件中，借助jooq-codegen-maven来实现代码生成

一个完整的配置示例如下

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
<build>
    <plugins>
        <plugin>
            <groupId>org.jooq</groupId>
            <artifactId>jooq-codegen-maven</artifactId>
            <!--下面这段不注释时，可以通过 mvn clean install 来生成代码-->
            <executions>
                <execution>
                    <id>convergence</id>
                    <phase>generate-sources</phase>
                    <goals>
                        <goal>generate</goal>
                    </goals>
                </execution>
            </executions>

            <dependencies>
                <dependency>
                    <groupId>mysql</groupId>
                    <artifactId>mysql-connector-java</artifactId>
                    <version>8.0.18</version>
                </dependency>
            </dependencies>

            <configuration>
                <jdbc>
                    <!-- 数据库相关配置 -->
                    <driver>com.mysql.cj.jdbc.Driver</driver>
                    <url>jdbc:mysql://127.0.0.1:3306/test</url>
                    <user>root</user>
                    <password></password>
                </jdbc>

                <generator>
                    <name>org.jooq.codegen.JavaGenerator</name>

                    <database>
                        <!-- 数据库的基本信息 -->
                        <name>org.jooq.meta.mysql.MySQLDatabase</name>
                        <inputSchema>test</inputSchema>
                        <!-- 所有的表都包含进来，用于自动生成代码 -->
                        <includes>user|money</includes>
                        <excludes></excludes>
                    </database>

                    <generate>
                        <pojos>true</pojos>
                    </generate>

                    <target>
                        <!-- 自动生成的类的包名，以及路径 -->
                        <packageName>com.git.hui.boot.jooq.dao</packageName>
                        <directory>src/main/java</directory>
                    </target>

                    <strategy>
                        <matchers>
                            <tables>
                                <table>
                                    <expression>^(.*)$</expression>
                                    <tableClass>
                                        <!-- table的后缀为TB -->
                                        <transform>PASCAL</transform>
                                        <expression>$1_T_B</expression>
                                    </tableClass>
                                    <recordClass>
                                        <!-- record的后缀为PO，表示实体类 -->
                                        <transform>PASCAL</transform>
                                        <expression>$1_P_O</expression>
                                    </recordClass>
                                    <pojoClass>
                                        <!-- pojo后缀为BO，作为内部使用的简单对象-->
                                        <transform>PASCAL</transform>
                                        <expression>$1_B_O</expression>
                                    </pojoClass>
                                </table>
                            </tables>
                        </matchers>
                    </strategy>
                </generator>
            </configuration>
        </plugin>
    </plugins>
</build>

上面的配置虽然长，但是结构比较清晰，下面拆分说明一下

a. 驱动器

因为数据源是mysql，所以我们加的是如下配置，如果是其他的数据源，替换成对应的依赖即可

1
2
3
4
5
6
7
<dependencies>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.18</version>
    </dependency>
</dependencies>

b. jdbc配置

这个配置很重要，连接数据库读取表结构信息

1
2
3
4
5
6
7
<jdbc>
    <!-- 数据库相关配置 -->
    <driver>com.mysql.cj.jdbc.Driver</driver>
    <url>jdbc:mysql://127.0.0.1:3306/test</url>
    <user>root</user>
    <password></password>
</jdbc>

c. generate配置

generate中指定jooq相关的一些配置

<database> 标签

指定数据库基本信息，如数据库名，哪些表需要自动生成对应的代码，哪些可以排除掉

1
2
3
4
5
6
7
8
9
<database>
    <!-- 数据库的基本信息 -->
    <name>org.jooq.meta.mysql.MySQLDatabase</name>
    <!-- 数据库名 -->
    <inputSchema>test</inputSchema>
    <!-- 所有的表都包含进来，用于自动生成代码 -->
    <includes>user|money</includes>
    <excludes></excludes>
</database>

如果我们希望数据库中所有的表都生成对应的代码，可以在include标签中填写.*；上面的写法表示 user, money这两张表需要生成相应的代码

pojos

下面这个非必要，因为默认生成DO对象包含较多的表结构信息，所以我们可以指定生成简单的对象，用于更友好的业务传递

1
2
3
<generate>
    <pojos>true</pojos>
</generate>

target

自动生成类的包名以及输出地址

1
2
3
4
5
<target>
    <!-- 自动生成的类的包名，以及路径 -->
    <packageName>com.git.hui.boot.jooq.dao</packageName>
    <directory>src/main/java</directory>
</target>

strategy

可以给生成的表名，实体名，pojo名指定特定的后缀

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<strategy>
    <matchers>
        <tables>
            <table>
                <expression>^(.*)$</expression>
                <tableClass>
                    <!-- table的后缀为TB -->
                    <transform>PASCAL</transform>
                    <expression>$1_T_B</expression>
                </tableClass>
                <recordClass>
                    <!-- record的后缀为PO，表示实体类 -->
                    <transform>PASCAL</transform>
                    <expression>$1_P_O</expression>
                </recordClass>
                <pojoClass>
                    <!-- pojo后缀为BO，作为内部使用的简单对象-->
                    <transform>PASCAL</transform>
                    <expression>$1_B_O</expression>
                </pojoClass>
            </table>
        </tables>
    </matchers>
</strategy>

代码自动生成

执行maven插件在idea中比较简单了，如下图，执行完毕之后，就可以在上面定义的路径下看到生成的类

2. jar包生成

除了上面介绍的maven插件自动生成代码之外，还可以借助jooq-xx.jar来自动生成代码，最大的好处是不需要创建项目工程，可以直接使用

这种用法需要我们下载对应的jar包，有需要的小伙伴可以到官网去获取，同时我也传了一份到百度网盘，关注微信公众号：一灰灰blog之后，回复 jooq-code-gen 即可获取下载信息（我个人不太建议使用这种方式，maven插件是真香）

下面假设各位小伙伴已经get到了所需的信息，对应的jar包和启动脚本(deploy.sh)如下

最后一个参数是我们的配置文件, mysql.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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<configuration xmlns="http://www.jooq.org/xsd/jooq-codegen-3.9.0.xsd">
    <!-- Configure the database connection here -->
    <jdbc>
        <driver>com.mysql.jdbc.Driver</driver>
        <url>jdbc:mysql://127.0.0.1:3306/test</url>
        <user>root</user>
        <password></password>
    </jdbc>

    <generator>
        <!-- java -classpath jooq-3.12.1.jar;jooq-meta-3.12.1.jar;jooq-codegen-3.12.1.jar;reactive-streams-1.0.3.jar;mysql-connector-java-5.1.41.jar;. org.jooq.codegen.GenerationTool mysql.xml -->
        <!-- The default code generator. You can override this one, to generate your own code style.
             Supported generators:
             - org.jooq.util.JavaGenerator
             - org.jooq.util.ScalaGenerator
             Defaults to org.jooq.util.JavaGenerator -->
        <name>org.jooq.codegen.JavaGenerator</name>

        <database>
            <!-- The database marketType. The format here is:
                 org.util.[database].[database]Database -->
            <name>org.jooq.meta.mysql.MySQLDatabase</name>

            <!-- The database schema (or in the absence of schema support, in your RDBMS this
                 can be the owner, user, database name) to be generated -->
            <inputSchema>test</inputSchema>

            <!-- All elements that are generated from your schema
                 (A Java regular expression. Use the pipe to separate several expressions)
                 Watch out for case-sensitivity. Depending on your database, this might be important! -->
            <includes>
               user|money
            </includes>

            <!-- All elements that are excluded from your schema
                 (A Java regular expression. Use the pipe to separate several expressions).
                 Excludes match before includes, i.e. excludes have a higher priority -->
            <excludes></excludes>
        </database>

        <generate>
            <!-- Generation flags: See advanced configuration properties -->
            <pojos>true</pojos>
            <daos>false</daos>
        </generate>

        <target>
            <!-- The destination package of your generated classes (within the destination directory) -->
            <packageName>com.git.hui.boot.jooq.dao</packageName>

            <!-- The destination directory of your generated classes. Using Maven directory layout here -->
            <directory>../src/main/java</directory>
        </target>

        <strategy>
            <matchers>
                <tables>
                    <table>
                        <expression>^(.*)$</expression>
                        <tableClass>
                            <!-- table的后缀为TB -->
                            <transform>PASCAL</transform>
                            <expression>$1_T_B</expression>
                        </tableClass>
                        <recordClass>
                            <!-- record的后缀为PO，表示实体类 -->
                            <transform>PASCAL</transform>
                            <expression>$1_P_O</expression>
                        </recordClass>
                        <pojoClass>
                            <!-- pojo后缀为BO，作为内部使用的简单对象-->
                            <transform>PASCAL</transform>
                            <expression>$1_B_O</expression>
                        </pojoClass>
                    </table>
                </tables>
            </matchers>
        </strategy>
    </generator>
</configuration>

说明

  • 上面的生成命令，适用于mac + linux操作系统，如果是widowns的童鞋，可以把-classpath参数中的冒号换成分号

3. 小结

本文主要介绍了jooq代码自动生成的两种方式，各自的优缺点比较明显

  • maven: 简单，简洁，高效，缺点是需要依托项目来执行
  • jar包: 独立运行，缺点是需要下载配套的jar包

II. 其他

0. 项目

系列博文

源码

1. 一灰灰Blog

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

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

一灰灰blog


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