JOOQ#

jOOQ（Java Object Oriented Querying）是一个开源框架，它可以把数据库模型的基本信息，比如表名，字段名自动生成相应的Java类；并在此基础上提供了一整套数据处理的API。

简单对比#

1. 原生sql#

1
SELECT * FROM kj_merchant WHERE city = '厦门市' ORDER BY create_time

2. MyBatis#

MyBatis 是一个半自动化的ORM框架，需要手动编写SQL语句或通过XML配置。

方式1：XML配置#

在 Mapper.xml 中定义SQL：

1
<select id="selectMerchantsByCity" resultType="KjMerchant">
2
    SELECT * FROM kj_merchant
3
    WHERE city = #{city}
4
    ORDER BY create_time
5
</select>

在 Mapper 接口中调用：

1
public interface KjMerchantMapper {
2
    List<KjMerchant> selectMerchantsByCity(@Param("city") String city);
3
}

方式2：注解方式#

直接在 Mapper 接口中使用注解：

1
public interface KjMerchantMapper {
2
    @Select("SELECT * FROM kj_merchant WHERE city = #{city} ORDER BY create_time")
3
    List<KjMerchant> selectMerchantsByCity(@Param("city") String city);
4
}

3. MyBatis-Plus#

MyBatis-Plus 是 MyBatis 的增强工具，提供了更简洁的API。

