其他分享
首页 > 其他分享> > SpringBoot双数据源配置

SpringBoot双数据源配置

作者:互联网

一、多套数据源

  1、独立数据库连接信息

  Spring Boot 的默认配置文件是 application.properties ,由于有两个数据库配置,独立配置数据库是好的实践,因此添加配置文件 jbdc.properties ,添加以下自定义的主从数据库配置:

# db01
spring.datasource.db01.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.db01.jdbc-url=jdbc:mysql://localhost:3306/java-training-camp?useSSL=false&serverTimezone=GMT%2B8&characterEncoding=UTF-8
spring.datasource.db01.username=root
spring.datasource.db01.password=ENC(wcXqCViJj4dmV1YsJPJPaFUNJFH8F4DNSe0XDy/bQKMmpd2eSA+zpE3fc82qlGbT)

# db02
spring.datasource.db02.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.db02.jdbc-url=jdbc:mysql://localhost:3306/xxl_job?useSSL=false&serverTimezone=GMT%2B8&characterEncoding=UTF-8
spring.datasource.db02.username=root
spring.datasource.db02.password=ENC(wcXqCViJj4dmV1YsJPJPaFUNJFH8F4DNSe0XDy/bQKMmpd2eSA+zpE3fc82qlGbT)

 

  2、多套数据源配置

  有了数据源连接信息,需要把数据源注入到 Spring 中。由于每个数据库使用独立的一套数据库连接,数据库连接使用的 SqlSession 进行会话连接,SqlSession 是由SqlSessionFactory 生成。因此,需要分别配置SqlSessionFactory 。以下操作均在 config 目录 下:

  (1)添加 DataSourceConfig 配置文件,注入主从数据源

    注解 PropertySource 指定配置信息文件

    注解 ConfigurationProperties 指定不同数据源配置前缀

    分别指定数据源名称

@Configuration
@PropertySource("classpath:jdbc.properties")
public class DatasourceConfig {

    @Bean("db01")
    @ConfigurationProperties(prefix = "spring.datasource.db01")
    public DataSource db01DataSource(){
        return DataSourceBuilder.create().build();
    }

    @Bean("db02")
    @ConfigurationProperties(prefix = "spring.datasource.db02")
    public DataSource db02DataSource(){
        return DataSourceBuilder.create().build();
    }
}

 

  (2)添加 MasterMybatisConfig 配置文件,注入各个数据源的SqlSessionFactory注解 MapperScan 指定那些包下的 mapper 使用本数据源,并指定使用哪个SqlSessionFactory,注意,此处的 sqlSessionFactoryRef 即本配置中的注入的 SqlSessionFactory。

    设置指定的数据源,使用 Qualifier 指定。

    如果使用的是MyBatis Plus, 对应的 Mapper 若有自定义的 mapper.xml, 则使用 setMapperLocations 指定。若需要对实体进行别名处理,则使用 setTypeAliasesPackage 指定。

@Configuration
@MapperScan(basePackages = "com.lcl.mysqldemo.mapper.db01",sqlSessionFactoryRef = "db01SqlSessionFactory")
public class Db01MabatisConfig {

    @Bean("db01SqlSessionFactory")
    public SqlSessionFactory db01SqlSessionFactory(@Qualifier("db01") DataSource dataSource) throws Exception {
        MybatisSqlSessionFactoryBean mybatisSqlSessionFactoryBean = new MybatisSqlSessionFactoryBean();
        mybatisSqlSessionFactoryBean.setDataSource(dataSource);

        PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        String locationPattern = "classpath*:/mapper/db01/*.xml";
        mybatisSqlSessionFactoryBean.setMapperLocations(resolver.getResources(locationPattern));
        String typeAliasesPackage = "com.lcl.mysqldemo.entity.db01";
        mybatisSqlSessionFactoryBean.setTypeAliasesPackage(typeAliasesPackage);
        return mybatisSqlSessionFactoryBean.getObject();
    }
}

 

