springboot动态数据源的切换

最新推荐文章于 2024-07-29 15:07:01 发布
最新推荐文章于 2024-07-29 15:07:01 发布
阅读量168 收藏
点赞数
文章标签： java 数据库 runtime
原文链接：https://my.oschina.net/u/2504004/blog/2997035
版权

1、开启数据库配置在启动类中增加 @EnableDataSources

@SpringBootApplication
@EnableDataSources
public class OrderServiceApplication {

    public static void main(String[] args) {
        new SpringApplicationBuilder(OrderServiceApplication.class).web(WebApplicationType.SERVLET).run(args);

    }

}

2、在配置文件中增加配置

 

## jdbc 配置信息
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.initialSize=10
jdbc.maxActive=100
jdbc.minIdle=5
jdbc.maxWait=5000
jdbc.dataAddres.order-1.url=jdbc:mysql://127.0.0.1/mysql
jdbc.dataAddres.order-1.userName=name
jdbc.dataAddres.order-1.password=password
jdbc.dataAddres.order-1.master=true

jdbc.dataAddres.order-2.url=jdbc:mysql://127.0.0.1/mysql
jdbc.dataAddres.order-2.userName=name
jdbc.dataAddres.order-2.password=password
jdbc.dataAddres.order-2.master=true

jdbc.dataAddres.order-3.url=jdbc:mysql://127.0.0.1/mysql
jdbc.dataAddres.order-3.userName=name
jdbc.dataAddres.order-3.password=password
jdbc.dataAddres.order-3.master=false

jdbc.dataAddres.order-4.url=jdbc:mysql://127.0.0.1/mysql
jdbc.dataAddres.order-4.userName=name
jdbc.dataAddres.order-4.password=password
jdbc.dataAddres.order-4.master=false

jdbc.rules.order=^com\\.xxx\\.xxx\\.service\\..+$

主要是@EnableDataSources配置类

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
@Import({DataImportBeanDefinitionRegistrar.class,DataSourcesConfig.class})
public @interface EnableDataSources {

}

包含DataImportBeanDefinitionRegistrar和DataSourcesConfig 2个类

DataImportBeanDefinitionRegistrar类主要是获取配置文件中的属性来，注册数据源、动态切换h

