Springboot 多数据源配置

最新推荐文章于 2024-07-29 14:22:26 发布

马丁路德金

最新推荐文章于 2024-07-29 14:22:26 发布

阅读量552

点赞数 1

本文链接：https://blog.csdn.net/weixin_38730113/article/details/108198610

版权

springboot 多数据源配置

最全解析springboot多数据源配置
- 一.多数据源实现原理
- 二，具体实现经历如下几个步骤(总共需要创建3个类，1个枚举，1个自定义注解)：

最全解析springboot多数据源配置

由于公司对各个系统进行拆分重组，自己所在项目组被安排将两个不同数据源的项目整合到一起，但两个项目所用数据库不一致，一个是mysql,一个是oralce。按计划，先在代码层面整合，数据库后续合并。

一.多数据源实现原理

springboot支持多数据源配置，spring-jdbc下的AbstractRoutingDataSource.java类，内部提供了一个Map（targetDataSources）,装载用户定义的多数据源。在程序运行时，只需指定使用这个集合中的那个数据源，spring就会自动切换到哪个数据源下。我们将使用自定义注解实现切换。
在这里插入图片描述

二，具体实现经历如下几个步骤(总共需要创建3个类，1个枚举，1个自定义注解)：

1. 创建自定义注解 MyDynamicDataSource，代码如下：

package com.example.datasource;

import java.lang.annotation.*;


@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface MyDynamicDataSource {
    DataSourceType value();
}

@Target({ElementType.METHOD, ElementType.TYPE}) 标注了，该注解在类和方法上均适用。

2. 创建DataSourceType枚举类

package com.example.datasource;


public enum DataSourceType {
    oracle,

    mysql;

}

分别定义了oracle,mysql.作为数据源的key.

3.创建DynamicDataSourceContextHolder ，其中的 DATASOURCE_HOLDER 需要被指定为 static final。ThreadLocal是一个本地线程副本变量工具类，各个线程都拥有一份线程私有的数据，线程之间的变量互不干扰，在高并发场景下，可以实现无状态的调用。此处使用ThreadLocal，意在将数据源的取值绑定在当前线程中，不会影响其他线程，每个线程使用各自的数据源，互不干扰。

package com.example.datasource;

public class DynamicDataSourceContextHolder {
private static final ThreadLocal<String> DATASOURCE_HOLDER = new ThreadLocal<>();

public static void setDataSourceType(String dataSourceType){
    System.out.println("切换到" + dataSourceType + "数据源");
    DATASOURCE_HOLDER.set(dataSourceType);
}

public static String getDataSourceType(){
    System.out.println("获取数据源:" + DATASOURCE_HOLDER.get());
    return DATASOURCE_HOLDER.get();
}

public static void removeDataSource(){
    DATASOURCE_HOLDER.remove();
}
}

4. 创建DataSourceAspect 自定义切面，切点指向自定义注解，获取注解的value,修改ThreadLocal的值。

package com.example.datasource;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;


@Aspect
@Order(1)
@Component
public class DataSourceAspect {
    //@annotation自定义注解标注在方法上的方法执行aop方法,@within自定义注解标注在的类上；该类的所有方法（不包含子类方法）执行aop方法
    @Pointcut("@annotation(com.example.datasource.MyDynamicDataSource) || @within(com.example.datasource.MyDynamicDataSource)")
    public void abchahaha(){
        System.out.println("执行Pointcut");
    }

    @Around("abchahaha()")
    public Object abc(ProceedingJoinPoint point)throws Throwable{
        System.out.println("Around");
        MyDynamicDataSource dataSource = getDataSource(point);
        if (dataSource != null){
            DynamicDataSourceContextHolder.setDataSourceType(dataSource.value().name());
        }
        try{
            return point.proceed();
        }
        finally{
            // 销毁数据源 在执行方法之后
            DynamicDataSourceContextHolder.removeDataSource();
        }
    }

    /**
     * 获取需要切换的数据源
     */
    public MyDynamicDataSource getDataSource(ProceedingJoinPoint point){
        MethodSignature signature = (MethodSignature) point.getSignature();
        Class<? extends Object> targetClass = point.getTarget().getClass();
        MyDynamicDataSource targetDataSource = targetClass.getAnnotation(MyDynamicDataSource.class);
        if (targetDataSource != null){
            return targetDataSource;
        }
        else{
            Method method = signature.getMethod();
            MyDynamicDataSource dataSource = method.getAnnotation(MyDynamicDataSource.class);
            return dataSource;
        }
    }

}

5.创建DynamicDataSource 继承AbstractRoutingDataSource 类，实现抽象方法determineCurrentLookupKey。实现数据源切换的功能就是自定义一个类扩展AbstractRoutingDataSource抽象类，其实该相当于数据源DataSourcer的路由中介，可以实现在项目运行时根据相应key值切换到对应的数据源DataSource上。

