数据库

Jboot 数据库功能基于 JFinal 的 ActiveRecordPlugin 插件和 Apache sharding-sphere 框架，提供了方便快捷的数据库操作能力。

目录

  • 描述
  • 基本增删改查
    • Db + Record 模式
    • Model 映射方式
    • Column 查询方式
  • 关联查询
  • 分页查询
  • 批量插入
  • 事务操作
  • 读写分离
  • 分库分表
  • 分布式事务

描述

Jboot 的数据库是依赖 JFinal 的 ORM 做基本的数据库操作，同时依赖 apahce-sphere 来做分库、分表和依赖 Seata 来做分布式事务。因此，在使用 Jboot 操作数据库的时候，建议对 JFinal 的 ORM 功能和 Apache Sharding-Sphere 有所了解。

基本增删改查

JFinal 操作数据库，提供了两种方式对数据库进行操作，他们分别是：

  • Db + Record 方式
  • Model 映射方式

Db + Record 方式

参考 JFinal 的文档：https://jfinal.com/doc/5-5

Model 映射方式

Model是 MVC 模式中的 M 部分。以下是 Model 定义示例代码：

  1. @Table(tableName = "user", primaryKey = "id")
  2. public class User extends BaseUser<User> {
  4. }

BaseUser：

  1. public abstract class BaseUser<M extends BaseUser<M>> extends JbootModel<M> implements IBean {
  3.     public void setId(java.lang.Long id) {
  4.         set("id", id);
  5.     }
  7.     public java.lang.Long getId() {
  8.         return getLong("id");
  9.     }
  11.     // other getter setter ...
  13. }

需要注意的是：

  • 以上的 User 和 BaseUser 都是通过代码生成器自动生成的，无需手写。
  • 多次执行代码生成器，User 代码不会被覆盖，但是 BaseUser 会被重新覆盖，因此，请不要在 BaseUser 手写任何代码。

一般情况下，在正式的项目里，代码分层还需要 Service 层来对业务逻辑进行处理。

UserService 代码如下:

  1. public class UserService extends JbootServiceBase<User>  {
  3.     // 不需要做任何的实现
  5. }

以上的 UserService , 只需要继承 JbootServiceBase<User> ,我们不需要编写任何实现代码，就可以拥有基本的增删改查的功能。

以下是示例代码：

  1. //创建 UserService
  2. UserService userService = new UserService();
  4. // 创建name属性为James,age属性为25的User对象并添加到数据库
  5. User user = new User().set("name", "James").set("age", 25);
  6. userService.save(user); 
  8. // 删除id值为25的User
  9. userService.deleteById(25);
  11. // 查询id值为25的User将其name属性改为James并更新到数据库
  12. User user = userService.findById(25);
  13. user.set("name", "James");
  14. userService.update(user);
  16. // 分页查询user,当前页号为1,每页10个user
  17. Page<User> userPage = userService.paginate(1, 10);

Columns 查询

在 JFinal 的基础上上，Jboot 提供了一套更加便利的查询方法，根据列查询。

