关于orm:SpringBoot-DB-系列Jooq-初体验

34次阅读

共计 5264 个字符，预计需要花费 14 分钟才能阅读完成。

【SpringBoot DB 系列】Jooq 初体验

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

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

<!– more –>

I. 我的项目搭建

咱们这里借助 h2dabase 来搭建演示我的项目，因而有趣味的小伙伴在文末能够间接获取我的项目地址启动即可体验，不须要额定的装置和配置 mysql 了

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

1. pom 依赖

上面给出外围的依赖配置

<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

#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 的表创立姿态不太一样哦

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

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

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

<!-- 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 中增加如下配置

<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 的根本应用姿态

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

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

增删改查 case

@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 来实现转换，如下

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. 我的项目

  • 工程：https://github.com/liuyueyi/spring-boot-demo
  • 我的项目源码: https://github.com/liuyueyi/spring-boot-demo/tree/master/spring-boot/107-jooq-aop

1. 一灰灰 Blog

尽信书则不如，以上内容，纯属一家之言，因集体能力无限，不免有疏漏和谬误之处，如发现 bug 或者有更好的倡议，欢送批评指正，不吝感谢

上面一灰灰的集体博客，记录所有学习和工作中的博文，欢送大家前去逛逛

  • 一灰灰 Blog 集体博客 https://blog.hhui.top
  • 一灰灰 Blog-Spring 专题博客 http://spring.hhui.top

正文完
orm
发表至： orm
2020-09-16
 0
关于orm:NET-CORE-数据库事务进化总结
关于orm:对象识别之重写对象equals和hashCode方法
关于orm:SpringBoot-DB-系列Jooq-初体验
关于orm:EBean-ORM-框架介绍3实体草稿功能