【连接池】-从源码到适配(下),使用dynamic-datasource导致连接池没生效(升级版本)

写在前面

书接上文,连接池没生效,启用了一个什么默认的连接池。具体是什么,一起来看看源码吧。


目录


一、问题描述

连接池没生效,无外乎就是 yml 的配置没读取到、连接池没创建或者创建失败了。因为没报错,所以极大的可能是 yml 配置没读取到。


二、本地调试

启动项目,debug一下,果然用的是Tomcat的连接池。

这里,默认根据 DATA_SOURCE_TYPE_NAMES 加载,发现 classpath 中有哪个就用哪个。

java 复制代码
package org.springframework.boot.autoconfigure.jdbc;
public class DataSourceBuilder {

   private static final String[] DATA_SOURCE_TYPE_NAMES = new String[] {
         "org.apache.tomcat.jdbc.pool.DataSource",
         "com.zaxxer.hikari.HikariDataSource",
         "org.apache.commons.dbcp.BasicDataSource", // deprecated
         "org.apache.commons.dbcp2.BasicDataSource" };

   public DataSource build() {
      Class<? extends DataSource> type = getType();
      DataSource result = BeanUtils.instantiate(type);
      maybeGetDriverClassName();
      bind(result);
      return result;
   }
   public Class<? extends DataSource> findType() {
      if (this.type != null) {
         return this.type;
      }
      for (String name : DATA_SOURCE_TYPE_NAMES) {
         try {
	 		// 遍历到第一个就返回了,第一个就是tomcat的
            return (Class<? extends DataSource>) ClassUtils.forName(name,
                  this.classLoader);
         }
         catch (Exception ex) {
         }
      }
      return null;
   }

}

那就再找一下连接池初始化数量,进一步确认。果然也正如料想的那样,初始化数量是10个。

java 复制代码
package org.apache.tomcat.jdbc.pool;
public class PoolProperties implements PoolConfiguration, Cloneable, Serializable {
    private volatile int initialSize = 10;
}

那现在就很明确了,是不是添加完dynamic-datasource之后影响了原有的连接池加载?其实这个时候从properties文件中就已经看出问题了:压根没有dbcp2的节点,貌似也不支持dbcp2连接池(只有druid 和 hikari)

以下是 DynamicDataSourceProperties 和 DataSourceProperty(yml的对应实体)。

java 复制代码
package com.baomidou.dynamic.datasource.spring.boot.autoconfigure;

/**
 * DynamicDataSourceProperties
 *
 * @author TaoYu Kanyuxia
 * @see DataSourceProperties
 * @since 1.0.0
 */
@Slf4j
@Getter
@Setter
@ConfigurationProperties(prefix = DynamicDataSourceProperties.PREFIX)
public class DynamicDataSourceProperties {

  public static final String PREFIX = "spring.datasource.dynamic";
  public static final String HEALTH = PREFIX + ".health";

  /**
   * 必须设置默认的库,默认master
   */
  private String primary = "master";
  /**
   * 是否启用严格模式,默认不启动. 严格模式下未匹配到数据源直接报错, 非严格模式下则使用默认数据源primary所设置的数据源
   */
  private Boolean strict = false;
  /**
   * 是否使用p6spy输出,默认不输出
   */
  private Boolean p6spy = false;
  /**
   * 是否使用 spring actuator 监控检查,默认不检查
   */
  private boolean health = false;
  /**
   * 每一个数据源
   */
  private Map<String, DataSourceProperty> datasource = new LinkedHashMap<>();
  /**
   * 多数据源选择算法clazz,默认负载均衡算法
   */
  private Class<? extends DynamicDataSourceStrategy> strategy = LoadBalanceDynamicDataSourceStrategy.class;
  /**
   * aop切面顺序,默认优先级最高
   */
  private Integer order = Ordered.HIGHEST_PRECEDENCE;
  /**
   * Druid全局参数配置
   */
  @NestedConfigurationProperty
  private DruidConfig druid = new DruidConfig();
  /**
   * HikariCp全局参数配置
   */
  @NestedConfigurationProperty
  private HikariCpConfig hikari = new HikariCpConfig();

