《SpringBoot2.0 实战》系列-集成MybatisPlus并配置动态数据源

àì夳堔傛蜴生んèń 2023-06-27 12:44 15阅读 0赞

## 简介 ##

[MyBatis-Plus][]（简称 MP）是一个 [MyBatis][] 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

整合了Hibernate和Mybatis的有点，即简化了单表基础的操作，又可自定义sql语句。

官方文档：[https://mp.baomidou.com/guide/][https_mp.baomidou.com_guide]

## 特性 ##

*  **无侵入**：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
 *  **损耗小**：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
 *  **强大的 CRUD 操作**：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
 *  **支持 Lambda 形式调用**：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
 *  **支持主键自动生成**：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题
 *  **支持 ActiveRecord 模式**：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作
 *  **支持自定义全局通用操作**：支持全局通用方法注入（ Write once, use anywhere ）
 *  **内置代码生成器**：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用
 *  **内置分页插件**：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询
 *  **分页插件支持多种数据库**：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库
 *  **内置性能分析插件**：可输出 Sql 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询
 *  **内置全局拦截插件**：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作

## ![20200106212658678.jpeg][] ##

### 快速开始 ###

增加相关依赖包

<dependency>
 <groupId>com.baomidou</groupId>
 <artifactId>mybatis-plus-boot-starter</artifactId>
 <version>3.3.0</version>
 </dependency>
 
 <dependency>
 <groupId>com.baomidou</groupId>
 <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
 <version>2.5.7</version>
 </dependency>

## 配置 ##

配置详解：[https://mp.baomidou.com/config/\#%E5%9F%BA%E6%9C%AC%E9%85%8D%E7%BD%AE][https_mp.baomidou.com_config_E5_9F_BA_E6_9C_AC_E9_85_8D_E7_BD_AE]

#MyBatisPlus
    mybatis-plus:
      mapper-locations: classpath*:/mapper/*.xml
      type-aliases-package: com.gourd.hu
      type-aliases-super-type: com.gourd.hu.base.data.BaseEntity
      type-handlers-package: com.gourd.hu.base.type.handler
      scripting-language-driver:
      global-config:
        banner: false # 关闭打印mybatis-plus的LOGO
        db-config:
          logic-delete-value: 1 # 逻辑已删除值(默认为 1)
          logic-not-delete-value: 0 # 逻辑未删除值(默认为 0)
    
    spring:
      # 数据库配置
      datasource:
        dynamic:
          p6spy: true # 默认false,建议线上关闭
          primary: master #设置默认的数据源或者数据源组,默认值即为master
          datasource:
            master:
              url: xxx
              driver-class-name: com.mysql.cj.jdbc.Driver
              username: root
              password: xxx
            slave:
              url: xxx
              driver-class-name: com.mysql.cj.jdbc.Driver
              username: root
              password: xxx

** 启动类增加**@MapperScan注解

@SpringBootApplication
 @MapperScan({"com.gourd.hu.*.dao"})
 public class ServiceHuApplication {
 
 public static void main(String[] args) {
 SpringApplication.run(ServiceHuApplication.class, args);
 log.warn(">o< gourd-hu服务启动成功！温馨提示：代码千万行，注释第一行，命名不规范，同事泪两行 >o<");
 }
 
 /**
 * 主数据源
 * @return
 */
 @Primary
 @Bean
 @ConfigurationProperties(prefix = "spring.datasource.dynamic.datasource.master")
 public DruidDataSource druidDataSource() {
 return new DruidDataSource();
 }
 }

## 拓展功能 ##

### **动态数据源切换** ###

> 使用 **@DS** 切换数据源。
> 
> **@DS** 可以注解在方法上和类上，**同时存在方法注解优先于类上注解**。
> 
> 注解在service实现或mapper接口方法上，但强烈不建议同时在service和mapper注解。 (可能会有问题)

![20200106205757383.png][]

###  **公共字段自动填充** ###

![20200106212828422.jpeg][]

新增处理器实现 **MetaObjectHandler** 接口，并增加@Component 注解自动注入到spring容器中管理

/**
     * 元对象字段填充控制器
     * 自定义填充公共字段 ,即没有传的字段自动填充
     *
     * @author gourd
     **/
    @Component
    public class FillMetaObjectHandler implements MetaObjectHandler {
        /**
         *  新增填充
         *
         *  @param metaObject
         */
        @Override
        public void insertFill(MetaObject metaObject) {
            // 此处userId根据自己的业务框架获取到
            Long userId = 0L;
            fillCreateMeta(metaObject, userId);
            fillUpdateMeta(metaObject, userId);
            fillCommonMeta(metaObject);
        }
    
        /**
         * 更新填充
         *
         * @param metaObject
         */
        @Override
        public void updateFill(MetaObject metaObject) {
            // 此处userId根据自己的业务框架获取到
            Long userId = 0L;
            fillUpdateMeta(metaObject,userId);
        }
    
        private void fillCommonMeta(MetaObject metaObject) {
            if (metaObject.hasGetter("version") && metaObject.hasGetter("deleted")) {
                setFieldValByName("version",1L,metaObject);
                setFieldValByName("deleted",false,metaObject);
            }
        }
    
        private void fillCreateMeta(MetaObject metaObject, Long userId) {
            if (metaObject.hasGetter("createdBy") && metaObject.hasGetter("createdTime")) {
                setFieldValByName("createdBy", userId, metaObject);
                setFieldValByName("createdTime", new Date(), metaObject);
            }
        }
        private void fillUpdateMeta(MetaObject metaObject, Long userId) {
            if (metaObject.hasGetter("updatedBy") && metaObject.hasGetter("updatedTime")) {
                setFieldValByName("updatedBy", userId, metaObject);
                setFieldValByName("updatedTime", new Date(), metaObject);
            }
        }
    }

### **ID自动填充** ###

![2020010621311224.jpeg][]

新增Id填充处理器实现 **IdentifierGenerator** 接口，并增加@Component 注解自动注入到spring容器中管理。

其中ID的生成策略可以自定义，并不一定要按照我的方式。

/**
 * 实体类id自动填充
 * @author gourd
 */
 @Component
 public class EntityIdGeneratorHandler implements IdentifierGenerator {
 
 private static final IdWorker idWorker = new IdWorker(0,1);
 
 @Override
 public Long nextId(Object entity) {
 return idWorker.nextId();
 }
 }
 
 /**
 * 名称：IdWorker.java
 * 描述：分布式自增长ID
 * <pre>
 * Twitter的 Snowflake　JAVA实现方案
 * </pre>
 * 核心代码为其IdWorker这个类实现，其原理结构如下，我分别用一个0表示一位，用—分割开部分的作用：
 * 1||0---0000000000 0000000000 0000000000 0000000000 0 --- 00000 ---00000 ---000000000000
 * 在上面的字符串中，第一位为未使用（实际上也可作为long的符号位），接下来的41位为毫秒级时间，
 * 然后5位datacenter标识位，5位机器ID（并不算标识符，实际是为线程标识），
 * 然后12位该毫秒内的当前毫秒内的计数，加起来刚好64位，为一个Long型。
 * 这样的好处是，整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞（由datacenter和机器ID作区分），
 * 并且效率较高，经测试，snowflake每秒能够产生26万ID左右，完全满足需要。
 * 
 * 64位ID (42(毫秒)+5(机器ID)+5(业务编码)+12(重复累加))
 * @author gourd
 */
 public class IdWorker {
 // 时间起始标记点，作为基准，一般取系统的最近时间（一旦确定不能变动）
 private final static long twepoch = 1288834974657L;
 // 机器标识位数
 private final static long workerIdBits = 5L;
 // 数据中心标识位数
 private final static long datacenterIdBits = 5L;
 // 机器ID最大值
 private final static long maxWorkerId = -1L ^ (-1L << workerIdBits);
 // 数据中心ID最大值
 private final static long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);
 // 毫秒内自增位
 private final static long sequenceBits = 12L;
 // 机器ID偏左移12位
 private final static long workerIdShift = sequenceBits;
 // 数据中心ID左移17位
 private final static long datacenterIdShift = sequenceBits + workerIdBits;
 // 时间毫秒左移22位
 private final static long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
 
 private final static long sequenceMask = -1L ^ (-1L << sequenceBits);
 /* 上次生产id时间戳 */
 private static long lastTimestamp = -1L;
 // 0，并发控制
 private long sequence = 0L;
 
 private final long workerId;
 // 数据标识id部分
 private final long datacenterId;
 
 public IdWorker() {
 this.datacenterId = getDatacenterId(maxDatacenterId);
 this.workerId = getMaxWorkerId(datacenterId, maxWorkerId);
 }
 
 /**
 * @param workerId 工作机器ID
 * @param datacenterId 序列号
 */
 public IdWorker(long workerId, long datacenterId) {
 if (workerId > maxWorkerId || workerId < 0) {
 throw new IllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0", maxWorkerId));
 }
 if (datacenterId > maxDatacenterId || datacenterId < 0) {
 throw new IllegalArgumentException(String.format("datacenter Id can't be greater than %d or less than 0", maxDatacenterId));
 }
 this.workerId = workerId;
 this.datacenterId = datacenterId;
 }
 
 /**
 * 获取下一个ID
 *
 * @return
 */
 public synchronized long nextId() {
 long timestamp = timeGen();
 if (timestamp < lastTimestamp) {
 throw new RuntimeException(String.format("Clock moved backwards. Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
 }
 
 if (lastTimestamp == timestamp) {
 // 当前毫秒内，则+1
 sequence = (sequence + 1) & sequenceMask;
 if (sequence == 0) {
 // 当前毫秒内计数满了，则等待下一秒
 timestamp = tilNextMillis(lastTimestamp);
 }
 } else {
 sequence = 0L;
 }
 lastTimestamp = timestamp;
 // ID偏移组合生成最终的ID，并返回ID
 long nextId = ((timestamp - twepoch) << timestampLeftShift)
 | (datacenterId << datacenterIdShift)
 | (workerId << workerIdShift) | sequence;
 
 return nextId;
 }
 
 private long tilNextMillis(final long lastTimestamp) {
 long timestamp = this.timeGen();
 while (timestamp <= lastTimestamp) {
 timestamp = this.timeGen();
 }
 return timestamp;
 }
 
 private long timeGen() {
 return System.currentTimeMillis();
 }
 
 /**
 * 
 * 获取 maxWorkerId
 * 
 */
 protected static long getMaxWorkerId(long datacenterId, long maxWorkerId) {
 StringBuffer mpid = new StringBuffer();
 mpid.append(datacenterId);
 String name = ManagementFactory.getRuntimeMXBean().getName();
 if (!name.isEmpty()) {
 /*
 * GET jvmPid
 */
 mpid.append(name.split("@")[0]);
 }
 /*
 * MAC + PID 的 hashcode 获取16个低位
 */
 return (mpid.toString().hashCode() & 0xffff) % (maxWorkerId + 1);
 }
 
 /**
 * 
 * 数据标识id部分
 * 
 */
 protected static long getDatacenterId(long maxDatacenterId) {
 long id = 0L;
 try {
 InetAddress ip = InetAddress.getLocalHost();
 NetworkInterface network = NetworkInterface.getByInetAddress(ip);
 if (network == null) {
 id = 1L;
 } else {
 byte[] mac = network.getHardwareAddress();
 id = ((0x000000FF & (long) mac[mac.length - 1])
 | (0x0000FF00 & (((long) mac[mac.length - 2]) << 8))) >> 6;
 id = id % (maxDatacenterId + 1);
 }
 } catch (Exception e) {
 
 }
 return id;
 }
 
 public static void main(String[] args) {
 // IdWorker idWorker = new IdWorker(31,31);
 // System.out.println("idWorker="+idWorker.nextId());
 IdWorker id = new IdWorker(0, 1);
 // System.out.println("id="+id.nextId());
 // System.out.println(id.datacenterId);
 // System.out.println(id.workerId);
 
 for (int i = 0; i < 9000; i++) {
 System.err.println(id.nextId());
 }
 }
 }

### **逻辑删除** ###

配置增加如下

mybatis-plus:
      global-config:
        db-config:
          logic-delete-field: flag  #全局逻辑删除字段值，也可在实体类上增加@TableLogic注解
          logic-delete-value: 1 # 逻辑已删除值(默认为 1)
          logic-not-delete-value: 0 # 逻辑未删除值(默认为 0)

如果不配置logic-delete-field，需要在实体类上增加 **@TableLogic**注解。

/**
     * 公共实体父类
     * @author gourd
     */
    @Data
    public class BaseEntity extends Model{
    
        /**
         * 主键id
         */
        @TableId(type= IdType.ASSIGN_ID)
        private Long id;
    
        /**
         * 创建人
         */
        @TableField(value = "created_by",fill = FieldFill.INSERT)
        private Long createdBy;
    
        /**
         * 创建时间
         */
        @TableField(value = "created_time",fill = FieldFill.INSERT)
        private Date createdTime;
    
        /**
         * 更新人
         */
        @TableField(value = "updated_by",fill = FieldFill.INSERT_UPDATE)
        private Long updatedBy;
    
        /**
         * 更新时间
         */
        @TableField(value = "updated_time",fill = FieldFill.INSERT_UPDATE)
        private Date updatedTime;
    
        /**
         * 版本号
         */
        @Version
        @TableField(fill = FieldFill.INSERT)
        private Long version;
    
        /**
         * 逻辑删除状态
         */
        @TableLogic
        @TableField(value = "is_deleted",fill = FieldFill.INSERT)
        private Boolean deleted;
    
    
        @Override
        protected Serializable pkVal() {
            return null;
        }
    }

### **乐观锁插件** ###

/**
         * mybatis-plus乐观锁插件
         * @return
         */
        @Bean
        public OptimisticLockerInterceptor optimisticLockerInterceptor() {
            return new OptimisticLockerInterceptor();
        }

### **sql注入器** ###

/**
         * Sql 注入器
         * @return
         */
        @Bean
        public ISqlInjector sqlInjector() {
            return new DefaultSqlInjector();
        }

### **执行 SQL 分析打印** ###

![20200106213215394.jpeg][]

借助于三方插件 **p6spy**

<dependency>
 <groupId>p6spy</groupId>
 <artifactId>p6spy</artifactId>
 <version>3.8.0</version>
 </dependency>

修改数据库连接配置，生产环境不建议开启。

url: jdbc:p6spy:mysql://xxx?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC&useSSL=false&nullCatalogMeansCurrent=true&serverTimezone=GMT%2B8
    driver-class-name: com.p6spy.engine.spy.P6SpyDriver

在resource目录下增加 **spy.properties**

# 指定应用的日志拦截模块,默认为com.p6spy.engine.spy.P6SpyFactory
 #modulelist=com.p6spy.engine.spy.P6SpyFactory,com.p6spy.engine.logging.P6LogFactory,com.p6spy.engine.outage.P6OutageFactory
 
 # 真实JDBC driver , 多个以 逗号 分割 默认为空
 #driverlist=
 
 # 是否自动刷新 默认 flase
 #autoflush=false
 
 # 配置SimpleDateFormat日期格式 默认为空
 dateformat=yyyy-MM-dd HH:mm:ss
 
 # 打印堆栈跟踪信息 默认flase
 #stacktrace=false
 
 # 如果 stacktrace=true，则可以指定具体的类名来进行过滤。
 #stacktraceclass=
 
 # 监测属性配置文件是否进行重新加载
 #reloadproperties=false
 
 # 属性配置文件重新加载的时间间隔，单位:秒 默认60s
 #reloadpropertiesinterval=60
 
 # 指定 Log 的 appender，取值：
 #appender=com.p6spy.engine.spy.appender.Slf4JLogger
 #appender=com.p6spy.engine.spy.appender.StdoutLogger
 #appender=com.p6spy.engine.spy.appender.FileLogger
 # 使用日志系统记录 sql
 appender=com.p6spy.engine.spy.appender.Slf4JLogger
 # 设置 p6spy driver 代理
 deregisterdrivers=true
 # 取消JDBC URL前缀
 useprefix=true
 
 # 指定 Log 的文件名 默认 spy.log
 #logfile=spy.log
 
 # 指定是否每次是增加 Log，设置为 false 则每次都会先进行清空 默认true
 #append=true
 
 # 指定日志输出样式 默认为com.p6spy.engine.spy.appender.SingleLineFormat , 单行输出 不格式化语句
 #logMessageFormat=com.p6spy.engine.spy.appender.SingleLineFormat
 # 自定义日志打印
 logMessageFormat=com.baomidou.mybatisplus.extension.p6spy.P6SpyLogger
 
 # 也可以采用 com.p6spy.engine.spy.appender.CustomLineFormat 来自定义输出样式, 默认值是%(currentTime)|%(executionTime)|%(category)|connection%(connectionId)|%(sqlSingleLine)
 # 可用的变量为:
 # %(connectionId) connection id
 # %(currentTime) 当前时间
 # %(executionTime) 执行耗时
 # %(category) 执行分组
 # %(effectiveSql) 提交的SQL 换行
 # %(effectiveSqlSingleLine) 提交的SQL 不换行显示
 # %(sql) 执行的真实SQL语句，已替换占位
 # %(sqlSingleLine) 执行的真实SQL语句，已替换占位 不换行显示
 #customLogMessageFormat=%(currentTime)|%(executionTime)|%(category)|connection%(connectionId)|%(sqlSingleLine)
 
 # date类型字段记录日志时使用的日期格式 默认dd-MMM-yy
 #databaseDialectDateFormat=dd-MMM-yy
 
 # boolean类型字段记录日志时使用的日期格式 默认boolean 可选值numeric
 #databaseDialectBooleanFormat=boolean
 
 # 是否通过jmx暴露属性 默认true
 #jmx=true
 
 # 如果jmx设置为true 指定通过jmx暴露属性时的前缀 默认为空
 # com.p6spy(.<jmxPrefix>)?:name=<optionsClassName>
 #jmxPrefix=
 
 # 是否显示纳秒 默认false
 #useNanoTime=false
 
 # 实际数据源 JNDI
 #realdatasource=/RealMySqlDS
 # 实际数据源 datasource class
 #realdatasourceclass=com.mysql.jdbc.jdbc2.optional.MysqlDataSource
 
 # 实际数据源所携带的配置参数 以 k=v 方式指定 以 分号 分割
 #realdatasourceproperties=port;3306,serverName;myhost,databaseName;jbossdb,foo;bar
 
 # jndi数据源配置
 # 设置 JNDI 数据源的 NamingContextFactory。
 #jndicontextfactory=org.jnp.interfaces.NamingContextFactory
 # 设置 JNDI 数据源的提供者的 URL。
 #jndicontextproviderurl=localhost:1099
 # 设置 JNDI 数据源的一些定制信息，以分号分隔。
 #jndicontextcustom=java.naming.factory.url.pkgs;org.jboss.naming:org.jnp.interfaces
 
 # 是否开启日志过滤 默认false， 这项配置是否生效前提是配置了 include/exclude/sqlexpression
 filter=true
 
 # 过滤 Log 时所包含的表名列表，以逗号分隔 默认为空
 #include=
 # 过滤 Log 时所排除的表名列表，以逗号分隔 默认为空
 exclude= foreign_key_checks,variable_name,GET_LOCK,RELEASE_LOCK,flyway_schema_history,information_schema,@,SELECT DATABASE(),SELECT version(),ACT_,QRTZ_
 
 # 过滤 Log 时的 SQL 正则表达式名称 默认为空
 #sqlexpression=
 
 #显示指定过滤 Log 时排队的分类列表，取值: error, info, batch, debug, statement,
 #commit, rollback, result and resultset are valid values
 # (默认 info,debug,result,resultset,batch)
 #excludecategories=info,debug,result,resultset,batch
 
 # 是否过滤二进制字段
 # (default is false)
 #excludebinary=false
 
 # P6Log 模块执行时间设置，整数值 (以毫秒为单位)，只有当超过这个时间才进行记录 Log。 默认为0
 #executionThreshold=
 
 # P6Outage 模块是否记录较长时间运行的语句 默认false
 # outagedetection=true
 # P6Outage 模块执行时间设置，整数值 （以秒为单位)），只有当超过这个时间才进行记录 Log。 默认30s
 # outagedetectioninterval=5s

===============================================

代码均已上传至本人的开源项目

![20191230131831499.jpeg][]

葫芦胡：[https://blog.csdn.net/HXNLYW/article/details/98037354][https_blog.csdn.net_HXNLYW_article_details_98037354]

## ##

[MyBatis-Plus]: https://github.com/baomidou/mybatis-plus
[MyBatis]: http://www.mybatis.org/mybatis-3/
[https_mp.baomidou.com_guide]: https://mp.baomidou.com/guide/
[20200106212658678.jpeg]: https://img-blog.csdnimg.cn/20200106212658678.jpeg
[https_mp.baomidou.com_config_E5_9F_BA_E6_9C_AC_E9_85_8D_E7_BD_AE]: https://mp.baomidou.com/config/#%E5%9F%BA%E6%9C%AC%E9%85%8D%E7%BD%AE
[20200106205757383.png]: https://img-blog.csdnimg.cn/20200106205757383.png
[20200106212828422.jpeg]: https://img-blog.csdnimg.cn/20200106212828422.jpeg
[2020010621311224.jpeg]: https://img-blog.csdnimg.cn/2020010621311224.jpeg
[20200106213215394.jpeg]: https://img-blog.csdnimg.cn/20200106213215394.jpeg
[20191230131831499.jpeg]: https://img-blog.csdnimg.cn/20191230131831499.jpeg
[https_blog.csdn.net_HXNLYW_article_details_98037354]: https://blog.csdn.net/HXNLYW/article/details/98037354