springboot项目配置多数据源：配置+自定义注解+AOP

已于 2022-02-18 14:36:34 修改
阅读量1.8k 收藏 6
点赞数 9
文章标签： spring boot java mysql
于 2022-02-09 18:06:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/itmime/article/details/122845405
版权

第一步.首先在配置文件中，将多数据源配置出来（这里你可以配置多个都无所谓）：

##druid数据库连接配置
spring:
	datasource:
	    druid:
	      url: jdbc:mysql://110.40.172.238:3306/guns?autoReconnect=true&useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=CONVERT_TO_NULL&useSSL=false&nullCatalogMeansCurrent=true
	      username: root
	      password: aaaa
	      initial-size: 1
	      max-active: 100
	      min-idle: 10
	      max-wait: 60000
	      pool-prepared-statements: true
	      max-pool-prepared-statement-per-connection-size: 20
	      time-between-eviction-runs-millis: 60000
	      min-evictable-idle-time-millis: 300000
	      #Oracle需要打开注释
	      #validation-query: SELECT 1 FROM DUAL
	      test-while-idle: true
	      test-on-borrow: false
	      test-on-return: false
	      stat-view-servlet:
	        enabled: true
	        url-pattern: /druid/*
	        #login-username: admin
	        #login-password: admin
	      filter:
	        stat:
	          log-slow-sql: true
	          slow-sql-millis: 1000
	          merge-sql: false
	        wall:
	          config:
	            multi-statement-allow: true
##多数据源的配置
dynamic:
  datasource:
    first:
      url: jdbc:mysql://110.40.172.238:3306/guns?autoReconnect=true&useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=CONVERT_TO_NULL&useSSL=false&nullCatalogMeansCurrent=true
      username: root
      password: aaaa
      driver-class-name: com.mysql.cj.jdbc.Driver
    second:
      url: jdbc:mysql://127.0.0.1:3306/guns?autoReconnect=true&useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=CONVERT_TO_NULL&useSSL=false&nullCatalogMeansCurrent=true
      username: root
      password: aaaa
      driver-class-name: com.mysql.cj.jdbc.Driver

第二步，创建多数据源属性实体对象，用于接受配置文件中的数据源信息：

public class DataSourceProperties {
    private String driverClassName;
    private String url;
    private String username;
    private String password;

    /**
     * Druid默认参数
     */
    private int initialSize = 2;
    private int maxActive = 10;
    private int minIdle = -1;
    private long maxWait = 60 * 1000L;
    private long timeBetweenEvictionRunsMillis = 60 * 1000L;
    private long minEvictableIdleTimeMillis = 1000L * 60L * 30L;
    private long maxEvictableIdleTimeMillis = 1000L * 60L * 60L * 7;
    private String validationQuery = "select 1";
    private int validationQueryTimeout = -1;
    private boolean testOnBorrow = false;
    private boolean testOnReturn = false;
    private boolean testWhileIdle = true;
    private boolean poolPreparedStatements = false;
    private int maxOpenPreparedStatements = -1;
    private boolean sharePreparedStatements = false;
    private String filters = "stat,wall";
    public String getDriverClassName() {
        return driverClassName;
    }
    public void setDriverClassName(String driverClassName) {
        this.driverClassName = driverClassName;
    }
    public String getUrl() {
        return url;
    }
    public void setUrl(String url) {
        this.url = url;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public int getInitialSize() {
        return initialSize;
    }
    public void setInitialSize(int initialSize) {
        this.initialSize = initialSize;
    }
    public int getMaxActive() {
        return maxActive;
    }
    public void setMaxActive(int maxActive) {
        this.maxActive = maxActive;
    }
    public int getMinIdle() {
        return minIdle;
    }
    public void setMinIdle(int minIdle) {
        this.minIdle = minIdle;
    }
    public long getMaxWait() {
        return maxWait;
    }
    public void setMaxWait(long maxWait) {
        this.maxWait = maxWait;
    }
    public long getTimeBetweenEvictionRunsMillis() {
        return timeBetweenEvictionRunsMillis;
    }
    public void setTimeBetweenEvictionRunsMillis(long timeBetweenEvictionRunsMillis) {
        this.timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;
    }
    public long getMinEvictableIdleTimeMillis() {
        return minEvictableIdleTimeMillis;
    }
    public void setMinEvictableIdleTimeMillis(long minEvictableIdleTimeMillis) {
        this.minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;
    }
    public long getMaxEvictableIdleTimeMillis() {
        return maxEvictableIdleTimeMillis;
    }
    public void setMaxEvictableIdleTimeMillis(long maxEvictableIdleTimeMillis) {
        this.maxEvictableIdleTimeMillis = maxEvictableIdleTimeMillis;
    }
    public String getValidationQuery() {
        return validationQuery;
    }
    public void setValidationQuery(String validationQuery) {
        this.validationQuery = validationQuery;
    }
    public int getValidationQueryTimeout() {
        return validationQueryTimeout;
    }
    public void setValidationQueryTimeout(int validationQueryTimeout) {
        this.validationQueryTimeout = validationQueryTimeout;
    }
    public boolean isTestOnBorrow() {
        return testOnBorrow;
    }
    public void setTestOnBorrow(boolean testOnBorrow) {
        this.testOnBorrow = testOnBorrow;
    }
    public boolean isTestOnReturn() {
        return testOnReturn;
    }
    public void setTestOnReturn(boolean testOnReturn) {
        this.testOnReturn = testOnReturn;
    }
    public boolean isTestWhileIdle() {
        return testWhileIdle;
    }
    public void setTestWhileIdle(boolean testWhileIdle) {
        this.testWhileIdle = testWhileIdle;
    }
    public boolean isPoolPreparedStatements() {
        return poolPreparedStatements;
    }
    public void setPoolPreparedStatements(boolean poolPreparedStatements) {
        this.poolPreparedStatements = poolPreparedStatements;
    }
    public int getMaxOpenPreparedStatements() {
        return maxOpenPreparedStatements;
    }
    public void setMaxOpenPreparedStatements(int maxOpenPreparedStatements) {
        this.maxOpenPreparedStatements = maxOpenPreparedStatements;
    }
    public boolean isSharePreparedStatements() {
        return sharePreparedStatements;
    }
    public void setSharePreparedStatements(boolean sharePreparedStatements) {
        this.sharePreparedStatements = sharePreparedStatements;
    }
    public String getFilters() {
        return filters;
    }
    public void setFilters(String filters) {
        this.filters = filters;
    }
}