方式1：使用 `QueryWrapper#

1
QueryWrapper<KjMerchant> queryWrapper = new QueryWrapper<>();
2
queryWrapper.eq("city", "厦门市")
3
            .orderByAsc("create_time");
4

5
List<KjMerchant> merchants = kjMerchantMapper.selectList(queryWrapper);

方式2：使用 Lambda 表达式#

1
LambdaQueryWrapper<KjMerchant> lambdaQueryWrapper = new LambdaQueryWrapper<>();
2
lambdaQueryWrapper.eq(KjMerchant::getCity, "厦门市")
3
                  .orderByAsc(KjMerchant::getCreateTime);
4

5
List<KjMerchant> merchants = kjMerchantMapper.selectList(lambdaQueryWrapper);

4. Hibernate#

Hibernate 是一个全自动化的ORM框架，支持通过HQL或Criteria API进行查询。

方式1：使用 HQL#

1
String hql = "FROM KjMerchant WHERE city = :city ORDER BY createTime";
2
Query<KjMerchant> query = session.createQuery(hql, KjMerchant.class);
3
query.setParameter("city", "厦门市");
4

5
List<KjMerchant> merchants = query.getResultList();

方式2：使用 Criteria API#

1
CriteriaBuilder cb = session.getCriteriaBuilder();
2
CriteriaQuery<KjMerchant> cq = cb.createQuery(KjMerchant.class);
3
Root<KjMerchant> root = cq.from(KjMerchant.class);
4

5
cq.select(root)
6
  .where(cb.equal(root.get("city"), "厦门市"))
7
  .orderBy(cb.asc(root.get("createTime")));
8

9
List<KjMerchant> merchants = session.createQuery(cq).getResultList();

5. jOOQ#

jOOQ 是一个以SQL为中心的框架，支持类型安全的SQL查询。

方式1：使用 jOOQ 的 DSL#

假设你已经通过 jOOQ 代码生成器生成了 KjMerchant 表和字段的Java类：

1
// 导入生成的表类
2
import static com.example.generated.Tables.KJ_MERCHANT;
3

4
// 创建 DSLContext
5
DSLContext create = DSL.using(connection, SQLDialect.MYSQL);
6

7
// 执行查询
8
List<KjMerchantRecord> merchants = create.selectFrom(KJ_MERCHANT)
9
    .where(KJ_MERCHANT.CITY.eq("厦门市"))
10
    .orderBy(KJ_MERCHANT.CREATE_TIME.asc())
11
    .fetchInto(KjMerchantRecord.class);

方式2：直接使用SQL#

如果你不想使用代码生成器，也可以直接编写SQL：

1
Result<Record> result = create.fetch("SELECT * FROM kj_merchant WHERE city = ? ORDER BY create_time", "厦门市");
2
List<KjMerchant> merchants = result.into(KjMerchant.class);

6. 总结#

以下是四种框架的实现对比：

框架	实现方式
MyBatis	手动编写SQL（XML或注解），适合需要精细控制SQL的场景。
MyBatis-Plus	提供更简洁的API（如 `QueryWrapper`），适合快速开发。
Hibernate	使用HQL或Criteria API，适合面向对象的操作，隐藏SQL细节。
jOOQ	类型安全的SQL查询，适合需要直接控制SQL但又希望避免手动拼接SQL的场景。

简介#

jOOQ，是一个ORM框架，利用其生成的Java代码和流畅的API，可以快速构建有类型约束的安全的SQL语句

jOOQ的核心优势是可以将数据库表结构映射为Java类，包含表的基本描述和所有表字段。通过jOOQ提供的API，配合生成的Java代码，可以很方便的进行数据库操作

生成的Java代码字段类型是根据数据库映射成的Java类型，在进行设置和查询操作时，因为是Java代码，都会有强类型校验，所以对于数据的输入，是天然安全的，极大的减少了SQL注入的风险

jOOQ的代码生成策略是根据配置全量生成，任何对于数据库的改动，如果会影响到业务代码，在编译期间就会被发现，可以及时进行修复。

配置#

Maven 配置#

1
<properties>
2
    <jooq.version>3.14.15</jooq.version>
3
</properties>
4

5
<dependencies>
6
    <dependency>
7
        <groupId>mysql</groupId>
8
        <artifactId>mysql-connector-java</artifactId>
9
        <version>8.0.18</version>
10
    </dependency>
11

12
    <!-- base jooq dependency -->
13
    <dependency>
14
        <groupId>org.jooq</groupId>
15
        <artifactId>jooq</artifactId>
16
        <version>${jooq.version}</version>
17
    </dependency>
18
</dependencies>
19

20
<plugins>
21
   <plugin>
22
        <groupId>org.jooq</groupId>
23
        <artifactId>jooq-codegen-maven</artifactId>
24
        <version>3.14.15</version> <!-- 请使用最新版本 -->
25
        <executions>
26
            <execution>
27
                <goals>
28
                    <goal>generate</goal>
29
                </goals>
30
            </execution>
31
        </executions>
32
        <configuration>
33
            <jdbc> <!-- 数据库连接信息 -->
34
                <driver>com.mysql.cj.jdbc.Driver</driver>
35
                <url>jdbc:mysql://localhost:3306/learn-jooq</url>
36
                <user>root</user>
37
                <password>root</password>
38
            </jdbc>
39
            <generator> <!-- 代码生成器配置 -->
40
                <database>
41
                    <name>org.jooq.meta.mysql.MySQLDatabase</name> <!-- 数据库类型 -->
42
                    <includes>.*</includes> <!-- 表名匹配规则 -->
43
                    <inputSchema>learn-jooq</inputSchema> <!-- 输入数据库的模式 -->
44
                </database>
45
                <generate>
46
                    <pojos>true</pojos> <!-- 启用POJO生成 -->
47
                    <daos>true</daos> <!-- 可选：启用DAO生成 -->
48
                </generate>
49
                <target>
50
                    <packageName>cc.wcxian.jooq.codegen</packageName> <!-- 生成代码的包名 -->
51
                    <directory>src/main/java</directory> <!-- 生成代码的目录 -->
52
                </target>
53
            </generator>
54
        </configuration>
55
   </plugin>
56
</plugins>

代码生成#

代码生成的原理就是通过读取数据库的元数据，将其转换为Java代码，并生成指定的文件，存放到配置好的指定目录

jOOQ的生成代码的目标路径建议配置单独的子包，因为每次代码生成都是全量的，如果和其他业务代码混合在一起，会被生成器误删

1
# 通过此命令里可以调用 jooq-codegen-maven 插件进行代码生成
2
mvn jooq-codegen:generate

或者

代码生成器执行完成后，会生成以下目录:

1
├─src/main/java/.../codegen ---- // 生成路径
2
│ ├─tables --------------------- // 表定义目录
3
│ │ ├─S1User ------------------- // s1_user 表描述包含: 字段，主键，索引，所属Schema
4
│ │ └─records ------------------ // 表操作对象目录
5
│ │   └─S1UserRecord ----------- // s1_user 表操作对象，包含字段get,set方法
6
│ ├─DefaultCatalog ------------- // Catalog对象，包含Schema常量
7
│ ├─Indexes -------------------- // 当前数据库所有的所有常量
8
│ ├─Keys ----------------------- // 当前数据库所有表主键，唯一索引等常量
9
│ ├─LearnJooq ------------------ // 数据库`learn-jooq`常量，包含该库所有表描述常量
10
│ └─Tables --------------------- // 所有数据库表常量

写个接口#

1
@RestController
2
@RequestMapping("/jooq")
3
public class JooqController {
4

5
    @Autowired
6
    private DSLContext dslContext;
7

8
    @GetMapping("/select/{id}")
9
    public List<S1UserDTO> select(@PathVariable Integer id) {
10
        List<S1UserRecord> s1UserRecords = dslContext.selectFrom(S1_USER)
11
                .where(S1_USER.ID.eq(id))
12
                .fetch();
13
        List<S1UserDTO> dtos = s1UserRecords.stream().map(s1UserRecord -> {
14
            S1UserDTO dto = new S1UserDTO();
15
            dto.setId(s1UserRecord.getId());
16
            dto.setUsername(s1UserRecord.getUsername());
17
            dto.setEmail(s1UserRecord.getEmail());
18
            dto.setAddress(s1UserRecord.getAddress());
19
            dto.setCreateTime(s1UserRecord.getCreateTime());
20
            dto.setUpdateTime(s1UserRecord.getUpdateTime());
21
            return dto;
22
        }).collect(Collectors.toList());
23
        return dtos;
24
    }
25
}

1
[
2
  {
3
    "id": 1,
4
    "username": "demo1",
5
    "email": "[email protected]",
6
    "address": "China Guangdong Shenzhen",
7
    "createTime": "2019-12-27T16:41:42",
8
    "updateTime": "2019-12-27T16:41:42"
9
  }
10
]

CRUD#

Insert#

1
// 类SQL语法 insertInto 方法第一个参数通常是表常量
2
dslContext.insertInto(S1_USER, S1_USER.USERNAME, S1_USER.ADDRESS, S1_USER.EMAIL)
3
    .values("王呈现", "厦门", "[email protected]")
4
    .values("小王", "泉州", "[email protected]")
5
    .execute();
6

7
// newRecord() 方法标识添加一条记录，通过链式调用，支持批量插入
8
dslContext.insertInto(S1_USER)
9
    .set(S1_USER.USERNAME, "雷军")
10
    .set(S1_USER.EMAIL, "[email protected]")
11
    .newRecord()
12
    .set(S1_USER.USERNAME, "马云")
13
    .set(S1_USER.EMAIL, "[email protected]")
14
    .execute();
15

16

17
//Record API
18
S1UserRecord record = dslContext.newRecord(S1_USER);
19
record.setUsername("usernameRecord1");
20
record.setEmail("[email protected]");
21
record.setAddress("address hello");
22
record.insert();
23

24
//批量插入
25
List<S1UserRecord> recordList = IntStream.range(0, 10).mapToObj(i -> {
26
    S1UserRecord s1UserRecord = new S1UserRecord();
27
    s1UserRecord.setUsername("usernameBatchInsert" + i);
28
    s1UserRecord.setEmail("[email protected]");
29
    return s1UserRecord;
30
}).collect(Collectors.toList());
31
dslContext.batchInsert(recordList).execute();
32

33
//插入后获得自增主键
34
Integer userId = dslContext.insertInto(S1_USER,
35
    S1_USER.USERNAME, S1_USER.ADDRESS, S1_USER.EMAIL)
36
    .values("username1", "demo-address1", "[email protected]")
37
    .returning(S1_USER.ID)
38
    .fetchOne().getId();

Update#

1
//类SQL
2
dslContext.update(S1_USER)
3
    .set(S1_USER.USERNAME, "RUOK")
4
    .set(S1_USER.EMAIL, "[email protected]")
5
    .where(S1_USER.ID.eq(347))
6
    .execute();
7

8
//Record API
9
S1UserRecord record = dslContext.newRecord(S1_USER);
10
record.setId(1);
11
record.setUsername("usernameUpdate-2");
12
record.setAddress("record-address-2");
13
record.update();
14
// 生成SQL:  update `learn-jooq`.`s1_user` set `learn-jooq`.`s1_user`.`id` = 1, `learn-jooq`.`s1_user`.`username` = 'usernameUpdate-2', `learn-jooq`.`s1_user`.`address` = 'record-address-2' where `learn-jooq`.`s1_user`.`id` = 1
15

16
//批量更新
17
S1UserRecord record1 = new S1UserRecord();
18
record1.setId(1);
19
record1.setUsername("batchUsername-1");
20
S1UserRecord record2 = new S1UserRecord();
21
record2.setId(2);
22
record2.setUsername("batchUsername-2");
23

24
List<S1UserRecord> userRecordList = new ArrayList<>();
25
userRecordList.add(record1);
26
userRecordList.add(record2);
27
dslContext.batchUpdate(userRecordList).execute();

Select#

1
//单表查询
2
Result<Record> fetchResult = dslContext.select().from(S1_USER)
3
        .where(S1_USER.ID.in(1, 2)).fetch();
4
List<S1UserRecord> result = fetchResult.into(S1UserRecord.class);
5

6
//联表查询
7
esult<Record3<String, String, String>> record3Result =
8
        dslContext.select(S1_USER.USERNAME,
9
        S2_USER_MESSAGE.MESSAGE_TITLE,
10
        S2_USER_MESSAGE.MESSAGE_CONTENT)
11
        .from(S2_USER_MESSAGE)
12
        .leftJoin(S1_USER).on(S1_USER.ID.eq(S2_USER_MESSAGE.USER_ID))
13
        .fetch();
14
List<UserMessagePojo> userMessagePojoList = record3Result.into(UserMessagePojo.class);
15
//into方法可以将结果或结果集转换为任意类型，jOOQ会通过反射的方式，将对应的字段值填充至指定的POJO中。通过关联查询的结果集，可以使用此方法将查询结果转换至指定类型的集合。

Delete#

1
//类SQL方式
2
int i = dslContext.delete(S1_USER).where(S1_USER.USERNAME.eq("王呈现")).execute();
3

4
//Record API
5
S1UserRecord record = dslContext.newRecord(S1_USER);
6
record.setId(2);
7
int deleteRows = record.delete();
8

9
//批量删除
10
S1UserRecord record1 = new S1UserRecord();
11
record1.setId(1);
12
S1UserRecord record2 = new S1UserRecord();
13
record2.setId(2);
14
dslContext.batchDelete(record1, record2).execute();
15

16
List<S1UserRecord> recordList = new ArrayList<>();
17
recordList.add(record1);
18
recordList.add(record2);
19
dslContext.batchDelete(recordList).execute();

POJO#

代码生成器可以配置在生成代码时，同时生成和表一一对应的POJO，只需要在生成器配置generator块中，加上相关配置即可:

1
<generator>
2
    <generate>
3
        <pojos>true</pojos>
4
    </generate>
5
    <!-- ...  -->
6
</generator>

我们如果要基于原有的某个POJO添加其他字段，那么我们可以自己创建一个和表名一致的类，然后继承该POJO对象，在添加上我们需要的字段，例如本篇代码实例中的s2_user_message表，在这里我们需要将这张表和s1_user表进行关联查询，为了是查出用户ID对应的用户名

1
public class UserMessagePojo extends S2UserMessage {
2
    private String username;
3

4
    public String getUsername() {
5
        return username;
6
    }
7

8
    public void setUsername(String username) {
9
        this.username = username;
10
    }
11
}

SpringBoot 配置#

1
<generator>
2
    <strategy>
3
        <name>com.diamondfsd.jooq.learn.CustomGeneratorStrategy</name>
4
    </strategy>
5
    <generate>
6
        <pojos>true</pojos>
7
        <daos>true</daos>
8
        <interfaces>true</interfaces>
9
        <springAnnotations>true</springAnnotations>
10
    </generate>
11
</generator>

1
class S1UserDaoTest extends BaseTest {
2
    @Autowired
3
    S1UserDao s1UserDao;
4

5
    Integer insertUserId = null;
6

7
    @Test
8
    public void findAll() {
9
        List<S1UserPojo> userAll = s1UserDao.findAll();
10
        Assertions.assertTrue(userAll.size() > 0);
11
    }
12

13
    @Test
14
    public void insert() {
15
        S1UserPojo s1UserPojo = new S1UserPojo();
16
        s1UserPojo.setUsername("hell username");
17
        s1UserDao.insert(s1UserPojo);
18
        Assertions.assertNotNull(s1UserPojo.getId());
19
        insertUserId = s1UserPojo.getId();
20
    }
21

22
    @Test
23
    public void findById() {
24
        S1UserPojo findById = s1UserDao.findById(1);
25
        Assertions.assertNotNull(findById);
26

27
        if (insertUserId != null) {
28
            S1UserPojo userPojo = s1UserDao.findById(insertUserId);
29
            Assertions.assertNull(userPojo);
30
        }
31
    }
32
}

JOOQ转SQL

插件 CodeTools

参考资料#

从零开始 - jOOQ 系列教程

《你不知道的 JAVA》博客系列 💘 掌握数据库 Simple CRUD 的方法之 JOOQ 实战上述的使用方式在数据 - 掘金

国内的 Java 体系真的很落后吗？ - V2EX

Java ORM 哪家强？10个ORM框架测试对比与选型建议_java orm框架-CSDN博客