devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

SpringBoot——动态数据源（多数据源自动切换）

作者：从前慢现在也慢 | 2024-06-05 20:23:40

赞

踩

动态数据源

前言

日常的业务开发项目中只会配置一套数据源，如果需要获取其他系统的数据往往是通过调用接口， 或者是通过第三方工具比如kettle将数据同步到自己的数据库中进行访问。

但是也会有需要在项目中引用多数据源的场景。比如如下场景：

  • 自研数据迁移系统，至少需要新、老两套数据源，从老库读取数据写入新库
  • 自研读写分离中间件，系统流量增加，单库响应效率降低，引入读写分离方案，写入数据是一个数据源，读取数据是另一个数据源

某系统除了需要从自己的主要数据库上读取和管理数据外，还有一部分业务涉及到其他多个数据库，要求可以在任何方法上可以灵活指定具体要操作的数据库。

为了在开发中以最简单的方法使用，本文基于注解和AOP的方法实现，在spring boot框架的项目中，添加本文实现的代码类后，只需要配置好数据源就可以直接通过注解使用，简单方便。

一、原理

关键类说明

忽略掉controller/service/entity/mapper/xml介绍。

  • jdbc.properties: 数据源配置文件。虽然可以配置到Spring boot的默认配置文件application.properties/application.yml文件当中，但是如果数据源比较多的话，根据实际使用，最佳的配置方式还是独立配置比较好。
  • DynamicDataSourceConfig：数据源配置类
  • DynamicDataSource：动态数据源配置类
  • DataSourceRouting：动态数据源注解
  • DynamicDataSourceAspect：动态数据源设置切面
  • DynamicDataSourceContextHolder：当前线程持有的数据源key
  • DataSourceConstants：数据源key常量类

开发流程

 

动态数据源流程

Spring Boot 的动态数据源，本质上是把多个数据源存储在一个 Map 中，当需要使用某个数据源时，从 Map 中获取此数据源进行处理。

 

在 Spring 中已提供了抽象类 AbstractRoutingDataSource 来实现此功能，继承AbstractRoutingDataSource类并覆写其determineCurrentLookupKey()方法即可，该方法只需要返回数据源key即可，也就是存放数据源的Map的key。

因此，我们在实现动态数据源的，只需要继承它，实现自己的获取数据源逻辑即可。AbstractRoutingDataSource顶级继承了DataSource，所以它也是可以做为数据源对象，因此项目中使用它作为主数据源。

 

AbstractRoutingDataSource原理

AbstractRoutingDataSource中有一个重要的属性：

  • argetDataSources：目标数据源，即项目启动的时候设置的需要通过AbstractRoutingDataSource管理的数据源。
  • defaultTargetDataSource：默认数据源，项目启动的时候设置的默认数据源，如果没有指定数据源，默认返回改数据源。
  • resolvedDataSources：也是存放的数据源，是对targetDataSources进行处理后进行存储的。可以看一下源码。

 

 

  • resolvedDefaultDataSource: 对默认数据源进行了二次处理，源码如上图最后的两行代码。

AbstractRoutingDataSource中所有的方法和属性：

 

比较重要的是determineTargetDataSource方法。

  1. protected DataSource determineTargetDataSource() {
  2.     Assert.notNull(this.resolvedDataSources, "DataSource router not initialized");
  3.     Object lookupKey = determineCurrentLookupKey();
  4.     DataSource dataSource = this.resolvedDataSources.get(lookupKey);
  5.     if (dataSource == null && (this.lenientFallback || lookupKey == null)) {
  6.             dataSource = this.resolvedDefaultDataSource;
  7.     }
  8.     if (dataSource == null) {
  9.             throw new IllegalStateException("Cannot determine target DataSource for lookup key [" + lookupKey + "]");
  10.     }
  11.     return dataSource;
  12. }
  13.  
  14. /**
  15. * Determine the current lookup key. This will typically be
  16. * implemented to check a thread-bound transaction context.
  17. * <p>Allows for arbitrary keys. The returned key needs
  18. * to match the stored lookup key type, as resolved by the
  19. * {@link #resolveSpecifiedLookupKey} method.
  20. */
  21. @Nullable
  22. protected abstract Object determineCurrentLookupKey();