再创建一个Druid数据源工厂，作用是将上述数据源属性信息转换为DruidDataSource对象

public class DynamicDataSourceFactory {

    public static DruidDataSource buildDruidDataSource(DataSourceProperties properties) {
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(properties.getDriverClassName());
        druidDataSource.setUrl(properties.getUrl());
        druidDataSource.setUsername(properties.getUsername());
        druidDataSource.setPassword(properties.getPassword());

        druidDataSource.setInitialSize(properties.getInitialSize());
        druidDataSource.setMaxActive(properties.getMaxActive());
        druidDataSource.setMinIdle(properties.getMinIdle());
        druidDataSource.setMaxWait(properties.getMaxWait());
        druidDataSource.setTimeBetweenEvictionRunsMillis(properties.getTimeBetweenEvictionRunsMillis());
        druidDataSource.setMinEvictableIdleTimeMillis(properties.getMinEvictableIdleTimeMillis());
        druidDataSource.setMaxEvictableIdleTimeMillis(properties.getMaxEvictableIdleTimeMillis());
        druidDataSource.setValidationQuery(properties.getValidationQuery());
        druidDataSource.setValidationQueryTimeout(properties.getValidationQueryTimeout());
        druidDataSource.setTestOnBorrow(properties.isTestOnBorrow());
        druidDataSource.setTestOnReturn(properties.isTestOnReturn());
        druidDataSource.setPoolPreparedStatements(properties.isPoolPreparedStatements());
        druidDataSource.setMaxOpenPreparedStatements(properties.getMaxOpenPreparedStatements());
        druidDataSource.setSharePreparedStatements(properties.isSharePreparedStatements());

        try {
            druidDataSource.setFilters(properties.getFilters());
            druidDataSource.init();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return druidDataSource;
    }
}

第三步.创建一个数据源管理对象，这里是可以切换当前线程的数据源 (ThreadLocal)，后面的AOP就会通过自定义注解所表示的数据源调用这个API对当前线程的数据源进行切换。代码如下：

public class DynamicDataSourceHolder {
	
    private static final ThreadLocal<String> THREAD_LOCAL = new ThreadLocal<String>();

    /**
     * 设置线程持有的DataSource, 底层以map形式呈现, key为当前线程
     *
     * @param dataSource
     */
    public static void setDataSource(String dataSource) {
        THREAD_LOCAL.set(dataSource);
    }
    /**
     * 获取线程持有的当前数据源
     *
     * @return
     */
    public static String getDataSource() {
        return THREAD_LOCAL.get();
    }
    /**
     * 清除数据源
     */
    public static void clear() {
        THREAD_LOCAL.remove();
    }
}

第四步（核心）.创建一个自定义的动态数据源对象，并且继承基类 AbstractRoutingDataSource，重写determineCurrentLookupKey方法，将第三步中的数据源返回给该对象（因为第三步是通过数据源的KEY来指定使用哪个数据源，第四步是将这个KEY返回给动态数据源管理对象，动态数据源管理对象会根据这个KEY找到我们的数据源，如果找不到就使用默认的数据源）

public class DynamicDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return DynamicDataSourceHolder.getDataSource();
    }
}

第五步.先创建一个读取多数据源配置信息的对象，这里要注意的是@ConfigurationProperties 这个注解，项目中要添加一个依赖：

	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-configuration-processor</artifactId>
		<optional>true</optional>
	</dependency>

有了@ConfigurationProperties(prefix = “dynamic”)，setDatasource方法会将前缀为“dynamic”的配置信息以key,value的方式读取到Map中，其中map的key就是每个数据源的名称，value是我们自定义的数据源属性的接收对象

@ConfigurationProperties(prefix = "dynamic")
public class DynamicDataSourceProperties {
    private Map<String, DataSourceProperties> datasource = new LinkedHashMap<>();

    public Map<String, DataSourceProperties> getDatasource() {
        return datasource;
    }
    
    public void setDatasource(Map<String, DataSourceProperties> datasource) {
        this.datasource = datasource;
    }
}

接下来就可以创建多数据源的配置对象了 注意的是需要@EnableConfigurationProperties(DynamicDataSourceProperties.class)
这个注解：开启DynamicDataSourceProperties对象读取配置文件的权限，否则上面的@ConfigurationProperties注解无法使用

/**
 * 配置多数据源
 *
 */
@Configuration
@EnableConfigurationProperties(DynamicDataSourceProperties.class)
public class DynamicDataSourceConfig {
    @Autowired
    private DynamicDataSourceProperties properties;
	
	 /**
     * 读取配置文件中的默认数据源配置 即spring.datasource.druid下的数据库连接配置
     * @return
     */
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.druid")
    public DataSourceProperties dataSourceProperties() {
        return new DataSourceProperties();
    }

    /**
     * 获取动态数据源
     * @return
     */
    @Bean(name = "dynamicDataSource")
    public javax.sql.DataSource dynamicDataSource() {
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        // 获取默认数据源 (spring.datasource.druid的配置)
        DataSourceProperties dataSourceProperties = dataSourceProperties();
        //设置默认数据源 (将自定义的数据源你对象通过DynamicDataSourceFactory转换为druid数据源对象)
        dynamicDataSource.setDefaultTargetDataSource(DynamicDataSourceFactory.buildDruidDataSource(dataSourceProperties));
        // 配置多数据源,
        // 添加数据源标识和DataSource引用到目标源映射
        dynamicDataSource.setTargetDataSources(getDynamicDataSource());
        return dynamicDataSource;
    }
	
    private Map<Object, Object> getDynamicDataSource(){
        Map<String, DataSourceProperties> dataSourcePropertiesMap = properties.getDatasource();
        Map<Object, Object> targetDataSources = new HashMap<>(dataSourcePropertiesMap.size());
        dataSourcePropertiesMap.forEach((k, v) -> {
            DruidDataSource druidDataSource = DynamicDataSourceFactory.buildDruidDataSource(v);
            targetDataSources.put(k, druidDataSource);
        });
        return targetDataSources;
    }

    /**
     * 将数据源加入到事务管理中
     * @return
     */
    @Bean
    public PlatformTransactionManager transactionManager() {
        return new DataSourceTransactionManager(dynamicDataSource());
    }
}

以上的所有配置完成，项目启动后就可以将配置文件中的多个数据源信息存入动态数据源管理中
接下来就可以创建一个自定义注解：

@Documented //文档记录
@Retention(RetentionPolicy.RUNTIME) //生命周期
@Target({ElementType.TYPE,ElementType.METHOD}) //作用范围
@Inherited //是否可继承
public @interface MeDataSource {
    String value() default "";
}

再创建一个AOP 去拦截上面的注解
记得添加AOP依赖

	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-aop</artifactId>
	</dependency>

@Aspect
@Component
@Order(1)//优先执行此aop
@Slf4j
public class DataSourceAop {
    private final String DEFAULT_DATA_SOURCE = "first";
	
