后台管理项目的多数据源方案
引言
在互联网开发公司中，往往伴随着业务的快速迭代，程序员可能没有过多的时间去思考技术扩展的相关问题，长久下来导致技术过于单一。为此最近在学习互联网思维，从相对简单的功能开始做总结，比如非常常见的基础数据的后台管理，那么涉及到多数据源的情况又会有哪些问题呢？
思考1：在业务中如何更加灵活方便的切换数据源呢？
思考2：多数据源之间的事务如何保证呢？
思考3：这种多数据源的分布式事务实现思路有哪些？
本篇文章的重点，也就是多数据源问题总结为以下三种方式：
使用Spring提供的AbstractRoutingDataSource
准备工作：
首先AbstractRoutingDataSource是jdbc包提供的，需要引入依赖：
org.springframework.boot
spring-boot-starter-jdbc
自定义一个类继承AbstractRoutingDataSource，重写关键方法：
@Component
@Primary
public class DynamicDatasource extends AbstractRoutingDataSource
{
public static ThreadLocal dataSourceName = new ThreadLocal<>();
@Autowired
DataSource dataSource1;
@Autowired
DataSource dataSource2;
@Override
protected Object determineCurrentLookupKey()
{
return dataSourceName.get();
}
@Override
public void afterPropertiesSet()
{
Map targetDataSources = new HashMap<>();
targetDataSources.put("W", dataSource1); //写数据库，主库
targetDataSources.put("R", dataSource2); //读数据库，从库
super.setTargetDataSources(targetDataSources);
super.setDefaultTargetDataSource(dataSource1);
super.afterPropertiesSet();
}
} 配置多个数据源：
@Configuration
public class DataSourceConfig
{
@Bean
@ConfigurationProperties(prefix = "spring.datasource.datasource1")
public DataSource dataSource1()
{
return DruidDataSourceBuilder.create().build();
}
@Bean
@ConfigurationProperties(prefix = "spring.datasource.datasource2")
public DataSource dataSource2()
{
return DruidDataSourceBuilder.create().build();
}
@Bean
public DataSourceTransactionManager transactionManager1(DynamicDatasource dataSource)
{
DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
dataSourceTransactionManager.setDataSource(dataSource);
return dataSourceTransactionManager;
}
@Bean
public DataSourceTransactionManager transactionManager2(DynamicDatasource dataSource)
{
DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
dataSourceTransactionManager.setDataSource(dataSource);
return dataSourceTransactionManager;
}
}application.yml参考配置：
spring:
datasource:
type: com.alibaba.druid.pool.DruidDataSource
datasource1:
url: jdbc:mysql://127.0.0.1:3306/datasource1?serverTimezone=UTC&useUnicode=true&characterEncoding=UTF8&useSSL=false
username: root
password: 123666
initial-size: 1
min-idle: 1
max-active: 20
test-on-borrow: true
driver-class-name: com.mysql.cj.jdbc.Driver
datasource2:
url: jdbc:mysql://127.0.0.1:3306/datasource2?serverTimezone=UTC&useUnicode=true&characterEncoding=UTF8&useSSL=false
username: root
password: 123666
initial-size: 1
min-idle: 1
max-active: 20
test-on-borrow: true
driver-class-name: com.mysql.cj.jdbc.Drivermin-idle，最小空闲连接，不会被销毁的数据库连接。注意：如果设置的太小，当客户端连接多的情况下，就需要新创建数据库连接，是一个比较耗时的操作，可能导致客户端连接超时。设置太大会占用系统资源
max-active：最大活跃数，官网建议配置：正在使用的数据库连接数 / 配置的这个值 = 85%
test-on-borrow：每次连接时都进行检查，生产上配置为true会影响性能，建议false，默认也是false
test-on-return：每次归还连接时进行检查，同样影响性能同上
生产上建议上面两个参数设置false，testWhileIdle设置为true，间隔一段时间检查连接是否可用：
空闲时间大于timeBetweenEvictionRunsMillis（默认1分钟）检查一次，检查发现连接失效也不会马上删除，而是空闲时间超过minEvictableIdleTimeMillis（最小空闲时间，默认30分钟）自动删除
maxEvictableIdleTimeMillis：最大空闲时间，默认7小时。空闲连接时间过长，数据库就会自动把连接关闭，Druid为了防止从连接池中拿到被数据库关闭的连接，设置了这个参数，超过时间强行关闭连接
使用测试：
方案一，直接在方法中设置数据源标识，简单实现功能，缺点也很明显
@Service
public class FriendServiceImpl implements FriendService
{
@Autowired
FriendMapper friendMapper;
@Override
public List list()
{
DynamicDatasource.dataSourceName.set("R");
return friendMapper.list();
}
@Override
public void save(Friend friend)
{
DynamicDatasource.dataSourceName.set("W");
friendMapper.save(friend);
}
} 方案二，使用自定义注解+AOP实现，适合不同业务的多数据源场景
// 1、自定义注解：
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface WR
{
String value() default "W";
}
// 2、切面配置类
@Component
@Aspect
public class DynamicDataSourceAspect
{
@Before("within(com.example.dynamicdatasource.service.impl.*) && @annotation(wr)")
public void before(JoinPoint joinPoint, WR wr)
{
String value = wr.value();
DynamicDatasource.dataSourceName.set(value);
System.out.println(value);
}
}
// 3、使用注解测试
@Service
public class FriendServiceImpl implements FriendService
{
@Autowired
FriendMapper friendMapper;
@WR("R")
@Override
public List list()
{
// DynamicDatasource.dataSourceName.set("R");
return friendMapper.list();
}
@WR("W")
@Override
public void save(Friend friend)
{
// DynamicDatasource.dataSourceName.set("W");
friendMapper.save(friend);
}
} 方案三，使用MyBatis插件，适合相同业务读写分离的业务场景
import com.example.dynamicdatasource.DynamicDatasource;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlCommandType;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.springframework.stereotype.Component;
import java.util.Properties;
@Component
@Intercepts({@Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class}),
@Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class,
ResultHandler.class})})
public class DynamicDataSourcePlugin implements Interceptor
{
@Override
public Object intercept(Invocation invocation)
throws Throwable
{
Object[] objects = invocation.getArgs();
MappedStatement ms = (MappedStatement)objects[0];
if (ms.getSqlCommandType().equals(SqlCommandType.SELECT))
{
DynamicDatasource.dataSourceName.set("R");
}
else
{
DynamicDatasource.dataSourceName.set("W");
}
return invocation.proceed();
}
@Override
public Object plugin(Object target)
{
if (target instanceof Executor)
{
return Plugin.wrap(target, this);
}
else
{
return target;
}
}
@Override
public void setProperties(Properties properties)
{
}
}使用MyBatis注册多个sqlSessionFactory
实现思路：Spring集成多个MyBatis框架，指定不同的扫描包、不同的数据源
准备工作：
读库和写库分别添加配置类，扫描不同的包路径：
@Configuration
@MapperScan(basePackages = "com.example.dynamicmybatis.mapper.r", sqlSessionFactoryRef = "rSqlSessionFactory")
public class RMyBatisConfig
{
@Bean
@ConfigurationProperties(prefix = "spring.datasource.datasource2")
public DataSource dataSource2()
{
return DruidDataSourceBuilder.create().build();
}
@Bean
public DataSourceTransactionManager rTransactionManager()
{
DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
dataSourceTransactionManager.setDataSource(dataSource2());
return dataSourceTransactionManager;
}
@Bean
public SqlSessionFactory rSqlSessionFactory()
throws Exception
{
final SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
sqlSessionFactoryBean.setDataSource(dataSource2());
return sqlSessionFactoryBean.getObject();
}
@Bean
public TransactionTemplate rTransactionTemplate()
{
return new TransactionTemplate(rTransactionManager());
}
}
@Configuration
@MapperScan(basePackages = "com.example.dynamicmybatis.mapper.w", sqlSessionFactoryRef = "wSqlSessionFactory")
public class WMyBatisConfig
{
@Bean
@ConfigurationProperties(prefix = "spring.datasource.datasource1")
public DataSource dataSource1()
{
return DruidDataSourceBuilder.create().build();
}
@Bean
public DataSourceTransactionManager wTransactionManager()
{
DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
dataSourceTransactionManager.setDataSource(dataSource1());
return dataSourceTransactionManager;
}
@Bean
public SqlSessionFactory wSqlSessionFactory()
throws Exception
{
final SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
sqlSessionFactoryBean.setDataSource(dataSource1());
return sqlSessionFactoryBean.getObject();
}
@Bean
public TransactionTemplate wTransactionTemplate()
{
return new TransactionTemplate(wTransactionManager());
}
}写库和读库使用两个Mapper类，在不同的包下：
public interface RFriendMapper
{
@Select("select * from friend")
List list();
@Insert("insert into friend(name) values(#{name})")
void save(Friend friend);
}
public interface WFriendMapper
{
@Select("select * from friend")
List list();
@Insert("insert into friend(name) values(#{name})")
void save(Friend friend);
} 使用测试：
@Service
public class FriendServiceImpl implements FriendService
{
@Autowired
RFriendMapper rFriendMapper;
@Autowired
WFriendMapper wFriendMapper;
@Override
public List list()
{
return rFriendMapper.list();
}
@Override
public void save(Friend friend)
{
wFriendMapper.save(friend);
}
} 思考：多数据源的事务问题
public void saveW(Friend friend)
{
friend.setName("gaoW");
wFriendMapper.save(friend);
}
public void saveR(Friend friend)
{
friend.setName("gaoR");
rFriendMapper.save(friend);
}
@Transactional
// @Transactional(transactionManager = "wTransactionManager")
@Override
public void saveAll(Friend friend)
{
saveW(friend);
saveR(friend);
int a = 1 / 0;
}存在多个事务管理器的情况直接使用@Transactional注解是不行的，Spring不知道使用哪个事务管理器会报错。但是指定了事务管理器后，仅当前事务管理器负责的部分支持回滚，还是存在问题。
在特定场景下，直接指定事务管理器名称的方式可以生效（保证数据一致的意思）：
@Transactional(transactionManager = "wTransactionManager")
@Override
public void saveAll(Friend friend)
{
saveW(friend);
saveR(friend);
int a = 1 / 0;
}1、saveW方法内部异常，saveW发生异常事务不提交，数据一致
2、saveR方法内部异常，事务管理器回滚saveW的更新，saveR异常未提交，数据一致
3、saveW和saveR方法中间的业务发生异常，事务管理器回滚saveW的更新，saveR未提交，数据一致
4、saveW和saveR方法后面的业务发生异常，事务管理器回滚saveW的更新，saveR已提交，数据不一致
Spring提供的编程式事务解决方案：
@Service
public class FriendServiceImpl implements FriendService
{
@Autowired
RFriendMapper rFriendMapper;
@Autowired
WFriendMapper wFriendMapper;
@Autowired
TransactionTemplate rTransactionTemplate;
@Autowired
TransactionTemplate wTransactionTemplate;
public void saveW(Friend friend)
{
friend.setName("gaoW");
wFriendMapper.save(friend);
}
public void saveR(Friend friend)
{
friend.setName("gaoR");
rFriendMapper.save(friend);
}
@Override
public void saveAll2(Friend friend)
{
wTransactionTemplate.execute(wstatus -> {
rTransactionTemplate.execute(rstatus -> {
try
{
saveW(friend);
saveR(friend);
// int a = 1 / 0;
}
catch (Exception e)
{
e.printStackTrace();
wstatus.setRollbackOnly();
rstatus.setRollbackOnly();
return false;
}
return true;
});
return true;
});
}
}Spring支持的声明式事务解决方案（分布式事务变种实现）：
@Service
public class FriendServiceImpl implements FriendService
{
@Autowired
RFriendMapper rFriendMapper;
@Autowired
WFriendMapper wFriendMapper;
@Autowired
TransactionTemplate rTransactionTemplate;
@Autowired
TransactionTemplate wTransactionTemplate;
@Override
public List list()
{
return rFriendMapper.list();
}
@Override
public void save(Friend friend)
{
wFriendMapper.save(friend);
}
public void saveW(Friend friend)
{
friend.setName("gaoW");
wFriendMapper.save(friend);
}
public void saveR(Friend friend)
{
friend.setName("gaoR");
rFriendMapper.save(friend);
}
@Transactional(transactionManager = "wTransactionManager")
@Override
public void saveAll1(Friend friend)
{
FriendService friendService = (FriendService)AopContext.currentProxy();
friendService.saveAllR(friend);
}
@Transactional(transactionManager = "rTransactionManager")
@Override
public void saveAllR(Friend friend)
{
saveW(friend);
saveR(friend);
// int a = 1 / 0;
}
}
@EnableAspectJAutoProxy(exposeProxy = true) //暴露代理对象
public class DynamicMybatisApplication { 注意：调用saveAllR方式时，需要使用代理对象，直接调用本类的其他方法事务不会生效
@Autowired自动注入自己获取代理对象，这种方式在springboot2.6以后有循环依赖报错，需要改配置，按照错误提示添加配置，设置参数为true即可
上面这两种事务的解决方式适用场景：
只涉及到两三个数据源，并且多数据源事务的场景不多，同时公司又不希望引入其他组件（安全性问题考虑），那么就可以使用这种方式实现分布式事务。当然分布式事务最好的解决方案肯定是通过第三方组件比如Seata
使用dynamic-datasource框架
dynamic-datasource是属于苞米豆生态圈的
基于Springboot的多数据源组件，功能强悍，支持Seata事务
-
支持数据源分组，适用多库、读写分离、一主多从（实现了负载均衡，轮询/随机）等场景
-
提供自定义数据源方案，比如从数据库加载
-
提供项目启动后动态增加和删除数据源方案，可以添加管理后台页面灵活调整
-
提供MyBatis环境下的纯读写分离方案
-
提供本地多数据源事务方案
-
提供基于Seata的分布式事务方案，注意不能和原生spring事务混用
-
等等
多数据源实现方式：就是通过继承AbstractRoutingDataSource的这种方式
数据源切换：通过AOP+自定义注解实现的
使用示例：
@Service
public class FriendServiceImpl implements FriendService
{
@Autowired
FriendMapper friendMapper;
@Override
@DS("slave")
public List list()
{
return friendMapper.list();
}
@Override
@DS("master")
@DSTransactional
public void save(Friend friend)
{
friendMapper.save(friend);
}
@DS("master")
@DSTransactional
public void saveAll()
{
// 执行多数据源的操作
}
} application.yml参考配置：
spring:
datasource:
dynamic:
#设置默认的数据源或者数据源组,默认值即为master
primary: master
#严格匹配数据源,默认false. true未匹配到指定数据源时抛异常,false使用默认数据源
strict: false
datasource:
master:
url: jdbc:mysql://127.0.0.1:3306/datasource1?serverTimezone=UTC&useUnicode=true&characterEncoding=UTF8&useSSL=false
username: root
password: 123666
initial-size: 1
min-idle: 1
max-active: 20
test-on-borrow: true
driver-class-name: com.mysql.cj.jdbc.Driver
slave_1:
url: jdbc:mysql://127.0.0.1:3306/datasource2?serverTimezone=UTC&useUnicode=true&characterEncoding=UTF8&useSSL=false
username: root
password: 123666
initial-size: 1
min-idle: 1
max-active: 20
test-on-borrow: true
driver-class-name: com.mysql.cj.jdbc.Driver