  /**
   * 全局默认publicKey
   */
  private String publicKey = CryptoUtils.DEFAULT_PUBLIC_KEY_STRING;
}

package com.baomidou.dynamic.datasource.spring.boot.autoconfigure;

/**
 * @author TaoYu
 * @since 1.2.0
 */
@Slf4j
@Data
@Accessors(chain = true)
public class DataSourceProperty {

  /**
   * 加密正则
   */
  private static final Pattern ENC_PATTERN = Pattern.compile("^ENC\\((.*)\\)$");

  /**
   * 连接池名称(只是一个名称标识)</br> 默认是配置文件上的名称
   */
  private String pollName;
  /**
   * 连接池类型,如果不设置自动查找 Druid > HikariCp
   */
  private Class<? extends DataSource> type;
  /**
   * JDBC driver
   */
  private String driverClassName;
  /**
   * JDBC url 地址
   */
  private String url;
  /**
   * JDBC 用户名
   */
  private String username;
  /**
   * JDBC 密码
   */
  private String password;
  /**
   * jndi数据源名称(设置即表示启用)
   */
  private String jndiName;
  /**
   * 自动运行的建表脚本
   */
  private String schema;
  /**
   * 自动运行的数据脚本
   */
  private String data;
  /**
   * 错误是否继续 默认 true
   */
  private boolean continueOnError = true;
  /**
   * 分隔符 默认 ;
   */
  private String separator = ";";
  /**
   * Druid参数配置
   */
  @NestedConfigurationProperty
  private DruidConfig druid = new DruidConfig();
  /**
   * HikariCp参数配置
   */
  @NestedConfigurationProperty
  private HikariCpConfig hikari = new HikariCpConfig();

  /**
   * 解密公匙(如果未设置默认使用全局的)
   */
  private String publicKey;

  public String getUrl() {
    return decrypt(url);
  }

  public String getUsername() {
    return decrypt(username);
  }

  public String getPassword() {
    return decrypt(password);
  }

  /**
   * 字符串解密
   */
  private String decrypt(String cipherText) {
    if (StringUtils.hasText(cipherText)) {
      Matcher matcher = ENC_PATTERN.matcher(cipherText);
      if (matcher.find()) {
        try {
          return CryptoUtils.decrypt(publicKey, matcher.group(1));
        } catch (Exception e) {
          log.error("DynamicDataSourceProperties.decrypt error ", e);
        }
      }
    }
    return cipherText;
  }
}

咋整?难道不用这个动态数据源,自己写一套?项目紧急,时间上不允许呀!

另外,不可能不支持dbcp2连接池额,走,去官网GitHub上看看。


三、升级dynamic-datasource

官网链接 https://github.com/baomidou/dynamic-datasource/tree/v3.3.4/src/main

不看不知道,一看吓一跳。

源码版本直接从V1.1.0直接到V3.3.0,中间的版本没有了。

查看源码,确实从3.3.4版本开始支持dbcp2版本数据源(目前用的是2.5.7),那就升级到3.5.2(4.x之后结构又发生了很大变化)

升级完,yml中配置的连接池生效了 ~

❗️ 技巧:
这也给我们提了一个醒,在引入一个新的框架时,
一定要先去对应的GitHub仓库看源码,不能只依赖于maven仓库。

成熟的产品,大都高版本是兼容低版本的。低版本不行,就去试试高版本~

四、新的问题

(一)数据源初始化问题

好用是好用,但是存在一个新的问题:dynamic-datasource会在项目启动时,加载所有的数据源并进行连接,然后通过@DS来动态切换数据源。

显然,这和我们的需求不太一样。我们并不想项目一启动就把所有的数据源都加载了,只想primary配置成哪个,就加载哪个数据源。

看源码,找到数据源加载的位置,确实这里把所有数据源全加载了。

以下是加载数据源的源码部分:

java 复制代码
public abstract class AbstractDataSourceProvider implements DynamicDataSourceProvider {

    @Autowired
    private DataSourceCreator dataSourceCreator;