@Configuration
@MapperScan(basePackages = "com.lcl.mysqldemo.mapper.db02",sqlSessionFactoryRef = "db02SqlSessionFactory")
public class Db02MabatisConfig {

    @Bean("db02SqlSessionFactory")
    public SqlSessionFactory db01SqlSessionFactory(@Qualifier("db02") DataSource dataSource) throws Exception {
        MybatisSqlSessionFactoryBean mybatisSqlSessionFactoryBean = new MybatisSqlSessionFactoryBean();
        mybatisSqlSessionFactoryBean.setDataSource(dataSource);

        PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        String locationPattern = "classpath*:/mapper/db02/*.xml";
        mybatisSqlSessionFactoryBean.setMapperLocations(resolver.getResources(locationPattern));
        String typeAliasesPackage = "com.lcl.mysqldemo.entity.db02";
        mybatisSqlSessionFactoryBean.setTypeAliasesPackage(typeAliasesPackage);
        return mybatisSqlSessionFactoryBean.getObject();
    }
}

 

  (3)多套实体

    在 MyBatis 配置中,实体设置 typeAliases 可以简化 xml 的配置,前面提到,使用 typeAliasesPackage 设置实体路径,在 entity 包下分别设置 db01 和 db02 包,存放两个库对应的表实体。

  (4)多套 mapper xml 文件

    在 resources/mapper 下,同样设置 db01 及 db02 目录,分别存放对应的mapper xml 文件。

  3、多数据源使用

    经过上面的多套数据源配置,可知道,若需要操作哪个数据库,直接使用对应的 mapper 进行 CRUD 操作即可。如下为 Controller 中分别查询两个库,获取到的数据合在一起返回:

@RestController
@RequestMapping("/test")
public class TestController {

    @Autowired
    private OrderInfoMapper orderInfoMapper;
    @Autowired
    private XxlJobInfoMapper xxlJobInfoMapper;

    @GetMapping("/03")
    public String test02(){
        Map<String, String> map = new HashMap<>();
        OrderInfo orderInfo = orderInfoMapper.selectByPrimaryKey(1);
        XxlJobInfo xxlJobInfo = xxlJobInfoMapper.selectByPrimaryKey(2);
        map.put("orderInfo", JSON.toJSONString(orderInfo));
        map.put("xxlJobInfo", JSON.toJSONString(xxlJobInfo));
        return JSON.toJSONString(map);
    }
}

 

   4、优缺点

    (1)优点

      简单、直接:一个库对应一套处理方式,很好理解。

      符合开闭原则( OCP ):开发的设计模式告诉我们,对扩展开放,对修改关闭,添加多一个数据库,原来的那一套不需要改动,只添加即可。

    (2)缺点

      资源浪费:针对每一个数据源写一套操作,连接数据库的资源也是独立的,分别占用同样多的资源。SqlSessionFactory 是一个工厂,建议是使用单例,完全可以重用,不需要建立多个,只需要更改数据源即可,跟多线程,使用线程池减少资源消耗是同一道理。

      代码冗余:在前面的多数据源配置中可以看出,其实 db01 和 db02 的很多操作是一样的,只是改个名称而已,因此会造成代码冗余。

      缺乏灵活:所有需要使用的地方都需要引入对应的mapper,对于很多操作,只是选择数据源的不一样,代码逻辑是一致的。另外,对于是主从数据库的配置,一主多从的情况,若需要对多个从库进行负载均衡,相对比较麻烦。

    正因为有上述的缺点,所以还有改进的空间。于是就有了动态数据源,至于动态数据源如何实现,下回分解。

二、动态数据源流程说明

  Spring Boot 的动态数据源,本质上是把多个数据源存储在一个 Map 中,当需要使用某个数据源时,从 Map 中获取此数据源进行处理。而在 Spring 中,已提供了抽象类 AbstractRoutingDataSource 来实现此功能。因此,我们在实现动态数据源的,只需要继承它,实现自己的获取数据源逻辑即可。

  1、添加动态数据源的配置

  (1)配置相关