public class DataImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar, EnvironmentAware {
    private Environment environment;
    /** 默认数据源名字 */
    private String defaultName;

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        StandardEnvironment standardEnvironment = (StandardEnvironment)environment;
        Iterator<PropertySource<?>> sources = standardEnvironment.getPropertySources().iterator();
        List<ConfigurationPropertySource> configs = new ArrayList<>();
        //获取数据源
        while(sources.hasNext()){
            PropertySource<?> source = sources.next();
            Iterable<ConfigurationPropertySource> a = ConfigurationPropertySources.from(source);
            a.forEach(info->configs.add(info));
        }
        //绑定数据源
        Binder binder = new Binder(configs);
        try {
            //解析属性
            BindResult<DataResources> response = binder.bind("jdbc", DataResources.class);
            DataResources dataResources = response.get();
            if(Objects.nonNull(dataResources)){
                //多数据源配置Map
                ManagedMap<String, Object> keys = new ManagedMap<>();
                //注册数据源
                boolean state = registerDataSource(registry, keys, dataResources);
                if(!state){
                    return;
                }
                //注册路由切换
                registerRoutingDataSource(registry,keys);
                //事务注册 DataSourceTransactionManager
                registerTransactionManager(registry);
                //拦截器 DatasourceAutoChanger
                registerDatasourceAutoChanger(registry,dataResources.getRules());
                //事务拦截器 TransactionInterceptor
                registerTransactionInterceptor(registry);
            }
        } catch (Exception e) {
            //e.printStackTrace();
        }
    }

    /**
     * 注册数据源
     * @param registry BeanDefinitionRegistry
     * @param keys ManagedMap
     * @param dataResources DataResources
     * @return boolean
     */
    private boolean registerDataSource(BeanDefinitionRegistry registry,ManagedMap<String, Object> keys,DataResources dataResources){

        //注册数据源
        final Map<String, Object> propertyValues = getPropertyValues(dataResources);
        Map<String, DataResources.DataAddress> dataAddress = dataResources.getDataAddres();
        //判断是否配置数据源
        if(Objects.isNull(dataAddress) && dataAddress.size() == 0){
            return false;
        }
        dataAddress.forEach(( key,value)->{
            String name = key.split("-")[0];
            if(defaultName == null){
                defaultName = name;
            }
            name = DatasourceAutoChanger.addDataName(name,value.getMaster());
            System.out.println("数据库主从名称："+name);
            RootBeanDefinition beanDefinition = new RootBeanDefinition();
            beanDefinition.setBeanClass(DruidDataSource.class);
            beanDefinition.setInitMethodName("init");
            Map<String, Object> propertys = getPropertyValuesAddress(value);
            propertys.putAll(propertyValues);
            beanDefinition.getPropertyValues().addPropertyValues(propertys);
            registry.registerBeanDefinition(name,beanDefinition);
            keys.put(name,new RuntimeBeanReference(name));
        });
        return true;
    }

    /**
     * 注册动态切换数据源<br>
     * @param registry BeanDefinitionRegistry
     * @param keys ManagedMap<String, Object>
     */
    private void registerRoutingDataSource(BeanDefinitionRegistry registry,ManagedMap<String, Object> keys){
        RootBeanDefinition dataSourceRute = new RootBeanDefinition();
        dataSourceRute.setBeanClass(RoutingDataSource.class);
        MutablePropertyValues rutePropertyValues = dataSourceRute.getPropertyValues();
        rutePropertyValues.addPropertyValue("defaultTargetDataSource",new RuntimeBeanReference(DatasourceAutoChanger.getMasterNameFrist(defaultName)));
        rutePropertyValues.addPropertyValue("targetDataSources",keys);
        registry.registerBeanDefinition("dataSource",dataSourceRute);
    }

    /**
     * 事务注册<br>
     * @param registry
     */
    private void registerTransactionManager(BeanDefinitionRegistry registry){
        RootBeanDefinition transactionManagerBean = new RootBeanDefinition();
        transactionManagerBean.setBeanClass(DataSourceTransactionManager.class);
        transactionManagerBean.getPropertyValues().addPropertyValue("dataSource",new RuntimeBeanReference("dataSource"));
        registry.registerBeanDefinition("transactionManager",transactionManagerBean);
    }

    /**
     * 自动切换数据源<br>
     * @param registry
     * @param rules
     */
    private void registerDatasourceAutoChanger( BeanDefinitionRegistry registry,Map<String,String> rules){
        //拦截器 datasourceAutoChanger
        RootBeanDefinition datasourceAutoChanger = new RootBeanDefinition();
        datasourceAutoChanger.setBeanClass(DatasourceAutoChanger.class);
        datasourceAutoChanger.getPropertyValues().addPropertyValue("rules",rules);
        registry.registerBeanDefinition("datasourceAutoChanger",datasourceAutoChanger);
    }

    /**
     * 事务拦截注册<br>
     * @param registry
     */
    private void registerTransactionInterceptor( BeanDefinitionRegistry registry){
        //拦截器 datasourceAutoChanger
        RootBeanDefinition transactionInterceptorBean = new RootBeanDefinition();
        transactionInterceptorBean.setBeanClass(TransactionInterceptor.class);
        transactionInterceptorBean.getPropertyValues().addPropertyValue("transactionManager",new RuntimeBeanReference("transactionManager"));
        Properties properties = new Properties();
        properties.put("save*","PROPAGATION_REQUIRES_NEW,ISOLATION_DEFAULT,-java.lang.Exception");
        properties.put("create*","PROPAGATION_REQUIRES_NEW,ISOLATION_DEFAULT,-java.lang.Exception");
        properties.put("insert*","PROPAGATION_REQUIRES_NEW,ISOLATION_DEFAULT,-java.lang.Exception");
        properties.put("delete*","PROPAGATION_REQUIRES_NEW,ISOLATION_DEFAULT,-java.lang.Exception");
        properties.put("update*","PROPAGATION_REQUIRES_NEW,ISOLATION_DEFAULT,-java.lang.Exception");
        properties.put("remove*","PROPAGATION_REQUIRES_NEW,ISOLATION_DEFAULT,-java.lang.Exception");
        transactionInterceptorBean.getPropertyValues().addPropertyValue("transactionAttributes",properties);
        registry.registerBeanDefinition("transactionInterceptor",transactionInterceptorBean);
    }

    /**
     * 获取数据连接公共属性<br/>
     * @param dataResources 属性
     * @return Map<String,Object>
     */
    private Map<String,Object> getPropertyValues(DataResources dataResources){
        Map<String,Object> propertyValue = new HashMap<>();
        propertyValue.put("driverClassName",dataResources.getDriverClassName());
        propertyValue.put("initialSize",dataResources.getInitialSize());
        propertyValue.put("minIdle",dataResources.getMinIdle());
        propertyValue.put("maxActive",dataResources.getMaxActive());
        propertyValue.put("maxWait",dataResources.getMaxWait());
        propertyValue.put("timeBetweenEvictionRunsMillis",dataResources.getTimeBetweenEvictionRunsMillis());
        propertyValue.put("minEvictableIdleTimeMillis",dataResources.getMinEvictableIdleTimeMillis());
        propertyValue.put("validationQuery",dataResources.getValidationQuery());
        propertyValue.put("testWhileIdle",dataResources.isTestWhileIdle());
        propertyValue.put("testOnBorrow",dataResources.isTestOnBorrow());
        propertyValue.put("testOnReturn",dataResources.isTestOnReturn());
        return propertyValue;

    }

    /**
     * 获取连接数据库用户账号和路径<br/>
     * @param dataAddress
     * @return Map<String,Object>
     */
    private Map<String,Object> getPropertyValuesAddress(DataResources.DataAddress dataAddress){
        Map<String,Object> propertyValue = new HashMap<>();
        propertyValue.put("url",dataAddress.getUrl());
        propertyValue.put("username",dataAddress.getUserName());
        propertyValue.put("password",dataAddress.getPassword());
        return propertyValue;
    }
    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
    }
}