    protected Map<String, DataSource> createDataSourceMap(
            Map<String, DataSourceProperty> dataSourcePropertiesMap) {
        Map<String, DataSource> dataSourceMap = new HashMap<>(dataSourcePropertiesMap.size() * 2);
        for (Map.Entry<String, DataSourceProperty> item : dataSourcePropertiesMap.entrySet()) {
            DataSourceProperty dataSourceProperty = item.getValue();
            String pollName = dataSourceProperty.getPoolName();
            if (pollName == null || "".equals(pollName)) {
                pollName = item.getKey();
            }
            dataSourceProperty.setPoolName(pollName);
            dataSourceMap.put(pollName, dataSourceCreator.createDataSource(dataSourceProperty));
        }
        return dataSourceMap;
    }
}

那好办,取出primary属性,判断一下就可以了。

修改如下:

java 复制代码
package com.baomidou.dynamic.datasource.provider;

import com.baomidou.dynamic.datasource.creator.DefaultDataSourceCreator;
import com.baomidou.dynamic.datasource.spring.boot.autoconfigure.DataSourceProperty;
import com.baomidou.dynamic.datasource.spring.boot.autoconfigure.DynamicDataSourceProperties;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

/**
 * @author TaoYu
 */
@Slf4j
public abstract class AbstractDataSourceProvider implements DynamicDataSourceProvider {

    @Autowired
    private DefaultDataSourceCreator defaultDataSourceCreator;

    @Autowired
    private DynamicDataSourceProperties dynamicDataSourceProperties;

    protected Map<String, DataSource> createDataSourceMap(
            Map<String, DataSourceProperty> dataSourcePropertiesMap) {
        Map<String, DataSource> dataSourceMap = new HashMap<>(dataSourcePropertiesMap.size() * 2);
        for (Map.Entry<String, DataSourceProperty> item : dataSourcePropertiesMap.entrySet()) {
            String dsName = item.getKey();
            // 只加载 yml配置文件中 primary指定的数据源
            if (dsName.equals(dynamicDataSourceProperties.getPrimary())) {
                DataSourceProperty dataSourceProperty = item.getValue();
                String poolName = dataSourceProperty.getPoolName();
                if (poolName == null || "".equals(poolName)) {
                    poolName = dsName;
                }
                dataSourceProperty.setPoolName(poolName);
                dataSourceMap.put(dsName, defaultDataSourceCreator.createDataSource(dataSourceProperty));
            }
        }
        return dataSourceMap;
    }
}

想让源码的文件生效有两种方式:

第一种把jar包中的文件copy出来,在项目下创建相同的包名。

第二种改源码。

因为我们有Nexus私服,这里就采用第二种方式,修改源码,维护一个自己的版本,也方便后期自定义。

构建nexus私服构件,下载源码,在pom中配置,以及maven的settings.xml中的认证,deploy即可到远程私服上查看是否部署成功。

修改依赖版本为自定义构建的版本 3.5.2.companyName。重新部署完项目,发现连接数瞬间变小,由原来的到230多变为40多。

❗️ 注意:这里说一下题外话,项目中还有一个问题,这也是下一个要重构的目标。

目前各个项目单独引用SpringBoot(版本可能还不太一样),数据源dbcp2连接池也就被分散到各个项目中,导致无法统一。
因为dbcp2的版本是在springboot中定义的。

为什么无法统一?看下面示例
在maven项目,父项目中<dependencyManagement>定义一个jar包的版本1.0,
子项目A定义一个jar包版本2.0,子项目B依赖子项目A。
这个时候子项目B的jar包版本不是2.0,而是1.0。

因为子项目A的2.0是会覆盖父项目中的版本,而子项目B只是依赖A,不会覆盖父项目中的1.0。

(二)GaussDB updatedTime NULL值问题

做数据库兼容时,还遇到一个问题:当程序中实体的 updatedTime 日期字段设置为null进行操作时,GaussDB数据库不支持自动更新。

GaussDB没有MySQL的这种 ON UPDATE功能,它认为你传的updatedTime 的值就是NULL,导致数据库NOT NULL 报错。

