ORM之他暂时可能只是个弟弟——Jooq

字数统计: 4.5k字   |   阅读时长≈ 22分

摘要：这篇文章主要是对之前一段时间学习Jooq的总结。

前言：相比较Hibernate、Mybatis等大家早已熟知的ORM框架来说，JOOQ只能算是一个弟弟。但它之所以能够脱颖而出，是因为它找到了正确的设计思想。

Jooq简介

JOOQ 是基于Java访问关系型数据库的工具包，轻量，简单，并且足够灵活，可以轻松的使用Java面向对象语法来实现各种复杂的sql。不管是Hibernate或者Mybatis，都能简单的使用实体映射来访问数据库，但有时候这些“高级”的对象关系映射，没有直接使用原生sql来的灵活和简单，而且对于一些如：joins,union, nested selects等复杂的操作支持的不友好。JOOQ 既吸取了传统ORM操作数据的简单性和安全性，又保留了原生sql的灵活性，它更像是介于ORM和JDBC的中间层。

相比其它ORM，JOOQ更注重于对数据库模型的建模。它拥有以下特点：

  • 面向SQL
  • 构建类型安全的SQL
  • 强大的代码生成工具
  • 方便的乐观锁等高级特性

详细的可以看看Jooq官网介绍。

如果说它有什么缺点，那就是它对一些商用数据库，如Oracle、SQL Server是收费的。

快速上手Jooq

接下来，让我们通过官网的《JOOQ7步走》中的例子快速上手JOOQ吧。

第一步 下载JOOQ

首先需要在JOOQ的下载页面下载它。如果使用的是开源版本，可以直接通过Maven等工具下载。

第二步 创建数据库

1
2
3
4
5
6
7
8
9
10
11
12
CREATE DATABASE `test`;

