一、前言
mybatisPlus多数据源配置主要解决的是多数据库连接和切换的问题。在一些大型应用中，由于数据量的增长或者业务模块的增多，可能需要访问多个数据库。这时，就需要配置多个数据源。
二、springboot + MyBatis Plus 数据源配置
2.1、单数据源配置
2.1.1、引用依赖
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.5.1</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.28</version>
</dependency>
2.1.2、application.yml 配置
spring:
datasource:
url: jdbc:mysql://localhost:3306/db1?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai&useSSL=false
username: root
password: 123456
driver-class-name: com.mysql.cj.jdbc.Driver
2.1.3、通用配置类
@Configuration
@MapperScan(basePackages = {"com.xx.**.mapper"})
public class MybatisPlusConfig {
public MybatisPlusInterceptor mybatisPlusInterceptor(){
//新的分页插件配置方法（Mybatis Plus 3.4.0版本及其之后的版本）
MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
return mybatisPlusInterceptor;
}
}
2.1.4、使用方式
这里便不过多的说明具体的使用方式了，和正常的MyBatis plus 单库一样
2.2、多数据源配置
2.2.1、引用依赖
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.5.1</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.28</version>
</dependency>
<!-- 集成druid连接池 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.2.9</version>
</dependency>
<!-- 多数据源所需要使用到的依赖-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>dynamic-datasource-spring-boot-starter</artifactId>
<version>3.1.0</version>
</dependency>
2.2.2、在 application.yml
spring:
# 配置数据源信息
datasource:
dynamic:
# 设置默认的数据源或者数据源组,默认值为master
primary: master
# 严格匹配数据源,默认false,true未匹配到指定数据源时抛异常,false使用默认数据源
strict: false
datasource:
master:
url: jdbc:mysql://localhost:3306/test?serverTimezone=GMT%2B8&characterEncoding=utf-8&userSSL=false
driver-class-name: com.mysql.cj.jdbc.Driver
username: root
password: 123456
slave_1:
url: jdbc:mysql://localhost:3306/demo?serverTimezone=GMT%2B8&characterEncoding=utf-8&userSSL=false
driver-class-name: com.mysql.cj.jdbc.Driver
username: root
2.2.3、通用配置类
@Configuration
@MapperScan(basePackages = {"com.xx.**.mapper"})
public class MybatisPlusConfig {
public MybatisPlusInterceptor mybatisPlusInterceptor(){
//新的分页插件配置方法（Mybatis Plus 3.4.0版本及其之后的版本）
MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
return mybatisPlusInterceptor;
}
}
2.2.4、准备 DataSourceType
public enum DataSourceType {
MASTER,
SLAVE,
THIRD
}
2.2.5、自定义切换数据源的注解 DataSourceType
import java.lang.annotation.*;
/**
* 定义切换数据源的注解
*
* @author: zhangxiaohu
* @date: 2021/6/25 21:59
* @Description:
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataSource {
/**
* 切换数据源名称
*/
DataSourceType value() default DataSourceType.MASTER;
}
2.2.6、准备 DynamicDataSourceContextHolder
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 动态数据源名称上下文处理
*
**/
public class DynamicDataSourceContextHolder {
public static final Logger log = LoggerFactory.getLogger(DynamicDataSourceContextHolder.class);
/**
* 设置数据源
* @param key
*/
private static final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>();
/**
* 设置数据源
* @param key
*/
public static void setDataSourceType(String dataSourceType) {
log.info(" switch to {} data source", dataSourceType);
CONTEXT_HOLDER.set(dataSourceType);
}
/**
* 获取数据源名称
* @return
*/
public static String getDataSourceType() {
return CONTEXT_HOLDER.get();
}
/**
* 删除当前数据源名称
*/
public static void clearDataSourceType() {
CONTEXT_HOLDER.remove();
}
}
2.2.7、动态数据源
import com.dq.workflow.context.DynamicDataSourceContextHolder;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
/**
* 动态数据源
*
**/
public class DynamicDataSource extends AbstractRoutingDataSource {
@Override
protected Object determineCurrentLookupKey() {
return DynamicDataSourceContextHolder.getDataSourceType();
}
}
2.2.8、在config中配置数据源
import com.dq.workflow.constants.DataSourceConstants;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.context.annotation.PropertySource;
import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;
@Component
@Configuration
@PropertySource("classpath:application-test.yml")
@MapperScan({"com.dq.workflow.mapper","com.dq.workflow.activiti.mapper"})
public class DataSourceConfig {
/**
* 创建数据源db1
* @return 数据源db1
*/
@Bean(name = "masterDataSource")
@ConfigurationProperties(prefix = "spring.datasource.dynamic.datasource.master")
public DataSource masterDataSource() {
return DataSourceBuilder.create().build();
}
/**
* 创建数据源db2
* @return 数据源db2
*/
@Bean(name = "slaveDataSource")
@ConfigurationProperties(prefix = "spring.datasource.dynamic.datasource.slave")
public DataSource slaveDataSource() {
return DataSourceBuilder.create().build();
}
/**
* 数据源配置
* @param db1数据源db1
* @param db2数据源db2
* @return 动态数据源切换对象。
* @Description @Primary赋予该类型bean更高的优先级，使至少有一个bean有资格作为autowire的候选者。
*/
@Primary
@Bean(name = "dynamicDataSource")
public DataSource dataSource(@Qualifier("masterDataSource") DataSource masterDataSource,
@Qualifier("slaveDataSource") DataSource slaveDataSource) {
Map<Object, Object> targetDataSourcesMap = new HashMap<>();
//主数据源
targetDataSourcesMap.put(DataSourceType.MASTER.name(), masterDataSource);
//从数据源
targetDataSourcesMap.put(DataSourceType.SLAVE.name(), slaveDataSource);
// 设置默认数据源、其他数据源
return new DynamicDataSource(masterDataSource, targetDataSourcesMap);
}
}
2.2.9、在config中配置数据源 文件为 db.properties
这个是将原来 Springboot DB配置单独抽离为一个单独的配置文件 db.properties ，没有这种情况的可以不用看这部分
2.2.9.1、准备 DbProperties
public class DbProperties {
public static String masterDriver;
public static String masterUrl;
public static String masterUserName;
public static String masterPassword;
public static String masterSchema;
public static String masterEncrypted;
public static String slaveDriver;
public static String slaveUrl;
public static String slaveUserName;
public static String slavePassword;
public static String slaveSchema;
public static String slaveEncrypted;
}
2.2.9.2、在 application.yml 添加
db:
properties:
path: C:\\MVNO\\src\\main\\resources\\db.properties
2.2.9.3、修改 DataSourceConfig
@Component
@Configuration
public class DataSourceConfig {
@Value("${db.properties.path}")
private String path;
private PropertyResourceBundle externalProps;
@Override
public void afterPropertiesSet() throws Exception {
InputStream input = null;
try {
input = Files.newInputStream(Paths.get(path));
this.externalProps = new PropertyResourceBundle(input);
} catch (Exception ex) {
log.error("Load external configuration file failed. path: {}. Cause: {}", path, ex.getMessage());
throw new RuntimeException(ex);
} finally {
IoUtil.close(input);
}
}
public void initDbProperties(String path) {
try {
DbProperties.masterDriver = this.externalProps.getString("jdbc.mvno.driverClassName");
DbProperties.masterUrl = this.externalProps.getString("jdbc.mvno.url");
DbProperties.masterUserName = this.externalProps.getString("jdbc.mvno.username");
DbProperties.masterPassword = this.externalProps.getString("jdbc.mvno.password");
DbProperties.masterSchema = this.externalProps.getString("jdbc.mvno.schema");
DbProperties.masterEncrypted = this.externalProps.getString("jdbc.mvno.encrypted");
DbProperties.slaveDriver = this.externalProps.getString("jdbc.pbue.driverClassName");
DbProperties.slaveUrl = this.externalProps.getString("jdbc.pbue.url");
DbProperties.slaveUserName = this.externalProps.getString("jdbc.pbue.username");
DbProperties.slavePassword = this.externalProps.getString("jdbc.pbue.password");
DbProperties.slaveSchema = this.externalProps.getString("jdbc.pbue.schema");
DbProperties.slaveEncrypted = this.externalProps.getString("jdbc.pbue.encrypted");
if ("true".equalsIgnoreCase(DbProperties.masterEncrypted)) {
DbProperties.masterPassword = Decryption.decrypt(DbProperties.masterPassword);
}
if ("true".equalsIgnoreCase(DbProperties.slaveEncrypted)) {
DbProperties.slavePassword = Decryption.decrypt(DbProperties.slavePassword);
}
} catch (Exception ex) {
log.error("Load db configuration failed. Cause: {}", ex.getMessage());
throw new RuntimeException(ex);
}
}
/**
* 创建数据源db1
* @return 数据源db1
*/
@Bean(name = "masterDataSource")
@Scope(ConfigurableListableBeanFactory.SCOPE_SINGLETON)
public DataSource masterDataSource() {
initDbProperties(path);
DruidDataSource dataSource = DruidDataSourceBuilder.create().build();
dataSource.setDriverClassName(DbProperties.masterDriver);
dataSource.setUsername(DbProperties.masterUserName);
dataSource.setPassword(DbProperties.masterPassword);
dataSource.setUrl(DbProperties.masterUrl);
dataSource.setMaxWait(60000);
dataSource.setMinEvictableIdleTimeMillis(300000);
}
/**
* 创建数据源db2
* @return 数据源db2
*/
@Bean(name = "slaveDataSource")
@ConfigurationProperties(prefix = "spring.datasource.dynamic.datasource.slave")
public DataSource slaveDataSource() {
initDbProperties(path);
DruidDataSource dataSource = DruidDataSourceBuilder.create().build();
dataSource.setDriverClassName(DbProperties.slaveDriver);
dataSource.setUsername(DbProperties.slaveUserName);
dataSource.setPassword(DbProperties.slavePassword);
dataSource.setUrl(DbProperties.slaveUrl);
dataSource.setMaxWait(60000);
dataSource.setMinEvictableIdleTimeMillis(300000);
return dataSource;
}
/**
* 数据源配置
* @param db1数据源db1
* @param db2数据源db2
* @return 动态数据源切换对象。
* @Description @Primary赋予该类型bean更高的优先级，使至少有一个bean有资格作为autowire的候选者。
*/
@Primary
@Bean(name = "dynamicDataSource")
public DataSource dataSource(@Qualifier("masterDataSource") DataSource masterDataSource,
@Qualifier("slaveDataSource") DataSource slaveDataSource) {
Map<Object, Object> targetDataSourcesMap = new HashMap<>();
//主数据源
targetDataSourcesMap.put(DataSourceType.MASTER.name(), masterDataSource);
//从数据源
targetDataSourcesMap.put(DataSourceType.SLAVE.name(), slaveDataSource);
// 设置默认数据源、其他数据源
return new DynamicDataSource(masterDataSource, targetDataSourcesMap);
}
}
2.2.9.4、修改 DynamicDataSource
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import javax.sql.DataSource;
import java.util.Map;
public class DynamicDataSource extends AbstractRoutingDataSource{
public DynamicDataSource(DataSource defaultTargetDataSource, Map<Object, Object> targetDataSourcesMap) {
super.setDefaultTargetDataSource(defaultTargetDataSource);
super.setTargetDataSources(targetDataSourcesMap);
super.afterPropertiesSet();
}
@Override
protected Object determineCurrentLookupKey() {
return DynamicDataSourceContextHolder.getDataSourceType();
}
}
2.2.10、Aop方式拦截
import cn.xiyou.config.DataSource;
import cn.xiyou.config.DynamicDataSourceContextHolder;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
@Aspect
@Order(1)
@Component
public class DataSourceAspect {
private Logger log = LoggerFactory.getLogger(getClass());
@Pointcut("@annotation(cn.xiyou.config.DataSource)")
public void dsPointCut() {
}
@Around("dsPointCut()")
public Object around(ProceedingJoinPoint point) {
MethodSignature signature = (MethodSignature) point.getSignature();
Method method = signature.getMethod();
DataSource dataSource = method.getAnnotation(DataSource.class);
if (dataSource != null) {
log.info("【before数据源名】" + dataSource.value().name());
DynamicDataSourceContextHolder.setDataSourceType(dataSource.value().name());
log.info("【after数据源名】" + dataSource.value().name());
}
Object obj = null;
try {
obj = point.proceed();
} catch (Throwable throwable) {
throwable.printStackTrace();
} finally {
// 销毁数据源 在执行方法之后
DynamicDataSourceContextHolder.clearDataSourceType();
}
return obj;
}
}
2.2.11、配置动态表前缀 DynamicTableName
我这边配置这个是因为存在跨账号查询数据库表的情况,这里请根据实际项目情况配置，没有这种需求请跳过
1、这里 IgnoreDBEnum 是用来过滤要查询 系统默认表的，系统表不能加前缀查询，否则会报视图不存在的SQL 问题。
2、使用 if(DataSourceType.SLAVE.name().equalsIgnoreCase(DynamicDataSourceContextHolder.getDataSourceType()))实现动态加表前缀
public enum IgnoreDBEnum {
ALL_TABLES,
ALL_TAB_COLUMNS,
ALL_TAB_PRIVS,
ALL_CONSTRAINTS,
ALL_CONS_COLUMNS ;
}
import com.baomidou.mybatisplus.extension.plugins.handler.TableNameHandler;
import com.mvno.common.db.HbueDBEnum;
import com.mvno.common.domain.DbProperties;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
public class DynamicTableNameHandler implements TableNameHandler {
private final List<String> ignoreTabs=new ArrayList<String>(){
{
for (IgnoreDBEnum tables : IgnoreDBEnum.values()) {
add(tables.name());
}
}
};
@Override
public String dynamicTableName(String sql, String tableName) {
if (ignoreTabs != null && ignoreTabs.size() > 0) {
for (String ignoreTab : ignoreTabs) {
if (ignoreTab.equalsIgnoreCase(tableName)) {
return tableName;
}
}
}
log.info("Data Source Type: {}", DynamicDataSourceContextHolder.getDataSourceType());
if(DataSourceType.SLAVE.name().equalsIgnoreCase(DynamicDataSourceContextHolder.getDataSourceType())){
return DbProperties.slaveSchema + "." + tableName;
}else{
return DbProperties.masterSchema + "." + tableName;
}
}
}
2.2.12、继承 InnerInterceptor
import com.baomidou.mybatisplus.core.plugins.InterceptorIgnoreHelper;
import com.baomidou.mybatisplus.core.toolkit.PluginUtils;
import com.baomidou.mybatisplus.core.toolkit.TableNameParser;
import com.baomidou.mybatisplus.extension.plugins.inner.InnerInterceptor;
import com.mvno.common.utils.MvnoSqlHolder;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlCommandType;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
public class MvnoSqlInnerInterceptor implements InnerInterceptor {
private MonthTableNameHandler tableNameHandler;
@Override
public void beforePrepare(StatementHandler sh, Connection connection, Integer transactionTimeout) {
PluginUtils.MPStatementHandler mpSh = PluginUtils.mpStatementHandler(sh);
MappedStatement ms = mpSh.mappedStatement();
SqlCommandType sct = ms.getSqlCommandType();
if (sct == SqlCommandType.SELECT || sct == SqlCommandType.UPDATE || sct == SqlCommandType.DELETE) {
if (InterceptorIgnoreHelper.willIgnoreDynamicTableName(ms.getId())) {
return;
}
PluginUtils.MPBoundSql mpBs = mpSh.mPBoundSql();
mpBs.sql(this.changeTable(mpBs.sql(),connection));
}
}
protected String changeTable(String sql) {
TableNameParser parser = new TableNameParser(sql);
List<TableNameParser.SqlToken> names = new ArrayList<>();
parser.accept(names::add);
StringBuilder builder = new StringBuilder();
int last = 0;
for (TableNameParser.SqlToken name : names) {
int start = name.getStart();
if (start != last) {
builder.append(sql, last, start);
builder.append(tableNameHandler.dynamicTableName(sql, name.getValue()));
}
last = name.getEnd();
}
if (last != sql.length()) {
builder.append(sql.substring(last));
}
return builder.toString();
}
public InnerInterceptor setTableNameHandler(DynamicTableNameHandler tableNameHandler) {
this.tableNameHandler = tableNameHandler;
return this;
}
}
2.2.13、数据源关闭连接问题
[com.alibaba.druid.util.JdbcUtils:109 ] - close statement error
java.sql.SQLRecoverableException: 关闭的连接
2.2.13.1、application.yml 配置
2.2.13.1.1、druid
这里引入的是专门为spring boot打造的druid-spring-boot-starter,如果引入的是druid则需要配置xml
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>{druid.version}</version>
</dependency>
druid参数可以不写，会按照默认参数处理，需要指定type
spring:
datasource:
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql:///:3306/数据库名?useSSL=false&useUnicode=true&characterEncoding=UTF-8
username:
password:
type: com.alibaba.druid.pool.DruidDataSource
druid:
initial-size: 10 # 初始化时建立物理连接的个数。初始化发生在显示调用init方法，或者第一次getConnection时
min-idle: 10 # 最小连接池数量
maxActive: 200 # 最大连接池数量
maxWait: 60000 # 获取连接时最大等待时间，单位毫秒。配置了maxWait之后，缺省启用公平锁，并发效率会有所下降，如果需要可以通过配置
timeBetweenEvictionRunsMillis: 60000 # 关闭空闲连接的检测时间间隔.Destroy线程会检测连接的间隔时间，如果连接空闲时间大于等于minEvictableIdleTimeMillis则关闭物理连接。
minEvictableIdleTimeMillis: 300000 # 连接的最小生存时间.连接保持空闲而不被驱逐的最小时间
validationQuery: SELECT 1 FROM DUAL # 验证数据库服务可用性的sql.用来检测连接是否有效的sql 因数据库方言而差, 例如 oracle 应该写成 SELECT 1 FROM DUAL
testWhileIdle: true # 申请连接时检测空闲时间，根据空闲时间再检测连接是否有效.建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRun
testOnBorrow: false # 申请连接时直接检测连接是否有效.申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。
testOnReturn: false # 归还连接时检测连接是否有效.归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。
poolPreparedStatements: true # 开启PSCache
maxPoolPreparedStatementPerConnectionSize: 20 #设置PSCache值
connectionErrorRetryAttempts: 3 # 连接出错后再尝试连接三次
breakAfterAcquireFailure: true # 数据库服务宕机自动重连机制
timeBetweenConnectErrorMillis: 300000 # 连接出错后重试时间间隔
asyncInit: true # 异步初始化策略
remove-abandoned: true # 是否自动回收超时连接
remove-abandoned-timeout: 1800 # 超时时间(以秒数为单位)
transaction-query-timeout: 6000 # 事务超时时间
filters: stat,wall,log4j2
useGlobalDataSourceStat: true #合并多个DruidDataSource的监控数据
connectionProperties: druid.stat.mergeSql\=true;druid.stat.slowSqlMillis\=5000 #通过connectProperties属性来打开mergeSql功能；慢SQL记录
2.2.13.1.2、hikari
在spring boot2中引入jdbc的时候如果没有显式指定数据库连接池，默认使用的就是hikari连接池
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
druid一样，可以使用默认参数
spring:
datasource:
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql:///:3306/数据库名?useSSL=false&useUnicode=true&characterEncoding=UTF-8
username:
password:
type: com.zaxxer.hikari.HikariDataSource
hikari:
# 连接池中允许的最小连接数。缺省值：10
minimum-idle: 10
# 连接池中允许的最大连接数。缺省值：10
maximum-pool-size: 100
# 自动提交
auto-commit: true
# 一个连接idle状态的最大时长（毫秒），超时则被释放（retired），缺省:10分钟
idle-timeout: 600
# 连接池名字
pool-name: 泡泡的HikariCP
# 一 个连接的生命时长（毫秒），超时而且没被使用则被释放（retired），缺省:30分钟，建议设置比数据库超时时长少30秒
max-lifetime: 1800000
# 等待连接池分配连接的最大时长（毫秒），超过这个时长还没可用的连接则发生SQLException， 缺省:30秒
connection-timeout: 30000
2.2.13.2、在config中配置
initial-size: 10 # 初始化时建立物理连接的个数。初始化发生在显示调用init方法，或者第一次getConnection时
min-idle: 10 # 最小连接池数量
maxActive: 200 # 最大连接池数量
maxWait: 60000 # 获取连接时最大等待时间，单位毫秒。配置了maxWait之后，缺省启用公平锁，并发效率会有所下降，如果需要可以通过配置
timeBetweenEvictionRunsMillis: 60000 # 关闭空闲连接的检测时间间隔.Destroy线程会检测连接的间隔时间，如果连接空闲时间大于等于minEvictableIdleTimeMillis则关闭物理连接。
minEvictableIdleTimeMillis: 300000 # 连接的最小生存时间.连接保持空闲而不被驱逐的最小时间
validationQuery: SELECT 1 FROM DUAL # 验证数据库服务可用性的sql.用来检测连接是否有效的sql 因数据库方言而差, 例如 oracle 应该写成 SELECT 1 FROM DUAL
testWhileIdle: true # 申请连接时检测空闲时间，根据空闲时间再检测连接是否有效.建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRun
testOnBorrow: false # 申请连接时直接检测连接是否有效.申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。
testOnReturn: false # 归还连接时检测连接是否有效.归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。
poolPreparedStatements: true # 开启PSCache
maxPoolPreparedStatementPerConnectionSize: 20 #设置PSCache值
connectionErrorRetryAttempts: 3 # 连接出错后再尝试连接三次
breakAfterAcquireFailure: true # 数据库服务宕机自动重连机制
timeBetweenConnectErrorMillis: 300000 # 连接出错后重试时间间隔
asyncInit: true # 异步初始化策略
remove-abandoned: true # 是否自动回收超时连接
remove-abandoned-timeout: 1800 # 超时时间(以秒数为单位)
transaction-query-timeout: 6000 # 事务超时时间
filters: stat,wall,log4j2
useGlobalDataSourceStat: true #合并多个DruidDataSource的监控数据
connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000 #通过connectProperties属性来打开mergeSql功能；慢SQL记录
DruidDataSource dataSource = DruidDataSourceBuilder.create().build();
dataSource.setDriverClassName(DbProperties.slaveDriver);
dataSource.setUsername(DbProperties.slaveUserName);
dataSource.setPassword(DbProperties.slavePassword);
dataSource.setUrl(DbProperties.slaveUrl);
dataSource.setMaxWait(60000);
dataSource.setMinEvictableIdleTimeMillis(300000);
2.2.14、多数据源配置的使用
- 1、使用 @DS 注解切换数据源时，使用springboot数据源的自动配置，需要将DataSourceConfig配置注释掉
- 2、使用 @DataSource 自定义注解时，排除springboot数据源的自动配置，引入DataSourceConfig配置
2.2.14.1、使用master主数据源（不需做任何操作，和之前单数据库一样）
import java.util.List;
import cn.xiyou.config.DataSource;
import cn.xiyou.config.DataSourceType;
import cn.xiyou.pojo.Dept;
import org.apache.ibatis.annotations.Param;
public interface DeptMapper extends BaseMapper<Dept> {
/**
* xml 自定义的查询方法
*
* @return
*/
// @DataSource(value = DataSourceType.MASTER)
List<Dept> findAll();
List<Dept> findAllByOrgCode(@Param("orgCode") String orgCode);
}
@Service
public interface DeptServiceImpl implements DeptService {
@Autowired
private DeptMapper deptMapper;
/**
* 使用 xml 自定义的查询方法
*
* @return
*/
public List<Dept> selectThreeTreeNode(String faultDate) {
return deptMapper.findAll();
}
/**
* 使用 mybatis plus 的查询方法
*
* @return
*/
public List<Dept> list(String faultDate) {
return deptMapper.list();
}
}
2.2.14.2、使用slave数据源
import cn.xiyou.config.DataSource;
import cn.xiyou.config.DataSourceType;
import cn.xiyou.pojo.ZTree;
import java.util.List;
public interface TreeMapper extends BaseMapper<ZTree> {
@DataSource(value = DataSourceType.SLAVE)
List<ZTree> selectThreeTreeNode();
@DataSource(value = DataSourceType.SLAVE)
@Select("SELECT COUNT(*) AS total FROM HBUE_LOOKUP_VPLMN_OPERATOR")
int findCount();
}
@Service
@DS("slave")
public interface TreeServiceImpl implements TreeService {
@Autowired
private TreeMapper treeMapper;
/**
* 使用 xml 自定义的查询方法
*
* @return
*/
@DataSource(value = DataSourceType.SLAVE)
public List<ZTree> selectThreeTreeNode(String faultDate) {
return treeMapper.selectThreeTreeNode();
}
/**
* 使用 mybatis plus 的查询方法
*
* @return
*/
@DataSource(value = DataSourceType.SLAVE)
public List<ZTree> list(String faultDate) {
return deptMapper.list();
}
}
2.2.14.3、实现效果
2.2.14.4、 Q&A
2.2.14.4.1 @Transactional 和 @DS 注解一起使用时, @DS失效的问题
这是因为 @Transactional 开启事务后, 就不会重新拿数据源,因为@DS也得通过切面去获取数据源, 这样就导致了@DS失效.
要解决的话, 就在要切换数据源的方法上也打上@DS, 或者多个数据源有修改操作可以都打上事务注解并改变传播机制,(但这其实是分布式事务的范畴, 这样操作不能保证事务了, plus也提供了
@DSTransactional 来支持, 不够需要借助seata)
2.2.14.4.2 针对@Transactional与@DSTransactional做一个简单的解释。
@Transactional是spring的注解目的就是开启事务，所以在该注解被扫描到的时候就去获取DataSource，此时DynamicDataSourceContextHolder队列中无任务元素，所以获取到的dsKey就是null，之后通过DynamicRoutingDataSource方法中的determinePrimaryDataSource获取主库的DataSource。
@DSTransactional是mp中的注解，该注解下的所有@DS注解在invoke方法中向DynamicDataSourceContextHolder中压入元素，之后在获取determineDataSource的时候或获取到一个dsKey从而选择正确的DataSource。
2.2.14.4.3. 低于V3.3.3版本无法切换数据源的问题
这是因为在V3.3.3版本之前, DruidDataSourceAutoConfigure会比DynamicDataSourceAutoConfiguration先注册, 导致数据库有读取druid的配置, 所以会出现 ,没有druid配置启动报错; 数据源无法切换等等原因, 官方在V3.3.3这个版本修复了, 但是这个版本有个其他的重点bug,官方不让下载, 所以github上找不到这个版本的描述, 只在官网有描述
分两步解决的,
1、去除 druid pom坐标
2、在 DynamicDataSourceAutoConfiguration 上指定优于 DruidDataSourceAutoConfigure加载
解决办法就是排除DruidDataSourceAutoConfigure 类;
2.2.14.4.4、一般使用都是在需要切换数据库在使用中发现经常出现几个小问题，
1、发现配置多数据源之后批量执行的方法都走的主库。
2、针对相同库的事务如何处理。
3、针对不同库的事务如何处理。
在使用多数据源的时候可以开启debug日志查看在每次创建SqlSession之后选用的是哪个数据源。例如：
- 1、针对问题1，在使用mp的时候可能执行一些批量的方法，比如saveBatch等，进入saveBatch方法中可以看到在这个方法上默认有@Transactional注解，对于该注解默认使用的都是主库，所以对于从库的一些操作因为无法切换从库产生一些问题。解决方法：
针对问题1的：同一个源的批量操作，可以在外部方法使用@DS(“bbb”)优先指定需要操作的源。
针对问题1的：不同源的批量操作，可以考虑自己实现批量操作等。
-
2、针对问题2，针对相同库的事务，可以使用@DS与@Transactional搭配实现
-
3、针对问题3，这对不同库的事务，可以使用@DSTransactional实现
总结一些：对于mp的多数据源的事务或者查询问题首先看每次sql执行时选择的源，另外使用@DS与@Transactional与@DSTransactional三个注解基本可以解决遇到的事务失效等问题。
针对三个注解给一个描述语：
@DS：就是用来切换数据源
@Transactional：默认只针对主库
@DSTransactional：可以理解为在事务中可以切换数据源