这个方法主要就是返回一个DataSource对象，主要逻辑就是先通过方法determineCurrentLookupKey获取一个Object对象的lookupKey，然后通过这个lookupKey到resolvedDataSources中获取数据源（resolvedDataSources就是一个Map，上面已经提到过了）；如果没有找到数据源，就返回默认的数据源。determineCurrentLookupKey就是程序员配置动态数据源需要自己实现的方法。

二、实现

引入Maven依赖

  1. <parent>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-parent</artifactId>
  4.     <version>2.1.10.RELEASE</version>
  5.     <relativePath/> <!-- lookup parent from repository -->
  6. </parent>
  7.  
  8. <properties>
  9.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  10.     <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  11.     <java.version>1.8</java.version>
  12. </properties>
  13.  
  14. <dependencies>
  15.     <dependency>
  16.         <groupId>org.springframework.boot</groupId>
  17.         <artifactId>spring-boot-starter-web</artifactId>
  18.     </dependency>
  19.  
  20.     <!--如果要用传统的xml或properties配置，则需要添加此依赖-->
  21.     <dependency>
  22.         <groupId>org.springframework.boot</groupId>
  23.         <artifactId>spring-boot-configuration-processor</artifactId>
  24.     </dependency>
  25.  
  26.     <dependency>
  27.         <groupId>tk.mybatis</groupId>
  28.         <artifactId>mapper-spring-boot-starter</artifactId>
  29.         <version>2.1.5</version>
  30.     </dependency>
  31.  
  32.     <dependency>
  33.         <groupId>mysql</groupId>
  34.         <artifactId>mysql-connector-java</artifactId>
  35.         <scope>runtime</scope>
  36.     </dependency>
  37.  
  38.     <dependency>
  39.         <groupId>org.springframework.boot</groupId>
  40.         <artifactId>spring-boot-starter-jdbc</artifactId>
  41.     </dependency>
  42.  
  43.     <dependency>
  44.         <groupId>org.springframework.boot</groupId>
  45.         <artifactId>spring-boot-starter-aop</artifactId>
  46.     </dependency>
  47.  
  48.     <!-- swagger -->
  49.     <dependency>
  50.         <groupId>io.springfox</groupId>
  51.         <artifactId>springfox-swagger-ui</artifactId>
  52.         <version>2.9.2</version>
  53.     </dependency>
  54.  
  55.     <dependency>
  56.         <groupId>io.springfox</groupId>
  57.         <artifactId>springfox-swagger2</artifactId>
  58.         <version>2.9.2</version>
  59.     </dependency>
  60.  
  61.     <!-- spring security -->
  62.     <dependency>
  63.         <groupId>org.springframework.boot</groupId>
  64.         <artifactId>spring-boot-starter-security</artifactId>
  65.     </dependency>
  66.     <!-- jwt -->
  67.     <dependency>
  68.         <groupId>io.jsonwebtoken</groupId>
  69.         <artifactId>jjwt</artifactId>
  70.         <version>0.9.1</version>
  71.     </dependency>
  72.     <!-- fastjson -->
  73.     <dependency>
  74.         <groupId>com.alibaba</groupId>
  75.         <artifactId>fastjson</artifactId>
  76.         <version>1.2.70</version>
  77.     </dependency>
  78.  
  79.  
  80.     <dependency>
  81.         <groupId>org.projectlombok</groupId>
  82.         <artifactId>lombok</artifactId>
  83.         <optional>true</optional>
  84.     </dependency>
  85. </dependencies>
  86.  
  87. <build>
  88.     <plugins>
  89.         <plugin>
  90.             <groupId>org.springframework.boot</groupId>
  91.             <artifactId>spring-boot-maven-plugin</artifactId>
  92.         </plugin>
  93.  
  94.         <plugin>
  95.             <groupId>org.mybatis.generator</groupId>
  96.             <artifactId>mybatis-generator-maven-plugin</artifactId>
  97.             <version>1.3.6</version>
  98.             <configuration>
  99.                 <configurationFile>
  100.                     ${basedir}/src/main/resources/generator/generatorConfig.xml
  101.                 </configurationFile>
  102.                 <overwrite>true</overwrite>
  103.                 <verbose>true</verbose>
  104.             </configuration>
  105.             <dependencies>
  106.                 <dependency>
  107.                     <groupId>mysql</groupId>
  108.                     <artifactId>mysql-connector-java</artifactId>
  109.                     <version>5.1.41</version>
  110.                 </dependency>
  111.                 <dependency>
  112.                     <groupId>tk.mybatis</groupId>
  113.                     <artifactId>mapper</artifactId>
  114.                     <version>4.1.5</version>
  115.                 </dependency>
  116.             </dependencies>
  117.         </plugin>
  118.     </plugins>
  119. </build>