sql 复制代码
updatedTime timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP

对于这个问题,你可以像Oracle一样通过触发器实现,但是加触发器也需要加很多(还会影响性能)。

我之前有用过MyBatis-plugins的属性填充,那我是否可以为MyBatis自定义一个属性填充?了解MyBatis的我们知道,可以通过拦截器实现,搞定。

以下为属性填充的拦截器:

java 复制代码
package com.zhht.mybatis.interceptor;

import com.alibaba.fastjson.JSON;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlCommandType;
import org.apache.ibatis.plugin.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.lang.reflect.Field;
import java.sql.Timestamp;
import java.util.Date;
import java.util.Objects;
import java.util.Properties;

/**
 * 拦截SQL,进行对象属性填充
 * 解决GaussDB数据库,表字段不支持 ON UPDATE CURRENT_TIMESTAMP
 */
@Intercepts(
        @Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class})
)
public class MetaObjectInterceptor implements Interceptor {

    private static final Logger LOGGER = LoggerFactory.getLogger(MetaObjectInterceptor.class);

    private static final String TABLE_FIELD_CREATE_TIME = "createTime";
    private static final String TABLE_FIELD_CREATED_TIME = "createdTime";
    private static final String TABLE_FIELD_GMT_CREATE = "gmtCreate";

    private static final String TABLE_FIELD_UPDATE_TIME = "updateTime";
    private static final String TABLE_FIELD_UPDATED_TIME = "updatedTime";
    private static final String TABLE_FIELD_GMT_MODIFIED = "gmtModified";

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        MappedStatement ms = (MappedStatement) invocation.getArgs()[0];
        Object parameter = invocation.getArgs()[1];
        LOGGER.info("MetaObjectInterceptor - intercept [method: {}] start!", ms.getId());
        if (!Objects.isNull(parameter)) {
            SqlCommandType sqlCommandType = ms.getSqlCommandType();
            if (SqlCommandType.INSERT == sqlCommandType || SqlCommandType.UPDATE == sqlCommandType) {
                BoundSql boundSql = ms.getBoundSql(parameter);
                String beforeParameter = JSON.toJSONString(boundSql.getParameterObject());
                LOGGER.info("MetaObjectInterceptor - intercept [method: {}, before params: {}]", ms.getId(), beforeParameter);

                Class<?> clazz = parameter.getClass();
                if (clazz.getSuperclass().isInstance(Object.class)) {
                    fillFields(parameter.getClass().getDeclaredFields(), parameter, sqlCommandType);
                } else {
                    Class<?> superclass = clazz.getSuperclass();
                    fillFields(superclass.getDeclaredFields(), parameter, sqlCommandType);
                }

                String afterParameter = JSON.toJSONString(boundSql.getParameterObject());
                LOGGER.info("MetaObjectInterceptor - intercept [method: {}, after params: {}]", ms.getId(), afterParameter);
            }
        }
        LOGGER.info("MetaObjectInterceptor - intercept [method: {}] successful!", ms.getId());
        return invocation.proceed();
    }

    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    @Override
    public void setProperties(Properties properties) {

    }

    /**
     * 填充属性
     *
     * @param declaredFields 参数字段
     * @param parameter      参数实体
     * @param sqlCommandType sql类型
     * @throws IllegalAccessException
     */
    private void fillFields(Field[] declaredFields, Object parameter, SqlCommandType sqlCommandType) throws IllegalAccessException {
        for (Field field : declaredFields) {
            field.setAccessible(true);
            if (isNeedFill(sqlCommandType, field.getName(), field.get(parameter))) {
                doFill(field, parameter);
            }
        }
    }

    /**
     * 设置值
     *
     * @param field 字段
     * @param parameter 参数实体
     */
    private void doFill(Field field, Object parameter) throws IllegalAccessException {
        if (Date.class == field.getType()) {
            field.set(parameter, new Date());
        } else if (Timestamp.class == field.getType()) {
            field.set(parameter, new Timestamp(System.currentTimeMillis()));
        } else if (Long.class == field.getType()) {
            field.set(parameter, System.currentTimeMillis());
        } else {
            LOGGER.warn("MetaObjectInterceptor - doFill [type: {} is not support!]", field.getType().getName());
        }
    }

    /**
     * 判断字段是否需要填充
     * 逻辑:包含且非空
     *
     * @param sqlCommandType sql类型
     * @param fieldName  字段名称
     * @param filedValue 字段值
     * @return
     */
    private boolean isNeedFill(SqlCommandType sqlCommandType, String fieldName, Object filedValue) {
        if (SqlCommandType.INSERT.equals(sqlCommandType)) {
            // create和update字段,为了效率, 不使用list.contains
            if (TABLE_FIELD_CREATE_TIME.equals(fieldName)
                    || TABLE_FIELD_CREATED_TIME.equals(fieldName)
                    || TABLE_FIELD_GMT_CREATE.equals(fieldName)
                    || TABLE_FIELD_UPDATE_TIME.equals(fieldName)
                    || TABLE_FIELD_UPDATED_TIME.equals(fieldName)
                    || TABLE_FIELD_GMT_MODIFIED.equals(fieldName)) {
                return Objects.isNull(filedValue);
            }

        } else if (SqlCommandType.UPDATE.equals(sqlCommandType)) {
            // 只考虑update字段,时时更新
            if (TABLE_FIELD_UPDATE_TIME.equals(fieldName)
                    || TABLE_FIELD_UPDATED_TIME.equals(fieldName)
                    || TABLE_FIELD_GMT_MODIFIED.equals(fieldName)) {
                return true;
            }
        }
        return false;
    }

}