# db01
spring.datasource.dynamicdb01.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.dynamicdb01.jdbc-url=jdbc:mysql://localhost:3306/java-training-camp?useSSL=false&serverTimezone=GMT%2B8&characterEncoding=UTF-8
spring.datasource.dynamicdb01.username=root
spring.datasource.dynamicdb01.password=ENC(wcXqCViJj4dmV1YsJPJPaFUNJFH8F4DNSe0XDy/bQKMmpd2eSA+zpE3fc82qlGbT)

# db02
spring.datasource.dynamicdb02.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.dynamicdb02.jdbc-url=jdbc:mysql://localhost:3306/xxl_job?useSSL=false&serverTimezone=GMT%2B8&characterEncoding=UTF-8
spring.datasource.dynamicdb02.username=root
spring.datasource.dynamicdb02.password=ENC(wcXqCViJj4dmV1YsJPJPaFUNJFH8F4DNSe0XDy/bQKMmpd2eSA+zpE3fc82qlGbT)

  (2)把数据源常量写在 DataSourceConstants 类中

public class DataSourceConstants {
    public static final String DS_KEY_DB01 = "dynamicdb01";
    public static final String DS_KEY_DB02 = "dynamicdb02";
}

 

  根据连接信息,把数据源注入到 Spring 中,添加 DynamicDataSourceConfig 文件,配置如下:

    此处使用 PropertySource 指定配置文件,ConfigurationProperties 指定数据源配置前缀

    使用 MapperScan 指定包,自动注入相应的 mapper 类。

    从此配置可以看到,已经把 SqlSessionFactory 这个配置从代码中擦除,直接使用 Spring Boot 自动配置的 SqlSessionFactory 即可,无需我们自己配置。

  (3)在 dynamicDataSource 方法中使用 Map 保存多个数据源,并设置到动态数据源对象中。设置默认的数据源是 db01 数据源,使用注解 Primary 优先从动态数据源中获取。

@Configuration
@PropertySource("classpath:jdbc.properties")
@MapperScan(basePackages = "com.lcl.mysqldemo.mapper.dynamic")
public class DynamicDataSourceConfig {

    @Bean(DataSourceConstants.DS_KEY_DB01)
    @ConfigurationProperties(prefix = "spring.datasource.dynamicdb01")
    public DataSource db01DataSource(){
        return DataSourceBuilder.create().build();
    }

    @Bean(DataSourceConstants.DS_KEY_DB02)
    @ConfigurationProperties(prefix = "spring.datasource.dynamicdb02")
    public DataSource db02DataSource(){
        return DataSourceBuilder.create().build();
    }

    @Bean
    @Primary
    public DataSource dynamicDataSource(){
        Map<Object, Object> datasourceMap = new HashMap<>();
        datasourceMap.put(DataSourceConstants.DS_KEY_DB01, db01DataSource());
        datasourceMap.put(DataSourceConstants.DS_KEY_DB02, db02DataSource());
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        dynamicDataSource.setTargetDataSources(datasourceMap);
        dynamicDataSource.setDefaultTargetDataSource(db01DataSource());
        return dynamicDataSource;
    }

}

 

  2、动态数据源设置

  前面的配置已把多个数据源注入到 Spring 中,接着对动态数据源进行配置。

    (1)数据源 key 的上下文

    为了可以动态切换路由策略,需要有一个动态获取数据源 key 的地方(我们称为上下文),对于 web 应用,访问以线程为单位,使用 ThreadLocal 就比较合适

public class DynamicDataSourceContextHolder {

    /**
     * 动态数据源名称上下文
     */
    private static final ThreadLocal<String> DATA_SOURCE_CONTEXT_KEY_HOLDER = new ThreadLocal<>();

    /**
     * 设置/切换数据源
     */
    public static void setContextKey(String key){
        DATA_SOURCE_CONTEXT_KEY_HOLDER.set(key);
    }
    /**
     * 获取数据源名称
     */
    public static String getContextKey(){
        String key = DATA_SOURCE_CONTEXT_KEY_HOLDER.get();
        return key == null?DataSourceConstants.DS_KEY_DB01:key;
    }