主要实现步骤：一配置二使用

  • 启动类注册动态数据源
  • 配置文件中配置多个数据源
  • 在需要的方法上使用注解指定数据源

  • 1、在启动类添加 @Import({DynamicDataSourceRegister.class, MProxyTransactionManagementConfiguration.class})

  1. // 注册动态多数据源
  2. @Import({DynamicDataSourceRegister.class})
  3. @MapperScan("com.yibo.mapper")//扫描Mapper接口
  4. @SpringBootApplication
  5. public class Application {
  6.  
  7.     public static void main(String[] args) {
  8.         SpringApplication.run(Application.class,args);
  9.     }
  10. }
  • 2、配置文件配置内容为：
  1. # 默认数据源
  2. spring.datasource.url=jdbc:mysql://localhost:3306/user_center?useUnicode=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC
  3. spring.datasource.hikari.driver-class-name=com.mysql.cj.jdbc.Driver
  4. spring.datasource.hikari.username=root
  5. spring.datasource.hikari.password=yibo
  6.  
  7. # 更多数据源
  8. custom.datasource.names=ds1,ds2
  9. custom.datasource.ds1.driver-class-name=com.mysql.cj.jdbc.Driver
  10. custom.datasource.ds1.url=jdbc:mysql://localhost:3306/content_center?useUnicode=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC
  11. custom.datasource.ds1.username=root
  12. custom.datasource.ds1.password=yibo
  13. custom.datasource.ds2.driver-class-name=com.mysql.cj.jdbc.Driver
  14. custom.datasource.ds2.url=jdbc:mysql://localhost:3306/trade?useUnicode=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC
  15. custom.datasource.ds2.username=root
  16. custom.datasource.ds2.password=yibo
  17.  
  18. mybatis.type-aliases-package: com.yibo.center.domain.entity
  19. mybatis.mapper-locations: classpath:mapper/*.xml
  20. mapper.identity: MYSQL
  21. mapper.not-empty: false
  22.  
  23. #是否激活 swagger true or false
  24. swagger.enable=true
  • 3、使用方法
  1. import com.yibo.center.domain.entity.Share;
  2. import com.yibo.datasource.anno.TargetDataSource;
  3. import com.yibo.mapper.ShareMapper;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.stereotype.Service;
  6. import org.springframework.transaction.annotation.Transactional;
  7.  
  8. import java.util.List;
  9.  
  10.  
  11.  
  12. @Service
  13. public class ShareService {
  14.  
  15.     @Autowired
  16.     private ShareMapper shareMapper;
  17.  
  18.     @TargetDataSource(name = "ds1")
  19.     @Transactional
  20.     public List<Share> findAll(){
  21.         return shareMapper.selectAll();
  22.     }
  23. }

  1. import com.yibo.center.domain.entity.TradeGoods;
  2. import com.yibo.center.domain.vo.TradeGoodsAO;
  3. import com.yibo.datasource.anno.TargetDataSource;
  4. import com.yibo.mapper.TradeGoodsMapper;
  5. import org.springframework.beans.BeanUtils;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.stereotype.Service;
  8. import org.springframework.transaction.annotation.Transactional;
  9.  
  10. import java.util.Date;
  11. import java.util.List;
  12.  
  13. /**
  14.  * @Description:
  15.  */
  16.  
  17. @Service
  18. public class TradeGoodsService {
  19.  
  20.     @Autowired
  21.     private TradeGoodsMapper tradeGoodsMapper;
  22.  
  23.     @TargetDataSource(name = "ds2")
  24.     @Transactional
  25.     public List<TradeGoods> findAll(){
  26.         return tradeGoodsMapper.selectAll();
  27.     }
  28.  
  29.     @TargetDataSource(name = "ds2")
  30.     @Transactional
  31.     public String addTradeGoods(TradeGoodsAO tradeGoodsAO){
  32.         TradeGoods tradeGoods = new TradeGoods();
  33.         BeanUtils.copyProperties(tradeGoodsAO,tradeGoods);
  34.         tradeGoods.setAddTime(new Date());
  35.         tradeGoodsMapper.insert(tradeGoods);
  36.         return "SUCCESS";
  37.     }
  38. }

  1. import com.yibo.center.domain.entity.User;
  2. import com.yibo.center.domain.vo.UserAo;
  3. import com.yibo.mapper.UserMapper;
  4. import org.springframework.beans.BeanUtils;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.stereotype.Service;
  7. import org.springframework.transaction.annotation.Transactional;
  8.  
  9. import java.util.Date;
  10. import java.util.List;
  11.  
  12. /**
  13.  * @Description:
  14.  */
  15.  
  16. @Service
  17. public class UserService {
  18.  
  19.     @Autowired
  20.     private UserMapper userMapper;
  21.  
  22.     public List<User> findAll(){
  23.         return userMapper.selectAll();
  24.     }
  25.  
  26.     @Transactional
  27.     public User findById(Integer id){
  28.         User user = new User();
  29.         user.setId(id);
  30.         return userMapper.selectOne(user);
  31.     }
  32.  
  33.     @Transactional
  34.     public String addUser(UserAo userAo){
  35.         User user = new User();
  36.         BeanUtils.copyProperties(userAo,user);
  37.         user.setCreateTime(new Date());
  38.         user.setUpdateTime(new Date());
  39.         userMapper.insert(user);
  40.         return "SUCCESS";
  41.     }
  42. }