比如，一个 tb_user 表中有以下字段：

  1. CREATE TABLE `user` (
  2.   `id` int(11) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键ID',
  3.   `username` varchar(128) DEFAULT NULL COMMENT '登录名',
  4.   `nickname` varchar(128) DEFAULT NULL COMMENT '昵称',
  5.   `realname` varchar(128) DEFAULT NULL COMMENT '实名',
  6.   `email` varchar(64) DEFAULT NULL COMMENT '邮件',
  7.   `mobile` varchar(32) DEFAULT NULL COMMENT '手机电话',
  8.   `gender` varchar(16) DEFAULT NULL COMMENT '性别',
  9.   `signature` varchar(2048) DEFAULT NULL COMMENT '签名',
  10.   `birthday` datetime DEFAULT NULL COMMENT '生日',
  11.   `company` varchar(256) DEFAULT NULL COMMENT '公司',
  12.   `occupation` varchar(256) DEFAULT NULL COMMENT '职位、职业',
  13.   `address` varchar(256) DEFAULT NULL COMMENT '地址',
  14.   `zipcode` varchar(128) DEFAULT NULL COMMENT '邮政编码',
  15.   `site` varchar(256) DEFAULT NULL COMMENT '个人网址',
  16.   `graduateschool` varchar(256) DEFAULT NULL COMMENT '毕业学校',
  17.   `education` varchar(256) DEFAULT NULL COMMENT '学历',
  18.   `avatar` varchar(256) DEFAULT NULL COMMENT '头像',
  19.   `idcardtype` varchar(128) DEFAULT NULL COMMENT '证件类型：身份证 护照 军官证等',
  20.   `idcard` varchar(128) DEFAULT NULL COMMENT '证件号码',
  21.   PRIMARY KEY (`id`)
  22. ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户信息表，保存用户信息。';

假设我们根据 username 查询，可以如下：

  1. String name = "michael";
  2. DAO.findFirstByColumns(Columns.create("username",name));

当有关联查询的时候，可以使用 DAO 的 join 系列方法，如下：

  1. /**
  2. *查询所有用户，left join 文章表
  3. */
  4. public List<User> findList(){
  5.    DAO.leftJoin("article").on("user.id = article.user_id")
  6.       .rightJoin("...").on(".....")
  7.       .findAll()
  8. }
  10. /**
  11. * 根据用户年龄和文章标题查询
  12. */
  13. public List<User> findListBy(int userAge,String articleTitle){
  14.    DAO.leftJoin("article").on("user.id = article.user_id")
  15.       .rightJoin("...").on(".....")
  16.       .findByColumns(Columns.create().ge("user.age",userAge).like("article.title",articleTitle))
  17. }

读写分离

在 Jboot 应用中，读写分离建议使用两个数据源，分别是读的数据源和写的数据源，写的数据源必须支持可读可写。

在应用中，在某些场景下我们需要从只读数据源读取数据的时候，通过 DAO.use('只读数据源的名称').find(...) 就可以。

分库分表

Jboot 的分库分表功能使用了 Sharding-jdbc 实现的，若在 Jboot 应用在需要用到分库分表功能，需要添加 jboot.datasource.shardingConfigYaml = xxx.yaml 的配置，其中 xxx.yaml 配置需要放在 classpath 目录下，配置内容参考：https://shardingsphere.apache.org/document/current/cn/manual/sharding-jdbc/configuration/config-yaml/

注意： 当在 jboot.properties 文件配置 jboot.datasource.shardingConfigYaml = xxx.yaml之后，不再需要在 jboot.properties 配置 jboot.datasource.url 、 jboot.datasource.user 和 jboot.datasource.password 等，这些配置都转义到 xxx.yaml 里进行配置了。

分布式事务

Jboot 的分布式事务依赖 Seata 来进行实现，在开始分布式事务之前，请先做好 Seata 的相关配置。

  • 创建 Seata 数据库
  • 启动 Seata

参考：https://github.com/seata/seata/wiki/Quick-Start

正常启动 Seata 之后，需要在 jboot.properties 配置文件添加如下配置

  1. jboot.rpc.filter = seata
  2. jboot.rpc.type = dubbo
  3. jboot.seata.enable = true
  4. jboot.seata.failureHandler = com.alibaba.io.seata.tm.api.DefaultFailureHandlerImpl
  5. jboot.seata.applicationId = Dubbo_Seata_Account_Service
  6. jboot.seata.txServiceGroup = dubbo_seata_tx_group

同时，在 resource 目录下添加 registry.conf 文件，用于对 seata 进行 registry 配置，内容如下：

  1. registry {
  2.   # file 、nacos 、eureka、redis、zk、consul、etcd3、sofa
  3.   type = "file"
  5.   nacos {
  6.     serverAddr = "localhost"
  7.     namespace = ""
  8.     cluster = "default"
  9.   }
  10.   eureka {
  11.     serviceUrl = "http://localhost:8761/eureka"
  12.     application = "default"
  13.     weight = "1"
  14.   }
  15.   redis {
  16.     serverAddr = "localhost:6379"
  17.     db = "0"
  18.   }
  19.   zk {
  20.     cluster = "default"
  21.     serverAddr = "127.0.0.1:2181"
  22.     session.timeout = 6000
  23.     connect.timeout = 2000
  24.   }
  25.   consul {
  26.     cluster = "default"
  27.     serverAddr = "127.0.0.1:8500"
  28.   }
  29.   etcd3 {
  30.     cluster = "default"
  31.     serverAddr = "http://localhost:2379"
  32.   }
  33.   sofa {
  34.     serverAddr = "127.0.0.1:9603"
  35.     application = "default"
  36.     region = "DEFAULT_ZONE"
  37.     datacenter = "DefaultDataCenter"
  38.     cluster = "default"
  39.     group = "SEATA_GROUP"
  40.     addressWaitTime = "3000"
  41.   }
  42.   file {
  43.     name = "file.conf"
  44.   }
  45. }
  47. config {
  48.   # file、nacos 、apollo、zk、consul、etcd3
  49.   type = "file"
  51.   nacos {
  52.     serverAddr = "localhost"
  53.     namespace = ""
  54.   }
  55.   consul {
  56.     serverAddr = "127.0.0.1:8500"
  57.   }
  58.   apollo {
  59.     app.id = "seata-server"
  60.     apollo.meta = "http://192.168.1.204:8801"
  61.   }
  62.   zk {
  63.     serverAddr = "127.0.0.1:2181"
  64.     session.timeout = 6000
  65.     connect.timeout = 2000
  66.   }
  67.   etcd3 {
  68.     serverAddr = "http://localhost:2379"
  69.   }
  70.   file {
  71.     name = "file.conf"
  72.   }
  73. }

PS：如果不想叫 registry.conf ,请在环境变量里配置 seata.config.name = yourname ，那么可以使用 yourname.conf 代替 registry.conf。

同时，在 resource 目录下添加 file.conf 文件，内容如下：

  1. transport {
  2.   # tcp udt unix-domain-socket
  3.   type = "TCP"
  4.   #NIO NATIVE
  5.   server = "NIO"
  6.   #enable heartbeat
  7.   heartbeat = true
  8.   #thread factory for netty
  9.   thread-factory {
  10.     boss-thread-prefix = "NettyBoss"
  11.     worker-thread-prefix = "NettyServerNIOWorker"
  12.     server-executor-thread-prefix = "NettyServerBizHandler"
  13.     share-boss-worker = false
  14.     client-selector-thread-prefix = "NettyClientSelector"
  15.     client-selector-thread-size = 1
  16.     client-worker-thread-prefix = "NettyClientWorkerThread"
  17.     # netty boss thread size,will not be used for UDT
  18.     boss-thread-size = 1
  19.     #auto default pin or 8
  20.     worker-thread-size = 8
  21.   }
  22.   shutdown {
  23.     # when destroy server, wait seconds
  24.     wait = 3
  25.   }
  26.   serialization = "seata"
  27.   compressor = "none"
  28. }
  29. service {
  30.   #vgroup->rgroup
  31.   vgroup_mapping.dubbo_seata_tx_group = "default"
  32.   #only support single node
  33.   default.grouplist = "127.0.0.1:8091"
  34.   #degrade current not support
  35.   enableDegrade = false
  36.   #disable
  37.   disable = false
  38.   #unit ms,s,m,h,d represents milliseconds, seconds, minutes, hours, days, default permanent
  39.   max.commit.retry.timeout = "-1"
  40.   max.rollback.retry.timeout = "-1"
  41. }
  43. client {
  44.   async.commit.buffer.limit = 10000
  45.   lock {
  46.     retry.internal = 10
  47.     retry.times = 30
  48.   }
  49.   report.retry.count = 5
  50.   tm.commit.retry.count = 1
  51.   tm.rollback.retry.count = 1
  52. }
  54. ## transaction log store
  55. store {
  56.   ## store mode: file、db
  57.   mode = "file"
  59.   ## file store
  60.   file {
  61.     dir = "sessionStore"
  63.     # branch session size , if exceeded first try compress lockkey, still exceeded throws exceptions
  64.     max-branch-session-size = 16384
  65.     # globe session size , if exceeded throws exceptions
  66.     max-global-session-size = 512
  67.     # file buffer size , if exceeded allocate new buffer
  68.     file-write-buffer-cache-size = 16384
  69.     # when recover batch read size
  70.     session.reload.read_size = 100
  71.     # async, sync
  72.     flush-disk-mode = async
  73.   }
  75.   ## database store
  76.   db {
  77.     ## the implement of javax.sql.DataSource, such as DruidDataSource(druid)/BasicDataSource(dbcp) etc.
  78.     datasource = "dbcp"
  79.     ## mysql/oracle/h2/oceanbase etc.
  80.     db-type = "mysql"
  81.     driver-class-name = "com.mysql.jdbc.Driver"
  82.     url = "jdbc:mysql://127.0.0.1:3306/seata"
  83.     user = "mysql"
  84.     password = "mysql"
  85.     min-conn = 1
  86.     max-conn = 3
  87.     global.table = "global_table"
  88.     branch.table = "branch_table"
  89.     lock-table = "lock_table"
  90.     query-limit = 100
  91.   }
  92. }
  93. lock {
  94.   ## the lock store mode: local、remote
  95.   mode = "remote"
  97.   local {
  98.     ## store locks in user's database
  99.   }
  101.   remote {
  102.     ## store locks in the seata's server
  103.   }
  104. }
  105. recovery {
  106.   #schedule committing retry period in milliseconds
  107.   committing-retry-period = 1000
  108.   #schedule asyn committing retry period in milliseconds
  109.   asyn-committing-retry-period = 1000
  110.   #schedule rollbacking retry period in milliseconds
  111.   rollbacking-retry-period = 1000
  112.   #schedule timeout retry period in milliseconds
  113.   timeout-retry-period = 1000
  114. }
  116. transaction {
  117.   undo.data.validation = true
  118.   undo.log.serialization = "jackson"
  119.   undo.log.save.days = 7
  120.   #schedule delete expired undo_log in milliseconds
  121.   undo.log.delete.period = 86400000
  122.   undo.log.table = "undo_log"
  123. }
  125. ## metrics settings
  126. metrics {
  127.   enabled = false
  128.   registry-type = "compact"
  129.   # multi exporters use comma divided
  130.   exporter-list = "prometheus"
  131.   exporter-prometheus-port = 9898
  132. }
  134. support {
  135.   ## spring
  136.   spring {
  137.     # auto proxy the DataSource bean
  138.     datasource.autoproxy = false
  139.   }
  140. }

注意：1、jboot.seata.txServiceGroup 配置的值要注意和 file.conf 里的 vgroup_mapping.xxx 保持一致2、jboot.rpc.filter=seata ##seata在Dubbo中的事务传播过滤器

以上配置完毕后如何使用呢？点击 这里 查看代码实例。