DataSourcesConfig类主要是方法拦截配置

@Configuration
public class DataSourcesConfig {

    @Bean("dataSourceAutoProxyCreator")
    public BeanNameAutoProxyCreator beanNameAutoProxyCreator(){
        BeanNameAutoProxyCreator dataSourceAutoProxyCreator = new BeanNameAutoProxyCreator();
        dataSourceAutoProxyCreator.setBeanNames("**ServiceImpl");
        dataSourceAutoProxyCreator.setInterceptorNames("datasourceAutoChanger","transactionInterceptor");
        return dataSourceAutoProxyCreator;
    }
}

 

下面是用到的几个类

RoutingDataSource类

public class RoutingDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return DatasourceHolder.getRouteKey();
    }
}

DatasourceHolder类

public class DatasourceHolder {

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

    public static String getRouteKey() {
        return threadLocal.get();
    }

    public static void setRouteKey(String key) {
        threadLocal.set(key);
    }
}

DatasourceAutoChanger类

public class DatasourceAutoChanger implements MethodBeforeAdvice {
    /** 数据源 */
    static Map<String, DataName> datas = new HashMap<>();

    /** 路由规则 */
    Map<String,String> rules = new HashMap<>();

    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        String name = method.getDeclaringClass().getName() + "." + method.getName();
        isFind:
        for (Map.Entry<String,String> entity : rules.entrySet()){
            String expressions = entity.getValue();
            for (String expression:expressions.split(",")){
                if(Pattern.matches(expression,name)){
                    boolean master = true;
                    if(method.getName().startsWith("select") || method.getName().startsWith("get") || method.getName().startsWith("find") || method.getName().startsWith("list")){
                        master = false;
                    }
                    DataName dataName = datas.get(entity.getKey());

                    if(Objects.nonNull(dataName)){
                        String random = dataName.randomName(entity.getKey(), master);
                        System.out.println("选择的数据源："+random);
                        DatasourceHolder.setRouteKey(random);
                    }
                    break isFind;
                }
            }
        }
    }


    public static void main(String[] args) {
        Random random = new Random();
        for (int i = 0 ;i<100;i++){
            System.out.println(random.nextInt(6));
        }

    }
    public Map<String, String> getRules() {
        return rules;
    }

    public void setRules(Map<String, String> rules) {
        this.rules = rules;
    }

    /**
     * 添加数据源名称<br>
     * @param name String
     * @param master  boolean
     * @return String
     */
    public static String addDataName(String name,boolean master){
        DataName dataName = datas.get(name);
        if(Objects.isNull(dataName)){
            dataName = new DataName();
            datas.put(name,dataName);
        }
        return dataName.addDataName(name,master);

    }

    /**
     * 获取主库<br>
     * @param name
     * @return
     */
    public static String getMasterNameFrist(String name){
        DataName dataName = datas.get(name);
        if(dataName == null){
            return null;
        }
        return dataName.getMasterNames().get(0);
    }
    static class DataName{
        /** 主库名 */
        List<String> masterNames = new ArrayList<>();
        /** 从库名 */
        List<String> slaveNames = new ArrayList<>();

        /**
         * 添加数据源名称<br>
         * @param name String
         * @param master boolean
         * @return
         */
        public String addDataName(String name,boolean master){
            Integer length = master?masterNames.size():slaveNames.size();
            name = name + (master?"-master-":"-slave-")+(++length);
            if(master){
                masterNames.add(name);
            }else{
                slaveNames.add(name);
            }
            return name;
        }
        /**
         * 添加数据源名称<br>
         * @param name String
         * @param master boolean
         * @return
         */
        public String randomName(String name,boolean master){
            Integer length = master?masterNames.size():slaveNames.size();
            Integer index = 0;
            if(length > 1){
                Random random = new Random();
                index = random.nextInt(length);
            }
            System.out.println("index:"+index);
            return master?masterNames.get(index):slaveNames.get(index);
        }
        public List<String> getMasterNames() {
            return masterNames;
        }

        public void setMasterNames(List<String> masterNames) {
            this.masterNames = masterNames;
        }

        public List<String> getSlaveNames() {
            return slaveNames;
        }

        public void setSlaveNames(List<String> slaveNames) {
            this.slaveNames = slaveNames;
        }
    }
}