要注意的是，在使用MyBatis时，注解@TargetDataSource 不能直接在接口类Mapper上使用。

请将下面几个类放到Spring Boot项目中。

  • DynamicDataSource.java
  • DynamicDataSourceAspect.java
  • DynamicDataSourceContextHolder.java
  • DynamicDataSourceRegister.java
  • TargetDataSource.java

  1. import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
  2.  
  3. /**
  4.  * @Description: 继承Spring AbstractRoutingDataSource实现路由切换
  5.  */
  6. public class DynamicDataSource extends AbstractRoutingDataSource {
  7.  
  8.     @Override
  9.     protected Object determineCurrentLookupKey() {
  10.         return DynamicDataSourceContextHolder.getDataSourceType();
  11.     }
  12. }

  1. import com.yibo.datasource.DynamicDataSourceContextHolder;
  2. import com.yibo.datasource.anno.TargetDataSource;
  3. import lombok.extern.slf4j.Slf4j;
  4. import org.aspectj.lang.JoinPoint;
  5. import org.aspectj.lang.annotation.After;
  6. import org.aspectj.lang.annotation.Aspect;
  7. import org.aspectj.lang.annotation.Before;
  8. import org.springframework.core.annotation.Order;
  9. import org.springframework.stereotype.Component;
  10.  
  11. /**
  12.  * @Description: 动态数据源通知
  13.  */
  14. @Aspect
  15. //保证该AOP在@Transactional之前执行
  16. @Order(-1)
  17. @Component
  18. @Slf4j
  19. public class DynamicDataSourceAspect {
  20.  
  21.     /**
  22.      * @Description 在方法执行之前执行  @annotation(ds) 会拦截有ds这个注解的方法即有 TargetDataSource这个注解的
  23.      * @param @param point
  24.      * @param @param ds
  25.      * @param @throws Throwable 参数
  26.      * @return void 返回类型
  27.      * @throws
  28.      */
  29.     @Before("@annotation(ds)")
  30.     public void changeDataSource(JoinPoint point, TargetDataSource ds)
  31.             throws Throwable {
  32.         String dsId = ds.name();
  33.         if (!DynamicDataSourceContextHolder.containsDataSource(dsId)) {
  34.             log.error("数据源[{}]不存在，使用默认数据源 > {}", ds.name(), point.getSignature());
  35.         }
  36.         else {
  37.             log.debug("Use DataSource : {} > {}", ds.name(),point.getSignature());
  38.             DynamicDataSourceContextHolder.setDataSourceType(ds.name());
  39.         }
  40.     }
  41.  
  42.     /**
  43.      * @Description 在方法执行之后执行  @annotation(ds) 会拦截有ds这个注解的方法即有 TargetDataSource这个注解的
  44.      * @param @param point
  45.      * @param @param ds 参数
  46.      * @return void 返回类型
  47.      * @throws
  48.      */
  49.     @After("@annotation(ds)")
  50.     public void restoreDataSource(JoinPoint point, TargetDataSource ds) {
  51.         log.debug("Revert DataSource : {} > {}", ds.name(), point.getSignature());
  52.         DynamicDataSourceContextHolder.clearDataSourceType();
  53.     }
  54. }

  1. import java.util.ArrayList;
  2. import java.util.List;
  3.  
  4. /**
  5.  * @Description: 动态数据源上下文管理
  6.  */
  7.  
  8. public class DynamicDataSourceContextHolder {
  9.  
  10.     //存放当前线程使用的数据源类型信息
  11.     private static final ThreadLocal<String> contextHolder = new ThreadLocal<String>();
  12.  
  13.     //存放数据源id
  14.     public static List<String> dataSourceIds = new ArrayList<String>();
  15.  
  16.     //设置数据源
  17.     public static void setDataSourceType(String dataSourceType) {
  18.         contextHolder.set(dataSourceType);
  19.     }
  20.  
  21.     //获取数据源
  22.     public static String getDataSourceType() {
  23.         return contextHolder.get();
  24.     }
  25.  
  26.     //清除数据源
  27.     public static void clearDataSourceType() {
  28.         contextHolder.remove();
  29.     }
  30.  
  31.     /**
  32.      * 判断指定DataSrouce当前是否存在
  33.      *
  34.      * @param dataSourceId
  35.      * @return
  36.      */
  37.     public static boolean containsDataSource(String dataSourceId){
  38.         return dataSourceIds.contains(dataSourceId);
  39.     }
  40. }

  1. import lombok.extern.slf4j.Slf4j;
  2. import org.springframework.beans.MutablePropertyValues;
  3. import org.springframework.beans.factory.support.BeanDefinitionRegistry;
  4. import org.springframework.beans.factory.support.GenericBeanDefinition;
  5. import org.springframework.boot.jdbc.DataSourceBuilder;
  6. import org.springframework.context.EnvironmentAware;
  7. import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
  8. import org.springframework.core.env.Environment;
  9. import org.springframework.core.type.AnnotationMetadata;
  10.  
  11. import javax.sql.DataSource;
  12. import java.util.HashMap;
  13. import java.util.Map;
  14.  
  15. /**
  16.  * @Description: 注册动态数据源
  17.  *  初始化数据源和提供了执行动态切换数据源的工具类
  18.  *  EnvironmentAware（获取配置文件配置的属性值）
  19.  */
  21. @Slf4j
  22. public class DynamicDataSourceRegister implements ImportBeanDefinitionRegistrar, EnvironmentAware {
  23.  
  24.     //指定默认数据源(springboot2.0默认数据源是hikari如何想使用其他数据源可以自己配置)
  25.     private static final String DATASOURCE_TYPE_DEFAULT = "com.zaxxer.hikari.HikariDataSource";
  26.  
  27.     //默认数据源
  28.     private DataSource defaultDataSource;
  29.  
  30.     //用户自定义数据源
  31.     private Map<String, DataSource> customDataSources  = new HashMap<>();
  32.  
  33.     /**
  34.      * 加载多数据源配置
  35.      * @param env
  36.      */
  37.     @Override
  38.     public void setEnvironment(Environment env) {
  39.         initDefaultDataSource(env);
  40.         initCustomDataSources(env);
  41.     }
  42.  
  43.  
  44.  
  45.     /**
  46.      * 初始化主数据源
  47.      * @param env
  48.      */
  49.     private void initDefaultDataSource(Environment env) {
  50.         // 读取主数据源
  51.         Map<String, Object> dsMap = new HashMap<>();
  52.         dsMap.put("driver", env.getProperty("spring.datasource.hikari.driver-class-name"));
  53.         dsMap.put("url", env.getProperty("spring.datasource.url"));
  54.         dsMap.put("username", env.getProperty("spring.datasource.hikari.username"));
  55.         dsMap.put("password", env.getProperty("spring.datasource.hikari.password"));
  56.         defaultDataSource = buildDataSource(dsMap);
  57.     }
  58.  
  59.  
  60.     /**
  61.      * 初始化更多数据源
  62.      * @param env
  63.      */
  64.     private void initCustomDataSources(Environment env) {
  65.         // 读取配置文件获取更多数据源
  66.         String dsPrefixs = env.getProperty("custom.datasource.names");
  67.         for (String dsPrefix : dsPrefixs.split(",")) {
  68.             // 多个数据源
  69.             Map<String, Object> dsMap = new HashMap<>();
  70.             dsMap.put("driver", env.getProperty("custom.datasource." + dsPrefix + ".driver-class-name"));
  71.             dsMap.put("url", env.getProperty("custom.datasource." + dsPrefix + ".url"));
  72.             dsMap.put("username", env.getProperty("custom.datasource." + dsPrefix + ".username"));
  73.             dsMap.put("password", env.getProperty("custom.datasource." + dsPrefix + ".password"));
  74.             DataSource ds = buildDataSource(dsMap);
  75.             customDataSources.put(dsPrefix, ds);
  76.         }
  77.     }
  78.  
  79.     @Override
  80.     public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
  81.         Map<Object, Object> targetDataSources = new HashMap<Object, Object>();
  82.         // 将主数据源添加到更多数据源中
  83.         targetDataSources.put("dataSource", defaultDataSource);
  84.         DynamicDataSourceContextHolder.dataSourceIds.add("dataSource");
  85.         // 添加更多数据源
  86.         targetDataSources.putAll(customDataSources);
  87.         for (String key : customDataSources.keySet()) {
  88.             DynamicDataSourceContextHolder.dataSourceIds.add(key);
  89.         }
  90.  
  91.         // 创建DynamicDataSource
  92.         GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
  93.         beanDefinition.setBeanClass(DynamicDataSource.class);
  94.         beanDefinition.setSynthetic(true);
  95.         MutablePropertyValues mpv = beanDefinition.getPropertyValues();
  96.         mpv.addPropertyValue("defaultTargetDataSource", defaultDataSource);
  97.         mpv.addPropertyValue("targetDataSources", targetDataSources);
  98.         registry.registerBeanDefinition("dataSource", beanDefinition); // 注册到Spring容器中
  99.  
  100.         log.info("Dynamic DataSource Registry");
  101.     }
  102.  
  103.     /**
  104.      * 创建DataSource
  105.      * @param dsMap
  106.      * @return
  107.      */
  108.     @SuppressWarnings("unchecked")
  109.     public DataSource buildDataSource(Map<String, Object> dsMap) {
  110.         try {
  111.             Object type = dsMap.get("type");
  112.             if (type == null)
  113.                 type = DATASOURCE_TYPE_DEFAULT;// 默认DataSource
  114.  
  115.             Class<? extends DataSource> dataSourceType;
  116.             dataSourceType = (Class<? extends DataSource>)Class.forName((String)type);
  117.             log.info("dsMap:{}",dsMap);
  118.             System.out.println(dsMap);
  119.             String driverClassName = dsMap.get("driver").toString();
  120.             String url = dsMap.get("url").toString();
  121.             String username = dsMap.get("username").toString();
  122.             String password = dsMap.get("password").toString();
  123.             // 自定义DataSource配置
  124.             DataSourceBuilder factory = DataSourceBuilder.create()
  125.                     .driverClassName(driverClassName)
  126.                     .url(url)
  127.                     .username(username)
  128.                     .password(password)
  129.                     .type(dataSourceType);
  130.             return factory.build();
  131.         }catch (ClassNotFoundException e) {
  132.             e.printStackTrace();
  133.         }
  134.         return null;
  135.     }
  136. }

  1. import java.lang.annotation.*;
  2.  
  3. /**
  4.  * @Description: 作用于类、接口或者方法上
  5.  */
  6. @Target({ElementType.METHOD, ElementType.TYPE})
  7. @Retention(RetentionPolicy.RUNTIME)
  8. @Documented
  9. public @interface TargetDataSource {
  10.     String name();
  11. }

本文代码博主是经过测试后没有问题才发出来共享给大家的。对于连接池参数配置会应用到所有数据源上。

比如配置一个：

spring.datasource.maximum-pool-size=80

那么我们所有的数据源都会自动应用上。

补充：

如果你使用的是SpringMVC，并集成了Shiro，一般按网上的配置你可能是：

  1. <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" depends-on="lifecycleBeanPostProcessor">
  2.     <property name="proxyTargetClass" value="true" />
  3. </bean>
  4.  
  5. <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
  6.     <property name="securityManager" ref="securityManager"/>
  7. </bean>

那么你请不要这样做，请按下面方法配置：

  1. <!-- AOP式方法级权限检查  -->
  2. <!-- 不要使用 DefaultAdvisorAutoProxyCreator 会出现二次代理的问题，这里不详述。 mark by shanhy 2016-05-15 -->
  3. <aop:config proxy-target-class="true"/>
  4. <!-- 或者你使用了 <aop:aspectj-autoproxy proxy-target-class="true" /> 也可以。 -->
  5.  
  6. <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
  7.     <property name="securityManager" ref="securityManager"/>
  8. </bean>

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/677984
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号