    /**
     * 删除当前数据源名称
     */
    public static void removeContextKey(){
        DATA_SOURCE_CONTEXT_KEY_HOLDER.remove();
    }
}

 

  (2)添加动态数据源类

    继承抽象类 AbstractRoutingDataSource ,需要实现方法 determineCurrentLookupKey,即路由策略。该路由策略从上面的 DynamicDataSourceContextHolder 中获取。 

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

 

   3、验证

    默认是使用 db01 数据源查询,使用上下文的 setContextKey 来切换数据源,使用完后使用 removeContextKey 进行恢复

    @GetMapping("/03")
    public String test02(){
        Map<String, String> map = new HashMap<>();
        OrderInfo orderInfo = orderInfoMapper.selectByPrimaryKey(1);
        map.put("orderInfo", JSON.toJSONString(orderInfo));
        DynamicDataSourceContextHolder.setContextKey(DataSourceConstants.DS_KEY_DB02);
        XxlJobInfo xxlJobInfo = xxlJobInfoMapper.selectByPrimaryKey(2);
        map.put("xxlJobInfo", JSON.toJSONString(xxlJobInfo));
        DynamicDataSourceContextHolder.removeContextKey();
        return JSON.toJSONString(map);
    }
}

  4、使用 AOP 选择数据源

    经过上面的动态数据源配置,可以实现动态数据源切换,但我们会发现,在进行数据源切换时,都需要做 setContextKey 和 removeContextKey 操作,如果需要切换的方法比多,就会发现很多重复的代码,如何消除这些重复的代码,就需要用到动态代理了

  (1)定义数据源注解

    在annotation包中,添加数据源注解 DS,此注解可以写在类中,也可以写在方法定义中。

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface DS {
    String value() default DataSourceConstants.DS_KEY_DB01;
}

  (2)定义切面

    注解 Pointcut 使用 annotation 指定注解,注解 Around 使用环绕通知处理,使用上下文进行对使用注解 DS 的值进行数据源切换,处理完后,恢复数据源。  

@Aspect
@Component
public class DynamicDatasourceAspect {

    @Pointcut(value = "@annotation(com.lcl.mysqldemo.annotation.DS)")
    public void pointCut(){

    }

    @Around("pointCut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        String dsKey = getDsAnnotation(joinPoint).value();
        try{
            DynamicDataSourceContextHolder.setContextKey(dsKey);
            return joinPoint.proceed();
        }finally {
            DynamicDataSourceContextHolder.removeContextKey();
        }
    }


    private DS getDsAnnotation(ProceedingJoinPoint joinPoint){
        Class<?> targetClass = joinPoint.getTarget().getClass();
        DS annotation = targetClass.getAnnotation(DS.class);
        if(Objects.nonNull(annotation)){
            return annotation;
        }else {
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            return signature.getMethod().getAnnotation(DS.class);
        }
    }
}

 

   (3)使用 AOP 进行数据源切换

    在service层,定义一个 Service ,里面有三个方法,分别使用默认值和设置值从 db01 和 db02 中获取数据,使用了注解DS

@Service
public class TestService {

    @Autowired
    private OrderInfoMapper1 orderInfoMapper;
    @Autowired
    private XxlJobInfoMapper1 xxlJobInfoMapper;

    @DS
    public OrderInfo getOrderInfo(int key){
        return orderInfoMapper.selectByPrimaryKey(key);
    }

    @DS(DataSourceConstants.DS_KEY_DB01)
    public OrderInfo getOrderInfo2(int key){
        return orderInfoMapper.selectByPrimaryKey(key);
    }

    @DS(DataSourceConstants.DS_KEY_DB02)
    public XxlJobInfo getXxljobInfo(int key){
        return xxlJobInfoMapper.selectByPrimaryKey(key);
    }

}

 

标签:SpringBoot,数据源,配置,public,datasource,spring,db01,DS
来源: https://www.cnblogs.com/liconglong/p/16388700.html