转载于:https://my.oschina.net/u/2504004/blog/2997035

chuhanlou7483
关注
SpringBoot中多数据源灵活切换解决方案
lucky_love816的博客
04-26 1111
本篇内容介绍了“SpringBoot中如何使用Dynamic Datasource配置多数据源”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！支持 数据源分组 ，适用于多种场景 纯粹多库 读写分离 一主多从 混合模式。支持无数据源启动，支持配置懒启动数据源(3.3.2+)。支持数据库敏感配置信息 加密 ENC()。支持每个数据库独立初始化表结构schema和数据库database。
springboot动态切换数据源
m0_65106897的博客
12-09 4052
在springboot项目中只需一句代码即可实现多个数据源之间的切换: // 切换sqlserver数据源: DataSourceContextHolder.setDataBaseType(DataSourceEnum.SQLSERVER_DATASOURCE); … // 切换mysql数据源 DataSourceContextHolder.setDataBaseType(DataSourceEnum.MYSQL_DATASOURCE); 1 2 3 4 5 具体实现: 本实例基于springboot2.
springboot配置多数据源及单库事务控制
婲落ヽ红颜谇的博客
10-29 398
1.背景介绍 通过springboot操作mysql数据库，但是在实际业务场景中，数据量迅速增长，一个库一个表已经满足不了我们的需求的时候，我们就会考虑分库分表的操作，在springboot中如何实现多数据源，动态数据源切换，读写分离等操作。 2.所需依赖 #父级项目依赖 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-.
SpringBoot轻松实现多数据源切换
最新发布
观止study
07-29 1448
项目需要实现在多个数据源之间读写数据，例如在 A 数据源和 B 数据源读取数据，然后在 C 数据源写入数据 或者 部分业务数据从 A 数据源中读取、部分从B数据源中读取诸如此类需求。本文将简单模拟在SpringBoot项目中实现不同数据源之间读取数据。
基于SpringBoot实现数据源的切换
心如止水
02-02 579
基于SpringBoot实现数据源的切换多数据源切换的思路yml 配置多数据源注入数据源bean定义apo切面以及数据源切换注解测试样例 多数据源切换的思路 Spring 框架具有ioc和aop两大特性，简单来说就是管理bean和面向切面编程。通过Spring 框架实现我们的动态数据源，可以通过继承 yml 配置多数据源 注入数据源bean 定义apo切面以及数据源切换注解 测试样例 ...
使用Spring Boot实现动态数据源切换
省赚客开发者博客
07-12 472
在现代应用中，使用多个数据源是一个常见的需求。比如，我们可能需要在读写分离的数据库架构中，根据不同的操作选择不同的数据源。在需要切换数据源的方法上添加注解，然后在AOP切面中切换数据源。通过上述步骤，我们成功实现了Spring Boot项目中的动态数据源切换功能。这样，我们可以根据不同的业务需求，在运行时动态选择和切换数据源。大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！首先，在Spring Boot项目中引入必要的依赖。在需要使用动态数据源的服务方法上添加。
SpringBoot动态切换数据源
qq_37634156的博客
08-24 4434
这里需要注意如果SpringBoot版本是2.0之后的版本，需要把【url】和【driverClassName】写成【jdbc-url】和【driver-class-name】，否则会报错【jdbcUrl is required with driverClassName.】自定义数据源枚举类，这里配置了两个数据源，则创建两个枚举。 3、注入数据源 生成bean。单一数据源与Mybatis整合时将DataSource数据源作为参数构建【SqlSessionFactory】，而多个数据源的话只需要将作为
SpringBoot数据源动态切换
qq_52927274的博客
03-31 280
SpringBoot数据源动态切换 maven依赖 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <
基于springboot整理的分布式事务及动态数据源切换
04-17
整理的分布式事务 及动态数据源切换 基于数据库XA协议 maven 包可直接使用 maven 引入路径: <groupId>com.maple</groupId> <artifactId>DCSDataSourcesServer <version>0.0.1-SNAPSHOT 事务及数据源标签...
SpringBoot配置多数据源实现动态切换数据源
06-29
本文将深入探讨如何在SpringBoot项目中配置多数据源，并实现数据源的动态切换，帮助你理解和掌握这一核心技能。 首先，我们理解"多数据源"的概念。在SpringBoot应用中，多数据源意味着系统能够连接并操作多个不同的...
SpringBoot 动态数据源切换
06-13
SpringBoot 中实现动态数据源切换有多种方式，其中一种比较常用的方式是通过使用 AbstractRoutingDataSource 类和 ThreadLocal 来实现。 具体步骤如下： 1. 创建一个继承 AbstractRoutingDataSource 类的类，重写 ...
SpringBoot整合Sharding-JDBC，实现从数据库加载sharding-jdbc数据源，实现多种数据库数据源切换，数据库方言动态切换
03-22
SpringBoot整合Sharding-JDBC，实现从数据库读取sharding-jdbc数据源，实现多种数据库数据源切换，数据库方言动态切换
SpringBoot多数据源切换.zip
11-24
SpringBoot多数据源切换.zip
SpringBoot实现动态切换数据源（含源码）
a342874650的专栏
01-25 1077
`ThreadLocal` 和 `AbstractRoutingDataSource` 是两个在Java中用于实现动态数据源切换的工具。本文详细介绍了使用该方法实现动态切换数据源的方法并附上详细的源代码。
springboot 多数据源之间切换
qq_38497071的博客
10-30 207
1.yml配置多个数据源 2.添加以下几个类 import java.util.HashMap; import java.util.Map; import javax.annotation.Resource; import javax.sql.DataSource; import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties; import org.springframework.jdbc.datasource
SpringBoot实现多数据源切换
白豆五的博客
07-04 1662
随着项目规模的扩大和业务需求的复杂化，单一数据源已经不能满足实际开发中的需求。在许多情况下，我们需要同时操作多个数据库，或者需要将不同类型的数据存储在不同的数据库中。这时，多数据源场景成为必不可少的解决方案。市面上常见的多数据源实现方案如下：方案1：基于Spring框架提供的AbstractRoutingDataSourc。优点： 简单易用，支持动态切换数据源；适用于少量数据源情况。场景：适用于需要动态切换数据源，且数据库较少的情况。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值