查看: 1911|回复: 0

[Java代码] Spring Boot + Mybatis多数据源和动态数据源配置方法

发表于 2018-2-25 08:00:00

网上的文章基本上都是只有多数据源或只有动态数据源,而最近的项目需要同时使用两种方式,记录一下配置方法供大家参考。

应用场景

项目需要同时连接两个不同的数据库A, B,并且它们都为主从架构,一台写库,多台读库。

多数据源

首先要将spring boot自带的DataSourceAutoConfiguration禁掉,因为它会读取application.properties文件的spring.datasource.*属性并自动配置单数据源。在@SpringBootApplication注解中添加exclude属性即可:

  1. @SpringBootApplication(exclude = {
  2. DataSourceAutoConfiguration.class
  3. })
  4. public class TitanWebApplication {
  5. public static void main(String[] args) {
  6. SpringApplication.run(TitanWebApplication.class, args);
  7. }
  8. }
复制代码

然后在application.properties中配置多数据源连接信息:

  1. # titan库
  2. spring.datasource.titan-master.url=jdbc:mysql://X.X.X.X:port/titan?characterEncoding=UTF-8
  3. spring.datasource.titan-master.username=
  4. spring.datasource.titan-master.password=
  5. spring.datasource.titan-master.driver-class-name=com.mysql.jdbc.Driver
  6. # 连接池配置
  7. # 省略
  8. # 其它库
  9. spring.datasource.db2.url=jdbc:mysql://X.X.X.X:port/titan2?characterEncoding=UTF-8
  10. spring.datasource.db2.username=
  11. spring.datasource.db2.password=
  12. spring.datasource.db2.driver-class-name=com.mysql.jdbc.Driver
复制代码

由于我们禁掉了自动数据源配置,因些下一步就需要手动将这些数据源创建出来:

  1. @Configuration
  2. public class DataSourceConfig {
  3. @Bean(name = "titanMasterDS")
  4. @ConfigurationProperties(prefix = "spring.datasource.titan-master") // application.properteis中对应属性的前缀
  5. public DataSource dataSource1() {
  6. return DataSourceBuilder.create().build();
  7. }
  8. @Bean(name = "ds2")
  9. @ConfigurationProperties(prefix = "spring.datasource.db2") // application.properteis中对应属性的前缀
  10. public DataSource dataSource2() {
  11. return DataSourceBuilder.create().build();
  12. }
  13. }
复制代码

接下来需要配置两个mybatis的SqlSessionFactory分别使用不同的数据源:

  1. @Configuration
  2. @MapperScan(basePackages = {"titan.mapper"}, sqlSessionFactoryRef = "sqlSessionFactory1")
  3. public class MybatisDbAConfig {
  4. @Autowired
  5. @Qualifier("titanMasterDS")
  6. private DataSource ds1;
  7. @Bean
  8. public SqlSessionFactory sqlSessionFactory1() throws Exception {
  9. SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
  10. factoryBean.setDataSource(ds1); // 使用titan数据源, 连接titan库
  11. return factoryBean.getObject();
  12. }
  13. @Bean
  14. public SqlSessionTemplate sqlSessionTemplate1() throws Exception {
  15. SqlSessionTemplate template = new SqlSessionTemplate(sqlSessionFactory1()); // 使用上面配置的Factory
  16. return template;
  17. }
  18. }
复制代码

经过上面的配置后,titan.mapper下的Mapper接口,都会使用titan数据源。同理可配第二个SqlSessionFactory:

  1. @Configuration
  2. @MapperScan(basePackages = {"other.mapper"}, sqlSessionFactoryRef = "sqlSessionFactory2")
  3. public class MybatisDbBConfig {
  4. @Autowired
  5. @Qualifier("ds2")
  6. private DataSource ds2;
  7. @Bean
  8. public SqlSessionFactory sqlSessionFactory2() throws Exception {
  9. SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
  10. factoryBean.setDataSource(ds2);
  11. return factoryBean.getObject();
  12. }
  13. @Bean
  14. public SqlSessionTemplate sqlSessionTemplate2() throws Exception {
  15. SqlSessionTemplate template = new SqlSessionTemplate(sqlSessionFactory2());
  16. return template;
  17. }
  18. }
复制代码

完成这些配置后,假设有2个Mapper titan.mapper.UserMapper和other.mapper.RoleMapper,使用前者时会自动连接titan库,后者连接ds2库。

动态数据源

使用动态数据源的初衷,是能在应用层做到读写分离,即在程序代码中控制不同的查询方法去连接不同的库。除了这种方法以外,数据库中间件也是个不错的选择,它的优点是数据库集群对应用来说只暴露为单库,不需要切换数据源的代码逻辑。