/**
 * MyBatis自动配置
 *
 * @author qiuxianbao
 * @date 2023/10/31
 */
@Configuration
@EnableConfigurationProperties
public class MyBatisAutoConfiguration {

    /**
     * 支持多种数据库产品
     * @return
     */
    @Bean
    @ConditionalOnMissingBean
    public DatabaseIdProvider getDatabaseIdProvider() {
        VendorDatabaseIdProvider databaseIdProvider = new VendorDatabaseIdProvider();
        databaseIdProvider.setProperties(DatabaseVendorLoadUtils.load());
        return databaseIdProvider;
    }

    /**
     * 添加属性填充拦截器
     * @return
     */
    @Bean
    public Interceptor metaObjectInterceptor() {
        return new MetaObjectInterceptor();
    }

}

至此,项目初步完成改造,后续观察,封版提测。

至于源码的事儿,敬请关注看图说话专栏或者系列文章~


五、参考资料

Github dynamic-datasource


写在后面

如果本文内容对您有价值或者有启发的话,欢迎点赞、关注、评论和转发。您的反馈和陪伴将促进我们共同进步和成长。


系列文章

【连接池】-从源码到适配(上),你遇到过数据库连接池的问题吗?This connection has been closed
【源码】-MyBatis-如何系统地看源码

相关推荐
工业甲酰苯胺1 小时前
Redis性能优化的18招
数据库·redis·性能优化
没书读了2 小时前
ssm框架-spring-spring声明式事务
java·数据库·spring
jokerest1232 小时前
web——sqliabs靶场——第十三关——报错注入+布尔盲注
mybatis
i道i3 小时前
MySQL win安装 和 pymysql使用示例
数据库·mysql
小怪兽ysl3 小时前
【PostgreSQL使用pg_filedump工具解析数据文件以恢复数据】
数据库·postgresql
武子康3 小时前
Java-06 深入浅出 MyBatis - 一对一模型 SqlMapConfig 与 Mapper 详细讲解测试
java·开发语言·数据仓库·sql·mybatis·springboot·springcloud
wqq_9922502773 小时前
springboot基于微信小程序的食堂预约点餐系统
数据库·微信小程序·小程序
爱上口袋的天空3 小时前
09 - Clickhouse的SQL操作
数据库·sql·clickhouse
聂 可 以5 小时前
Windows环境安装MongoDB
数据库·mongodb
web前端神器5 小时前
mongodb多表查询,五个表查询
数据库·mongodb