package com.example.datasource;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import javax.sql.DataSource; 
import java.util.Map;

public class DynamicDataSource extends AbstractRoutingDataSource {

	public DynamicDataSource(){ 
		System.out.println("动态数据源类被实例化(无参)"); 
	}
	
	public DynamicDataSource(DataSource defaultTargetDataSource, Map<Object, Object> targetDataSources) { 
		System.out.println("动态数据源类被实例化(有参)"); 
		super.setDefaultTargetDataSource(defaultTargetDataSource); 
		super.setTargetDataSources(targetDataSources); 
		super.afterPropertiesSet(); 
	}
	
	@Override protected Object determineCurrentLookupKey() { 
		return DynamicDataSourceContextHolder.getDataSourceType(); 
	} 
}

6. 在系统启动时读取配置文件，初始化数据源：

package com.example.config;

import com.example.datasource.DataSourceType;
import com.example.datasource.DynamicDataSource;
import com.example.listener.DemoListener;
import com.example.listener.DemoServlet;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletListenerRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import org.springframework.context.annotation.Primary;

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


@Configuration
public class SystemConfig {

    //配置动态数据源
    @Bean("oracleDataSource")
    @ConfigurationProperties("spring.datasource.oracle")
    public DataSource oracleDataSource() {
        return DruidDataSourceBuilder.create().build();
    }
    @Bean("mySqlDataSource")
    @ConfigurationProperties("spring.datasource.mysql")
    public DataSource mysqlDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean(name = "dynamicDataSource")
    @Primary
    public DynamicDataSource dataSource() {
        System.out.println("动态数据源加载开始");
        DataSource defaultDataSource=oracleDataSource();
        Map<Object, Object>; targetDataSources = new HashMap<>;();
        targetDataSources.put(DataSourceType.oracle.name(), defaultDataSource);
        targetDataSources.put(DataSourceType.mysql.name(), mysqlDataSource());
        return new DynamicDataSource(defaultDataSource, targetDataSources);
    }
}

7.yaml配置文件：

#动态数据源配置
spring:
  datasource:
      oracle:
        driver-class-name: oracle.jdbc.driver.OracleDriver
        url: jdbc:oracle:thin:***
        username: ***
        password: ***
        type: com.alibaba.druid.pool.DruidDataSource
        InitialSize: 8
        filters: stat,wall,log4j
        maxPoolPreparedStatementPerConnectionSize: 20
        useGlobalDataSourceStat: true
        connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500
      mysql:
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://***
        username: ***
        password: ***
        type: com.alibaba.druid.pool.DruidDataSource
        InitialSize: 8
        filters: stat,wall,log4j
        maxPoolPreparedStatementPerConnectionSize: 20
        useGlobalDataSourceStat: true
        connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500
  resources:
      static-locations: static-locations=classpath:/META-INF/resources/,classpath:/resources/,classpath:/static/**,classpath:/public/,file:c:/dev/uploads/
  thymeleaf:
    encoding: utf-8

8. 在Controller类上使用注解，此controller所有数据库操作均使用对应数据源




@RestController
@RequestMapping("/mainController")
@MyDynamicDataSource(DataSourceType.mysql)
public class MainController {

    @Autowired
    public UserService userService;

    //查询所有用户
    @RequestMapping(value = "/index")
    public RespStat index(HttpSession session){
        RespStat res = new RespStat();
        res.setCode("success");
        res.setMsg(userService.getServArg1());
        res.setResponesBody(userService.findAllDto());
        return res;
    }
}

9.启动项目验证配置是否成功。

10.相关maven依赖

        <!--AOP相关-->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aop</artifactId>
		</dependency>
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
		</dependency>
                <dependency>
			<groupId>com.hynnet</groupId>
			<artifactId>oracle-driver-ojdbc6</artifactId>
			<version>12.1.0.1</version>
		</dependency>
		<!--Druid数据库连接池需要使用-->
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>1.2.17</version>
		</dependency>
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid-spring-boot-starter</artifactId>
			<version>1.1.20</version>
		</dependency>
		<!--mysql-->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>

马丁路德金

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
Springboot 多数据源配置

springboot 多数据源配置最全解析springboot多数据源配置一.多数据源实现原理二，具体实现经历如下几个步骤(总共需要创建3个类，1个枚举，1个自定义注解)：最全解析springboot多数据源配置由于公司对各个系统进行拆分重组，自己所在项目组被安排将两个不同数据源的项目整合到一起，但两个项目所用数据库不一致，一个是mysql,一个是oralce。按计划，先在代码层面整合，数据库后续合并。一.多数据源实现原理springboot支持多数据源配置，spring-jdbc下的Abstrac
复制链接

扫一扫