我们通过自定义注解 + AOP的方式实现数据源动态切换。

首先定义一个ContextHolder, 用于保存当前线程使用的数据源名:

  1. public class DataSourceContextHolder {
  2. public static final Logger log = LoggerFactory.getLogger(DataSourceContextHolder.class);
  3. /**
  4. * 默认数据源
  5. */
  6. public static final String DEFAULT_DS = "titan-master";
  7. private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();
  8. // 设置数据源名
  9. public static void setDB(String dbType) {
  10. log.debug("切换到{}数据源", dbType);
  11. contextHolder.set(dbType);
  12. }
  13. // 获取数据源名
  14. public static String getDB() {
  15. return (contextHolder.get());
  16. }
  17. // 清除数据源名
  18. public static void clearDB() {
  19. contextHolder.remove();
  20. }
  21. }
复制代码

然后自定义一个javax.sql.DataSource接口的实现,这里只需要继承Spring为我们预先实现好的父类AbstractRoutingDataSource即可:

  1. public class DynamicDataSource extends AbstractRoutingDataSource {
  2. private static final Logger log = LoggerFactory.getLogger(DynamicDataSource.class);
  3. @Override
  4. protected Object determineCurrentLookupKey() {
  5. log.debug("数据源为{}", DataSourceContextHolder.getDB());
  6. return DataSourceContextHolder.getDB();
  7. }
  8. }
复制代码

创建动态数据源:

  1. /**
  2. * 动态数据源: 通过AOP在不同数据源之间动态切换
  3. * @return
  4. */
  5. @Bean(name = "dynamicDS1")
  6. public DataSource dataSource() {
  7. DynamicDataSource dynamicDataSource = new DynamicDataSource();
  8. // 默认数据源
  9. dynamicDataSource.setDefaultTargetDataSource(dataSource1());
  10. // 配置多数据源
  11. Map<Object, Object> dsMap = new HashMap(5);
  12. dsMap.put("titan-master", dataSource1());
  13. dsMap.put("ds2", dataSource2());
  14. dynamicDataSource.setTargetDataSources(dsMap);
  15. return dynamicDataSource;
  16. }
复制代码

自定义注释@DS用于在编码时指定方法使用哪个数据源:

  1. @Retention(RetentionPolicy.RUNTIME)
  2. @Target({
  3. ElementType.METHOD
  4. })
  5. public @interface DS {
  6. String value() default "titan-master";
  7. }
复制代码

编写AOP切面,实现切换逻辑:

  1. @Aspect
  2. @Component
  3. public class DynamicDataSourceAspect {
  4. @Before("@annotation(DS)")
  5. public void beforeSwitchDS(JoinPoint point){
  6. //获得当前访问的class
  7. Class<?> className = point.getTarget().getClass();
  8. //获得访问的方法名
  9. String methodName = point.getSignature().getName();
  10. //得到方法的参数的类型
  11. Class[] argClass = ((MethodSignature)point.getSignature()).getParameterTypes();
  12. String dataSource = DataSourceContextHolder.DEFAULT_DS;
  13. try {
  14. // 得到访问的方法对象
  15. Method method = className.getMethod(methodName, argClass);
  16. // 判断是否存在@DS注解
  17. if (method.isAnnotationPresent(DS.class)) {
  18. DS annotation = method.getAnnotation(DS.class);
  19. // 取出注解中的数据源名
  20. dataSource = annotation.value();
  21. }
  22. } catch (Exception e) {
  23. e.printStackTrace();
  24. }
  25. // 切换数据源
  26. DataSourceContextHolder.setDB(dataSource);
  27. }
  28. @After("@annotation(DS)")
  29. public void afterSwitchDS(JoinPoint point){
  30. DataSourceContextHolder.clearDB();
  31. }
  32. }
复制代码

完成上述配置后,在先前SqlSessionFactory配置中指定使用DynamicDataSource就可以在Service中愉快的切换数据源了:

  1. @Autowired
  2. private UserAModelMapper userAMapper;
  3. @DS("titan-master")
  4. public String ds1() {
  5. return userAMapper.selectByPrimaryKey(1).getName();
  6. }
  7. @DS("ds2")
  8. public String ds2() {
  9. return userAMapper.selectByPrimaryKey(1).getName();
  10. }
复制代码

总结

以上所述是小编给大家介绍的Spring Boot + Mybatis多数据源和动态数据源配置方法,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对程序员之家网站的支持!



回复

使用道具 举报