spring boot 配置 多数据源

分类：Spring作者：特特

1. 前言

在日常生活中，我们不可避免要在工程中配置多个数据源，下面我就给大家讲一下怎么在spring boot里面配置多数据源，并且在文章结尾给出一个github的demo，希望对大家有所帮助

2. application.yml 配置多个数据库

spring:
  datasource:
    write:
      url: jdbc:mysql://192.168.31.155:3306/test_1?characterEncoding=UTF-8&useSSL=false
      username: root
      password: root
    read:
      url: jdbc:mysql://192.168.31.155:3306/test_2?characterEncoding=UTF-8&useSSL=false
      username: root
      password: root

3. spring读取配置文件

package com.multi.datasource.config;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;

/**
 * @create: 2021-01-14 14:56
 **/
@ConfigurationProperties(prefix = "spring.datasource.read")
@Data
public class DataSourceReadProperties {

    private String url;
    private String username;
    private String password;
}
package com.multi.datasource.config;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;

/**
 * @create: 2021-01-14 14:56
 **/
@ConfigurationProperties(prefix = "spring.datasource.write")
@Data
public class DataSourceWriteProperties {

    private String url;
    private String username;
    private String password;
}

4. 数据源配置

package com.multi.datasource.config;

import com.zaxxer.hikari.HikariDataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

/**
 * @create: 2021-01-14 14:55
 **/
@Configuration
public class DataSourceConfig {

    @Bean("dataSourceReadProperties")
    @ConditionalOnProperty(prefix = "spring.datasource.read", name = {"url", "username", "password"})
    public DataSourceReadProperties dataSourceReadProperties() {
        DataSourceReadProperties dataSourceReadProperties = new DataSourceReadProperties();
        return dataSourceReadProperties;
    }

    @Bean("dataSourceWriteProperties")
    @ConditionalOnProperty(prefix = "spring.datasource.write", name = {"url", "username", "password"})
    public DataSourceWriteProperties dataSourceWriteProperties() {
        DataSourceWriteProperties dataSourceWriteProperties = new DataSourceWriteProperties();
        return dataSourceWriteProperties;
    }

    @Bean("dataSourceRead")
    @ConditionalOnBean(name = "dataSourceReadProperties")
    public DataSource getDataSourceRead(@Qualifier("dataSourceReadProperties") DataSourceReadProperties dataSourceReadProperties) {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl(dataSourceReadProperties.getUrl());
        dataSource.setUsername(dataSourceReadProperties.getUsername());
        dataSource.setPassword(dataSourceReadProperties.getPassword());
        return dataSource;
    }

    @Bean("dataSourceWrite")
    @ConditionalOnBean(name = "dataSourceWriteProperties")
    public DataSource getDataSourceWrite(@Qualifier("dataSourceWriteProperties") DataSourceWriteProperties dataSourceWriteProperties) {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl(dataSourceWriteProperties.getUrl());
        dataSource.setUsername(dataSourceWriteProperties.getUsername());
        dataSource.setPassword(dataSourceWriteProperties.getPassword());
        return dataSource;
    }


    /**
     * 设置数据源路由，通过该类中的determineCurrentLookupKey决定使用哪个数据源
     */
    @Bean("routingDataSource")
    public AbstractRoutingDataSource routingDataSource(@Qualifier("dataSourceWrite") DataSource dataSourceWrite,
                                                       @Qualifier("dataSourceRead") DataSource dataSourceRead) {
        MyAbstractRoutingDataSource proxy = new MyAbstractRoutingDataSource();
        Map<Object, Object> targetDataSources = new HashMap<>(2);
        targetDataSources.put(DbContextHolder.WRITE, dataSourceWrite);
        targetDataSources.put(DbContextHolder.READ, dataSourceRead);
        proxy.setDefaultTargetDataSource(dataSourceWrite);
        proxy.setTargetDataSources(targetDataSources);
        return proxy;
    }