    @Before(value = "@annotation(com.example.picture.datasource.MeDataSource)")//你的自定义注解路径
    public void before(JoinPoint joinPoint){
        //获取到执行的方法
        Object target = joinPoint.getTarget();
        MethodSignature methodSignature = (MethodSignature)joinPoint.getSignature();
        // 执行方法名
        String methodName = methodSignature.getName();
        // 方法参数
        Class[] parameterTypes = methodSignature.getParameterTypes();
        try {
            // 获取方法, 直接getClass获取对象可能为代理对象
            Method method = target.getClass().getMethod(methodName, parameterTypes);
            // 添加默认数据源
            String dataSource = DEFAULT_DATA_SOURCE;
            if (null != method && method.isAnnotationPresent(MeDataSource.class)) {
                MeDataSource targetDataSource = method.getAnnotation(MeDataSource.class);
                dataSource = targetDataSource.value();
            }
            // 此处添加线程对应的数据源到上下文
            // 在AbstractRoutingDataSource子类中拿到数据源, 加载后进行配置
            DynamicDataSourceHolder.setDataSource(dataSource);
            log.info("generate data source : " + dataSource);
        } catch (Exception e) {
            log.info("error", e);
        }
    }

    /**
     * 清除数据源, 方法执行完成后, 清除数据源
     */
    @After("@annotation(com.example.picture.datasource.MeDataSource)")
    public void after(JoinPoint joinPoint) {
        DynamicDataSourceHolder.clear();
    }
}

DynamicDataSourceHolder.setDataSource(dataSource); 这个操作就是获取注解中的数据源标识传入数据源管理器中，管理器通过这个标识调用动态数据源对象获取对应的数据源信息

到此就可以启动项目进行测试了

Print?
关注
Springcloud+Mybatis使用多数据源的四种方式
Java6888的博客
09-22 1403
Springcloud+Mybatis使用多数据源的四种方式 前段时间在做会员中心和中间件系统开发时，多次碰到多数据源配置问题，主要用到分包方式、参数化切换、注解+AOP、动态添加 这四种方式。这里做一下总结，分享下使用心得以及踩过的坑。 分包方式 数据源配置文件 在yml中，配置两个数据源，id分别为master和s1。 spring: datasource: master: jdbcUrl: jdbc:mysql://192.168.xxx.xxx:xxxx/db1?
Spring系列之多个数据源配置
2401_84003941的博客
04-18 422
关于面试刷题也是有方法可言的，建议最好是按照专题来进行，然后由基础到高级，由浅入深来，效果会更好。Java基础部分算法与编程数据库部分流行的框架与新技术（Spring+SpringCloud+SpringCloudAlibaba）这份面试文档当然不止这些内容，实际上像JVM、设计模式、ZK、MQ、数据结构等其他部分的面试内容均有涉及，因为文章篇幅，就不全部在这里阐述了。
MyBatis 多数据源读写分离（注解实现）
公众号：Java后端
11-09 471
优质文章，及时送达作者 |hy_xiaobin来源 | juejin.im/post/5d8705e65188253f4b629f47首先需要建立两个库进行测试，我这里...
Spring Boot 多数据源配置详解
最新发布
baidu_28705493的博客
08-21 979
在现代企业应用中，可能会涉及到多个数据库的使用，如不同模块或服务使用不同的数据库，或者在同一应用中同时连接多个数据库以处理不同的业务需求。为了应对这种需求，Spring Boot 提供了灵活的多数据源配置机制。本文将详细介绍如何在 Spring Boot 中配置多数据源，并通过代码示例来展示具体的实现步骤。
springboot 通过注解方式配置多数据源
无情编码工具人的博客
05-18 664
注解方式配置多数据源配置maven依赖主启动类排除Druid自动配置yml 配置使用非主数据源@DS("db2") ,主数据源不写默认就是 配置maven依赖 <dependency> <groupId>com.baomidou</groupId> <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
spring-boot项目配置多数据源
lgq2016的博客
11-15 1085
下面介绍一下通过configuration配置多数据源，或不多说，上代码。 application.properties文件 server.port = 8080 #mybatis扫描mapper文件的配置 mybatis.mapper-locations = classpath:mapper/*.xml,classpath:mapper/*/*.xml,classpath:mapper/*/*/*.xml #配置oracle的数据源 spring.datasource.oracle.url=jdb
springboot+jpa+aop自定义注解多数据源配置
焚琴煮鹤呀的博客
03-16 2519
springboot+jpa+aop自定义注解多数据源配置
SpringBoot配置多数据源实现动态切换数据源
06-29
本文将深入探讨如何在SpringBoot项目中配置多数据源，并实现数据源的动态切换，帮助你理解和掌握这一核心技能。 首先，我们理解"多数据源"的概念。在SpringBoot应用中，多数据源意味着系统能够连接并操作多个不同的...
Springboot+Mybatis+Druid多数据源配置
01-14
本教程将围绕"Springboot+Mybatis+Druid多数据源配置"这一主题，详细介绍如何实现这一功能。 首先，Spring Boot简化了Spring应用的初始化和配置。在多数据源场景下，我们可以通过Spring Boot的@...
springboot+mybatis配置多数据源，通过注解自动切换
04-11
- 在MyBatis的Mapper接口方法上也可以使用自定义注解，与Spring AOP配合，实现数据源的切换。 6. **测试验证** - 编写单元测试或者集成测试，确保在切换数据源后，数据操作正确执行在目标数据库上。 通过以上...
springboot实现多数据源而且加上事务不会使aop切换数据源失效
04-03
为了实现AOP动态切换数据源，我们可以创建一个自定义的注解，如`@UseSecondaryDataSource`，并编写对应的切面来处理数据源切换： ```java @Aspect @Component public class DataSourceAspect { @Autowired ...
spring boot配置多个数据源
qq_35261162的博客
08-22 1569
spring boot配置多个数据源
SpringBoot2.x实践之多数据源配置
直须看尽洛城花
08-26 461
Spring 要使用多数据源，需要在 Spring 容器中放入多个 DataSource。DataSource 是 javax.sql 包中的一个接口，这个接口有多种实现，常见的有 c3p0 中的 ComboPooledDataSource 连接池，druid 的 DruidDataSource ，都实现了 DataSource 接口。 我们以 druid 举例，通过 @Bean 标签在 Spr...
@MapperScan注解、type-aliases-package、mapper-locations配置多个值
lcjjy666的博客
10-14 3445
1.@MapperScan配置多个值 @MapperScan({"com.pv.modular.*.mapper","com.pv.modular.*.*.mapper"}) 2.type-aliases-package和mapper-locations配置多个值 type-aliases-package: com.pv.modular.*.entity,;com.pv.modular.*.*.entity mapper-locations: classpath:mapping/*/*.xml,class
Spring 多数据源方法级别注解实现
东皋长歌的专栏
07-25 825
Spring框架提供了多种数据源管理方式，其中多数据源管理是其中之一。多数据源管理允许应用程序使用多个数据源，而不是只使用一个数据源，从而提高了应用程序的灵活性和可靠性。 多数据源管理的主要目的是让应用程序能够在不同的数据库之间切换，以满足不同的业务需求。例如，如果应用程序需要访问一个高可用性的数据库，但是该数据库当前不可用，那么应用程序可以自动切换到备用数据库，以保证业务的连续性。 在多数据源管理中，Spring框架通过使用JNDI（Java命名和目录接口）来管理数据源。JNDI允许应用程序在运行时动
spring-boot配置多数据源（动态数据源，基于注解和切面方式）
qq_43170312的博客
05-10 1412
一、自定义DB注解 @Target({ElementType.METHOD, ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) public @interface DS { /** * 数据源名称 */ String value(); } 二、配置properties数据源 文件名：jdbc.properties # slave-authserver spring.datasource.slave.auths
yml文件中如何配置同一个属性多个值，然后再代码中如何取值？
weixin_42605050的博客
01-22 6074
yml文件的配置，同一个属性有多个值，采用逗号进行分开，也可以用其他符号 代码中，注解要用split用指定的符号进行分开，类型是list类型 /** * 4个管理员账户 */ @Value("#{'${username.userName}'.split(',')}") private List<String> userName; 3.如何在代码中取值遍历 User user = new User(); user..
SpringBoot+自定义注解实现多数据源配置
热门推荐
一恍过去
06-15 2万+
SpringBoot+自定义注解实现多数据源配置
67、SpringBoot --＞ 数据源配置 及 配置多个数据源--C3P0 数据源 和 Hikari 数据源
Java 领域技术分享
09-14 1589
数据源配置 及 配置多个数据源--C3P0 数据源 和 Hikari 数据源
SpringBoot AOP 实现多数据源切换详细教程
"这篇文章主要探讨了如何在SpringBoot项目中利用AOP技术实现多数据源的动态切换，目的是为了在不影响主数据库性能的情况下，进行特定查询操作。作者通过配置两个数据源（主数据源和从数据源），并设计了一种基于AOP...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值