CREATE TABLE `student` (
  `id` int(10) NOT NULL AUTO_INCREMENT,
  `stu_id` int(20) NOT NULL,
  `stu_name` varchar(40) NOT NULL,
  `age` int(8) DEFAULT NULL,
  `class_id` int(10) NOT NULL,
  `class_name` varchar(40) NOT NULL,
  `result` int(8) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4;

第三步 生成代码

JOOQ生成代码方式有多种，可以按照官网的方法生成代码。然后就可以在自己的代码中使用这些生成的代码了。

或者参考下面配置，修改你的pom.xml，然后在Terminal运行：mvn jooq-codegen:generate

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
<properties>
    <java.version>1.8</java.version>
    <!-- 数据库信息 -->
    <db.url>jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=UTF-8</db.url>
    <!-- 你的数据库用户名 -->
    <db.username>root</db.username>
    <!-- 你的数据库密码 -->
    <db.password>{*********}</db.password>
    <jooq.version>3.13.1</jooq.version>
    <!-- 你的packageName -->
    <jooq.packageName>{*********}</jooq.packageName>
    <!-- 你的directory -->
    <jooq.directory>{*********}</jooq.directory>
</properties>

<build>
    <plugins>
<!-- jOOQ代码生成插件 -->
            <plugin>
                <groupId>org.jooq</groupId>
                <artifactId>jooq-codegen-maven</artifactId>
                <version>3.11.2</version>
                <executions>
                    <execution>
                        <id>jooq-codegen</id>
                        <goals>
                            <goal>generate</goal>
                        </goals>
                        <phase>package</phase>
                    </execution>
                </executions>
                <configuration>
                    <skip>false</skip>
                    <jdbc>
                        <driver>com.mysql.jdbc.Driver</driver>
                        <url>${db.url}</url>
                        <user>${db.username}</user>
                        <password>${db.password}</password>
                    </jdbc>
                    <generator>
                        <name>org.jooq.codegen.JavaGenerator</name>
                        <database>
                            <name>org.jooq.meta.mysql.MySQLDatabase</name>
                            <includes>.*</includes>
                            <excludes></excludes>
                            <inputSchema>test</inputSchema>
                        </database>
                        <generate>
                            <javaTimeTypes>true</javaTimeTypes>
                        </generate>
                        <target>
                            <!-- The destination package of your generated classes (within the
                                destination directory) -->
                            <packageName>${jooq.packageName}</packageName>
                            <!-- The destination directory of your generated classes -->
                            <directory>${jooq.directory}</directory>
                        </target>
                        <generate>
                            <!-- 生成pojo -->
                            <pojos>true</pojos>
                            <!-- 生成dao -->
                            <daos>true</daos>
                        </generate>
                    </generator>
                </configuration>
            </plugin>
      </plugins>
</build>

第四、五、六步 完成增删改操作

具体代码如下：

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
import org.jooq.DSLContext;
import org.jooq.Record;
import org.jooq.Result;
import org.jooq.SQLDialect;
import org.jooq.impl.DSL;
import top.ajie.jooqDemo.entity.tables.Student;
import top.ajie.jooqDemo.entity.tables.records.StudentRecord;

import java.sql.Connection;
import java.sql.DriverManager;

import static top.ajie.jooqDemo.entity.Tables.STUDENT;

public class JooqCRUD {
    public static void main(String[] args) {
        String userName = "root";
        String password = "";
        String url = "jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8";
        // Connection is the only JDBC resource that we need
        // PreparedStatement and ResultSet are handled by jOOQ, internally
        try (Connection conn = DriverManager.getConnection(url, userName, password)) {
            DSLContext dslContext = DSL.using(conn, SQLDialect.MYSQL);
            // 查询数据
            query(dslContext);
            // 添加数据
            StudentRecord stu = dslContext.newRecord(STUDENT);
            stu.setStuId(123456);
            stu.setStuName("张三");
            stu.setClassId(20200306);
            stu.setClassName("三年六班");
            stu.setAge(9);
            stu.setResult(100);
            stu.store();
            // 查询数据
            query(dslContext);
            // 修改数据
            int sumUp = dslContext
                    .update(Student.STUDENT)
                    .set(Student.STUDENT.STU_NAME, "李四")
                    .where(Student.STUDENT.STU_NAME.eq("张三")
                            .and(Student.STUDENT.RESULT.eq(100))
                    )
                    .execute();
            System.out.println(sumUp);
            // 查询数据
            query(dslContext);
            // 删除数据
            int sumDelete = dslContext
                    .delete(Student.STUDENT)
                    .where(Student.STUDENT.STU_NAME.eq("李四")
                            .and(Student.STUDENT.RESULT.eq(100))
                    )
                    .execute();
            System.out.println(sumDelete);
            // 查询数据
            query(dslContext);
        }
        // For the sake of this tutorial, let's keep exception handling simple
        catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void query(DSLContext dslContext) {
        // 查询数据
        Result<Record> stuResult = dslContext.select().from(STUDENT).fetch();
        for (Record r : stuResult) {
            String stuName = r.getValue(STUDENT.STU_NAME);
            String className = r.getValue(STUDENT.CLASS_NAME);
            Integer result = r.getValue(STUDENT.RESULT);

            System.out.println("stuName: " + stuName + " className: " + className + " result: " + result);
        }
    }
}

探索 ：略

特性

1、生成POJO

首先在生成配置中添加生成POJO的选项：

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

重新运行生成工具，一个 student 类就生成了：

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
import java.io.Serializable;

import javax.annotation.Generated;

@SuppressWarnings({ "all", "unchecked", "rawtypes" })
public class Student implements Serializable {

    private static final long serialVersionUID = -1386674258;

    private Integer id;
    private Integer stuId;
    private String  stuName;
    private Integer age;
    private Integer classId;
    private String  className;
    private Integer result;

    public Student() {}

    public Student(Student value) {
        this.id = value.id;
        this.stuId = value.stuId;
        this.stuName = value.stuName;
        this.age = value.age;
        this.classId = value.classId;
        this.className = value.className;
        this.result = value.result;
    }
    ............
}

然后可以使用JOOQ的API方便的将查询结果和POJO相互转化了：

1
2
3
4
5
6
7
8
9
// Record to POJO
List<Student> list = dslContext.selectFrom(STUDENT).fetch().into(Student.class);
System.out.println(list);

// POJO to Record
Student a = dslContext.selectFrom(STUDENT).fetch().get(0).into(Student.class);
StudentRecord author = dslContext.newRecord(STUDENT);
author.from(a);
System.out.println(author);

需要注意的是：

  • from方法提供了多个重载，可以从Map或Array获取数据
  • from方法从Object获取数据使用了反射的方式，因此效率会比较低。【后面会有解决办法】

2、生成接口

Java提倡面向接口编程，JOOQ也提供了生成接口的配置：

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

生成的接口是这样的：

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
import java.io.Serializable;

import javax.annotation.Generated;


/**
 * This class is generated by jOOQ.
 */
@Generated(
    value = {
        "http://www.jooq.org",
        "jOOQ version:3.11.11"
    },
    comments = "This class is generated by jOOQ"
)
@SuppressWarnings({ "all", "unchecked", "rawtypes" })
public interface IStudent extends Serializable {

    /**
     * Setter for <code>test.student.id</code>.
     */
    public void setId(Integer value);

    /**
     * Getter for <code>test.student.id</code>.
     */
    public Integer getId();
    .
    .
    .
    .
    .
    .

    /**
     * Copy data into another generated Record/POJO implementing the common interface IStudent
     */
    public <E extends top.ajie.jooqDemo.entity.tables.interfaces.IStudent> E into(E into);
}

如果选择生成“接口”，则生成的Record和POJO都将继承该接口。
而之前提到的from方法也将会增加一个IStudent的重载，并使用其中的Getters, Setters，从而具有更好的性能。

如果只生成接口，而不生成Record或POJO，则JOOQ会使用proxy动态代理对象的方法来达到相同的效果。

3、生成Annotation

JOOQ可以选择生成JPA和JSR-303的注解，从而能够更好的和JPA框架配合，并提供更加强大的校验能力：

1
2
<jpaAnnotations>true</jpaAnnotations>
<validationAnnotations>true</validationAnnotations>

选择之后，以IStudent为例，生成的代码将变成这样：

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
import java.io.Serializable;

import javax.annotation.Generated;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Index;
import javax.persistence.Table;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;


/**
 * This class is generated by jOOQ.
 */
@Generated(
    value = {
        "http://www.jooq.org",
        "jOOQ version:3.11.11"
    },
    comments = "This class is generated by jOOQ"
)
@SuppressWarnings({ "all", "unchecked", "rawtypes" })
@Entity
@Table(name = "student", schema = "test", indexes = {
    @Index(name = "PRIMARY", unique = true, columnList = "id ASC")
})
public interface IStudent extends Serializable {

    /**
     * Setter for <code>test.student.id</code>.
     */
    public void setId(Integer value);

    /**
     * Getter for <code>test.student.id</code>.
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id", unique = true, nullable = false, precision = 10)
    public Integer getId();

    .
    .
    .
    .
    .
    .

    /**
     * Copy data into another generated Record/POJO implementing the common interface IStudent
     */
    public <E extends top.ajie.jooqDemo.entity.tables.interfaces.IStudent> E into(E into);
}

4、Builder模式

到了这一步，也许你已经在问自己，为什么没有早点认识JOOQ了，能省不少事呢。不过你知道吗，JOOQ还可以做得更多——它能生成具有Builder模式的Bean：

添加以下配置：

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

配置fluentSetters为true时，Setter将返回自身：

1
2
3
4
public Student setId(Integer id) {
    this.id = id;
    return this;
}

生成的代码将可以这样使用：

1
2
IStudent student = dslContext.newRecord(STUDENT);
student.setId(1).setStuId(123456).setStuName("老六");

这样代码字段设置和之前相比简洁了很多。

5、DAO和spring

如果你是DAO模式和Spring的忠实粉丝，还可以增加以下两个配置，无缝对接Spring的集成：

1
2
<daos>true</daos>
<springAnnotations>true</springAnnotations>

生成的代码类似这样：

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
import java.util.List;

import javax.annotation.Generated;

import org.jooq.Configuration;
import org.jooq.impl.DAOImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import top.ajie.jooqDemo.entity.tables.Student;
import top.ajie.jooqDemo.entity.tables.records.StudentRecord;


/**
 * This class is generated by jOOQ.
 */
@Generated(
    value = {
        "http://www.jooq.org",
        "jOOQ version:3.11.11"
    },
    comments = "This class is generated by jOOQ"
)
@SuppressWarnings({ "all", "unchecked", "rawtypes" })
@Repository
public class StudentDao extends DAOImpl<StudentRecord, top.ajie.jooqDemo.entity.tables.pojos.Student, Integer> {

    /**
     * Create a new StudentDao without any configuration
     */
    public StudentDao() {
        super(Student.STUDENT, top.ajie.jooqDemo.entity.tables.pojos.Student.class);
    }

    /**
     * Create a new StudentDao with an attached configuration
     */
    @Autowired
    public StudentDao(Configuration configuration) {
        super(Student.STUDENT, top.ajie.jooqDemo.entity.tables.pojos.Student.class, configuration);
    }

    .
    .
    .
    .

    /**
     * Fetch records that have <code>result IN (values)</code>
     */
    public List<top.ajie.jooqDemo.entity.tables.pojos.Student> fetchByResult(Integer... values) {
        return fetch(Student.STUDENT.RESULT, values);
    }
}

6、无符号数字类型

SQL支持无符号数字，但是java没有内建无符号数字的类型，为此JOOQ的作者提供了JOOU来处理无符号数。

例如对上面的age字段，类型可以设置成UInteger，可以使用age.intValue()获取对应的int数值。尽管UInteger更加准确，但是如果你觉得增加一个intValue()的调用会比较繁琐。可以通过下面这个配置使POJO直接使用int作为字段类型：

1
2
3
<database>
  <unsignedTypes>false</unsignedTypes>
</database>

7、乐观锁支持

一个修改的常见场景是：用户读取了记录，作了修改之后再保存入数据库。如果这个时间里，有人修改了数据库的同一个字段，则上一个人的修改就被覆盖了。

乐观锁就是再出现这种情况时，通过抛出异常或其他方式，来提醒用户改动不安全，需要刷新并重新修改记录。

jOOQ允许您使用乐观锁定执行CRUD操作。您可以通过激活相关的executeWithOptimisticLocking设置立即利用此功能。如果不进一步了解基础数据语义，这将对store()和delete()方法产生以下影响：

  • INSERT语句不受此Setting标志的影响。
  • 在UPDATE或DELETE语句之前，jOOQ将运行SELECT .. FOR UPDATE语句，悲观地锁定记录以用于后续的UPDATE(DELETE)。
  • 使用先前的SELECT提取的数据将与存储或删除的记录中的数据进行比较。
  • 一个org.jooq.exception.DataChangedException如果记录已经在平均时间被修改，则被抛出。
  • 如果同时未修改记录，则记录成功UPDATE(DELETE)。

JOOQ提供了一个配置能方便地实现乐观锁，而不需要修改业务代码【详见文档】：

1
2
3
// Properly configure the DSLContext
DSLContext optimistic = DSLContext.using(connection, SQLDialect.MYSQL,
  new Settings().withExecuteWithOptimisticLocking(true));

JOOQ的乐观锁模式虽然对业务逻辑代码没有侵入性，但是需要数据表提供numeric VERSION或TIMESTAMP字段，比如下表的last_modified_time字段：

1
2
3
4
5
6
7
8
9
10
11
CREATE TABLE `student` (
  `id` int(10) NOT NULL AUTO_INCREMENT,
  `stu_id` int(20) NOT NULL,
  `stu_name` varchar(40) NOT NULL,
  `age` int(8) DEFAULT NULL,
  `class_id` int(10) NOT NULL,
  `class_name` varchar(40) NOT NULL,
  `result` int(8) DEFAULT NULL,
  `time` timestamp(0) NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP(0),
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4;

然后在代码生成中添加下面的配置：

1
2
3
4
5
<database>
  ...
  <!-- 支持正则，多个字段可以使用`|`分隔 -->
  <recordTimestampFields>last_modified_time</recordTimestampFields>
</database>

最后生成的Table类中将增加一个getRecordTimestamp方法供乐观锁使用：

1
2
3
public TableField<StudentRecord, Timestamp> getRecordTimestamp() {
    return TIME;
}

应用集成

JOOQ与hikaricp集成管理数据源

JOOQ唯一的外部依赖就是一个JDBC连接或JDBC资源池DataSource。JOOQ只会使用这个连接构建PreparedStatement和执行SQL，并不会管理这个连接的生命周期。这样做的好处是模块功能划分做的很彻底，数据源的事情由专门的数据源库来管理DataSource是一个独立的模块，我们可以灵活地配置它。

应用开发需要引入一个第三方的DatatSource数据源来管理数据库连接；这里介绍一下hikaricp的集成方式：

Hikari提供了多种方式创建数据源，例如可以程序直接创建：

1
2
3
4
5
6
7
8
9
10
HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:mysql://localhost:3306/test");
config.setUsername("root");
config.setPassword("123456");
config.addDataSourceProperty("cachePrepStmts", "true");
config.addDataSourceProperty("prepStmtCacheSize", "350");
config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");

HikariDataSource ds = new HikariDataSource(config);
DSLContext create = DSL.using(ds, SQLDialect.MYSQL);

观察者

ExecuteListener 可以看作是一个JOOQ执行的观察者，它可以监控SQL执行的整个生命周期。并且可以通过执行上下文，做一些个性化的操作。下面SlowQueryListener类的作用就是收集sql执行过程的慢查询日志。

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
class SlowQueryListener extends DefaultExecuteListener {
  private Logger logger = LoggerFactory.getLogger(SlowQueryListener.class);
  StopWatch watch;

  @Override
  public void executeStart(ExecuteContext ctx) {
    super.executeStart(ctx);
    watch = new StopWatch();
  }

  @Override
  public void executeEnd(ExecuteContext ctx) {
    try{
      super.executeEnd(ctx);
      if (watch.split() > 1_000_000_000L) {//记录执行时间超过1s的操作
        ExecuteType type = ctx.type();
        StringBuffer sqlBuffer = new StringBuffer();
        if(type == ExecuteType.BATCH) {
          for(Query query:ctx.batchQueries()) {
            sqlBuffer.append(query.toString()).append("\n");
          }
        }else {
          sqlBuffer.append(ctx.query() == null ? "blank query ":ctx.query().toString());
        }
        watch.splitInfo(String.format("Slow SQL query meta executed : [ %s ]",
                                      sqlBuffer.toString() ));
      }
    }catch (Exception e) {
      logger.error(" SlowQueryListener has occur,fix bug  ",e);
    }
  }
}

然后在初始化 DSLContext 的时候把SlowQueryListener配置进去，代码如下：

1
2
dslContext.configuration()
                .set(DefaultExecuteListenerProvider.providers(slowQueryListener));

分库

数据库分库是生产环境中经常使用的方式，例如我们提供了一个新的class的库，复用了student表。如果我们要查询class库，还需要重新生成class的代码，那就太麻烦了。JOOQ提供了运行时替换库名的能力，使得在生产环境中使用多个分库变得很轻松。还以student的查询为例：

1
2
DSLContext dsl = DSL.using(conn, SQLDialect.MYSQL);
List<Student> list = dslContext.selectFrom(STUDENT).fetch();

对应的默认查询语句是这样的：

1
2
3
4
5
6
7
8
9
10
select
`test`.`student`.`id`,
`test`.`student`.`stu_id`,
`test`.`student`.`stu_name`,
`test`.`student`.`age`,
`test`.`student`.`class_id`,
`test`.`student`.`class_name`,
`test`.`student`.`result`,
`test`.`student`.`time`
from `test`.`student`

如果我们配置了动态替换

1
2
3
4
5
Settings settings =
        new Settings().withRenderMapping(new RenderMapping().withSchemata(
                new MappedSchema().withInput("test").withOutput("class")));
DSLContext dsl = DSL.using(dataSource, SQLDialect.MYSQL, settings);
List<Student> list = dsl.selectFrom(STUDENT).fetch();

则生成的语句就变为class下的SQL了：

1
2
3
4
5
6
7
8
9
10
select
`class`.`student`.`id`,
`class`.`student`.`stu_id`,
`class`.`student`.`stu_name`,
`class`.`student`.`age`,
`class`.`student`.`class_id`,
`class`.`student`.`class_name`,
`class`.`student`.`result`,
`class`.`student`.`time`
from `class`.`student`

JOOQ还支持多个Schema的动态替换，以及表名的动态替换，详见Runtime schema mapping

复用数据库实例

因为JOOQ的SQL是带有Schema名称的，所以对同一个IP实例中的不同数据库，JOOQ可以方便的支持查询。

这在当多个数据库共用一个数据库实例的时候，很有用，可以复用数据源配置，从而不需要为每一个库创建一个连接池，减少数据库连接资源的占用。

1
2
3
dataSource = ImmutableMap.<String, HikariDataSource>builder()
        .put("DATABASE1", datasources1)
        .put("DATABASE2", datasources1).build();

依赖注入

其他常用操作：Batch、Curser、Transaction

其它运行时配置

JOOQ将一些不常用的配置，放在Settings对象类管理，例如

  • 是否使用乐观锁
  • 是否打印JOOQ的SQL日志

具体可以参考JOOQ文档

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

教练，我想学技术！
我主要是以后端技术为主，偶尔看看网络安全相关的内容，或者编写一些有趣的脚本！