    /**
     * 多数据源需要自己设置sqlSessionFactory
     */
    @Bean
    public SqlSessionFactory sqlSessionFactory(@Qualifier("routingDataSource") AbstractRoutingDataSource routingDataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(routingDataSource);
        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        // mybatis的XML的配置
        bean.setMapperLocations(resolver.getResources("classpath*:mapper/*Mapper.xml"));
        return bean.getObject();
    }

    /**
     * 设置事务，事务需要知道当前使用的是哪个数据源才能进行事务处理
     */
    @Bean
    public DataSourceTransactionManager dataSourceTransactionManager(@Qualifier("routingDataSource") AbstractRoutingDataSource routingDataSource) {
        return new DataSourceTransactionManager(routingDataSource);
    }
}

5.多数据源切换配置

package com.multi.datasource.config;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;

/**
 * 这里切换读/写模式
 * 原理是利用ThreadLocal保存当前线程是否处于读模式（通过开始READ_ONLY注解在开始操作前设置模式为读模式，
 * 操作结束后清除该数据，避免内存泄漏，同时也为了后续在该线程进行写操作时任然为读模式
 *
 * @author zxliuyu
 */
@Slf4j
public class DbContextHolder {

    public static final String WRITE = "write";
    public static final String READ = "read";

    private static ThreadLocal<String> contextHolder = new ThreadLocal<>();

    public static void setDbType(String dbType) {
        if (StringUtils.isBlank(dbType)) {
            log.error("DbContextHolder dbType is null");
        }
        contextHolder.set(dbType);
    }

    public static String getDbType() {
        return StringUtils.isBlank(contextHolder.get()) ? WRITE : contextHolder.get();
    }

    public static void clearDbType() {
        contextHolder.remove();
    }
}
package com.multi.datasource.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

@Slf4j
public class MyAbstractRoutingDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        String typeKey = DbContextHolder.getDbType();
        if (typeKey.equals(DbContextHolder.WRITE)) {
            log.info("dataSource is use write");
            return typeKey;
        }
        log.info("dataSource is use read");
        return DbContextHolder.READ;
    }
}

6. 通过注解指定数据源

package com.multi.datasource.config;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @create: 2021-01-14 17:22
 **/
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface ReadOnly {
}
package com.multi.datasource.config;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;

@Aspect
@Component
@Slf4j
public class ReadOnlyInterceptor implements Ordered {

    @Around("@annotation(readOnly)")
    public Object setRead(ProceedingJoinPoint joinPoint, ReadOnly readOnly) throws Throwable {
        try {
            DbContextHolder.setDbType(DbContextHolder.READ);
            return joinPoint.proceed();
        } finally {
            // 清楚DbType一方面为了避免内存泄漏，更重要的是避免对后续在本线程上执行的操作产生影响
            DbContextHolder.clearDbType();
            log.info("remove threadLocal");
        }
    }

    @Override
    public int getOrder() {
        return 0;
    }
}

7. github地址

https://github.com/constantRAIN/multi-data-source

原文地址：https://cloud.tencent.com/developer/article/2072465

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

Spring Boot云数据库 SQL Server

相关推荐

spring的事务传播属性REQUIRED_NESTED的原理介绍
这篇文章主要介绍了spring的事务传播属性REQUIRED_NESTED的原理介绍，具有一定借鉴价值，需要的朋友可以参考下。下面就和我一起来看看吧。传统事务中回滚点的使...
一文解析spring中事务的传播机制
今天小编给大家分享的是一文解析spring中事务的传播机制，相信很多人都不太了解，为了让大家更加了解，所以给大家总结了以下内容，一起往下看吧。一定会有所收获...
SpringCloud Alibaba和SpringCloud有什么区别
这篇文章主要介绍了SpringCloudAlibaba和SpringCloud有什么区别，具有一定借鉴价值，需要的朋友可以参考下。下面就和我一起来看看吧。Spring Cloud Netfli...
Spring Cloud整合XXL-Job的几个步骤
本篇文章和大家了解一下SpringCloud整合XXL-Job的几个步骤。有一定的参考价值，有需要的朋友可以参考一下，希望对大家有所帮助。第一步：整合pom文件，在S...
Spring延迟初始化会遇到什么问题
本篇文章和大家了解一下Spring延迟初始化会遇到什么问题。有一定的参考价值，有需要的朋友可以参考一下，希望对大家有所帮助。List 坑列表 = new ArrayList(2);...
怎么使用Spring提供的不同缓存注解实现缓存
这篇文章主要介绍了怎么使用Spring提供的不同缓存注解实现缓存的相关知识，内容详细易懂，操作简单快捷，具有一定借鉴价值，相信大家阅读完这篇...
Spring中的@Autowired和@Resource注解怎么使用
本篇内容主要讲解“Spring中的@Autowired和@Resource注解怎么使用”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学...
SpringSecurity怎么定义多个过滤器链
今天小编给大家分享一下SpringSecurity怎么定义多个过滤器链的相关知识点，内容详细，逻辑清晰，相信大部分人都还太了解这方面的知识，所以分享这篇文章给大家
Spring的@Conditional注解怎么使用
这篇文章主要介绍“Spring的@Conditional注解怎么使用”的相关知识，小编通过实际案例向大家展示操作过程，操作方法简单快捷，实用性强，希望这篇“Spring的@Con...
SpringCloud Gateway的熔断限流怎么配置
这篇文章主要介绍了SpringCloudGateway的熔断限流怎么配置的相关知识，内容详细易懂，操作简单快捷，具有一定借鉴价值，相信大家阅读完这篇SpringCloud&nb...
怎么使用Spring解决循环依赖问题
今天小编给大家分享一下怎么使用Spring解决循环依赖问题的相关知识点，内容详细，逻辑清晰，相信大部分人都还太了解这方面的知识，所以分享这篇文章给大家参考
Spring事务及传播机制的原理及应用方法是什么
这篇文章主要介绍“Spring事务及传播机制的原理及应用方法是什么”的相关知识，小编通过实际案例向大家展示操作过程，操作方法简单快捷，实用性强，希望这篇“Sp...
SpringCloud Alibaba框架实例应用分析
这篇“SpringCloudAlibaba框架实例应用分析”文章的知识点大部分人都不太理解，所以小编给大家总结了以下内容，内容详细，步骤清晰，具有一定的借鉴价
Spring Boot中怎么使用Spring MVC
本篇内容主要讲解“SpringBoot中怎么使用SpringMVC”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习...
SpringMVC适配器模式作用范围是什么
这篇文章主要介绍“SpringMVC适配器模式作用范围是什么”的相关知识，小编通过实际案例向大家展示操作过程，操作方法简单快捷，实用性强，希望这篇“SpringMVC
导入SpringCloud依赖失败如何解决
这篇“导入SpringCloud依赖失败如何解决”文章的知识点大部分人都不太理解，所以小编给大家总结了以下内容，内容详细，步骤清晰，具有一定的借鉴价值，希望大家...
SpringMVC核心DispatcherServlet处理流程是什么
这篇文章主要讲解了“SpringMVC核心DispatcherServlet处理流程是什么”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来
SpringMVC HttpMessageConverter消息转换器怎么使用
今天小编给大家分享一下SpringMVCHttpMessageConverter消息转换器怎么使用的相关知识点，内容详细，逻辑清晰，相信大部分人都还太了解这方面的知识，所以...
Spring框架实现依赖注入的原理是什么
这篇文章主要介绍“Spring框架实现依赖注入的原理是什么”的相关知识，小编通过实际案例向大家展示操作过程，操作方法简单快捷，实用性强，希望这篇“Spring框架...
Spring单元测试控制Bean注入的方法是什么
本篇内容介绍了“Spring单元测试控制Bean注入的方法是什么”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot