本文实现案例场景：
某系统除了需要从自己的主要数据库上读取和管理数据外，还有一部分业务涉及到其他多个数据库，要求可以在任何方法上可以灵活指定具体要操作的数据库。

为了在开发中以最简单的方法使用，本文基于注解和AOP的方法实现，在spring boot框架的项目中，添加本文实现的代码类后，只需要配置好数据源就可以直接通过注解使用，简单方便。

一配置二使用
1. 启动类注册动态数据源
2. 配置文件中配置多个数据源
3. 在需要的方法上使用注解指定数据源

1、在启动类添加 @Import({DynamicDataSourceRegister.class, MProxyTransactionManagementConfiguration.class})

@SpringBootApplication

@Import({DynamicDataSourceRegister.class}) // 注册动态多数据源

public class SpringBootSampleApplication {

<span class="hljs-comment">// 省略其他代码</span>




}

2、配置文件配置内容为：
（不包括项目中的其他配置，这里只是数据源相关的）

# 主数据源，默认的


spring.datasource.driver-class-name=com.mysql.jdbc.Driver


spring.datasource.url=jdbc:mysql://localhost:3306/test


spring.datasource.username=root


spring.datasource.password=123456


# 更多数据源


custom.datasource.names=ds1,ds2



custom.datasource.ds1.driver-class-name=com.mysql.jdbc.Driver



custom.datasource.ds1.url=jdbc:mysql://localhost:3306/test1



custom.datasource.ds1.username=root



custom.datasource.ds1.password=123456


custom.datasource.ds2.driver-class-name=com.mysql.jdbc.Driver



custom.datasource.ds2.url=jdbc:mysql://localhost:3306/test2



custom.datasource.ds2.username=root



custom.datasource.ds2.password=123456

3、使用方法

package org.springboot.sample.service;


import java.sql.ResultSet;



import java.sql.SQLException;



import java.util.List;


import org.springboot.sample.datasource.TargetDataSource;



import org.springboot.sample.entity.Student;



import org.springboot.sample.mapper.StudentMapper;



import org.springframework.beans.factory.annotation.Autowired;



import org.springframework.jdbc.core.JdbcTemplate;



import org.springframework.jdbc.core.RowMapper;



import org.springframework.stereotype.Service;


/**


  • Student Service
    • 

  • @author   单红宇(365384722)
    • 

  • @myblog  http://blog.csdn.net/catoop/
    • 

  • @create    2016年1月12日


    
*/


    
@Service


    
public class StudentService {
    

@Autowired


    
private JdbcTemplate jdbcTemplate;
    

// MyBatis的Mapper方法定义接口


    
@Autowired


    
private StudentMapper studentMapper;
    

@TargetDataSource(name="ds2")


    
public List<Student> likeName(String name){


    
return studentMapper.likeName(name);


    
}

public List<Student> likeNameByDefaultDataSource(String name){


    
return studentMapper.likeName(name);


    
}


    /**

    • 不指定数据源使用默认数据源
      • 

    • @return
      • 

    • @author SHANHY
      • 

    • @create  2016年1月24日


      
*/


      
public List<Student> getList(){


      
String sql = "SELECT ID,NAME,SCORE_SUM,SCORE_AVG, AGE   FROM STUDENT";


      
return (List<Student>) jdbcTemplate.query(sql, new RowMapper<Student>(){
      

       <span class="hljs-meta">@Override</span></br>
      
 <span class="hljs-function"><span class="hljs-keyword">public</span> Student <span class="hljs-title">mapRow</span><span class="hljs-params">(ResultSet rs, <span class="hljs-keyword">int</span> rowNum)</span> <span class="hljs-keyword">throws</span> SQLException </span>{</br>
      
     Student stu = <span class="hljs-keyword">new</span> Student();</br>
      
     stu.setId(rs.getInt(<span class="hljs-string">"ID"</span>));</br>
      
     stu.setAge(rs.getInt(<span class="hljs-string">"AGE"</span>));</br>
      
     stu.setName(rs.getString(<span class="hljs-string">"NAME"</span>));</br>
      
     stu.setSumScore(rs.getString(<span class="hljs-string">"SCORE_SUM"</span>));</br>
      
     stu.setAvgScore(rs.getString(<span class="hljs-string">"SCORE_AVG"</span>));</br>
      
     <span class="hljs-keyword">return</span> stu;</br>
      
 }
      

      

      });

      
}
    


    /**
    

    • 指定数据源
      • 

    • @return
      • 

    • @author SHANHY
      • 

    • @create  2016年1月24日


      
*/

      
@TargetDataSource(name="ds1")


      
public List<Student> getListByDs1(){


      
String sql = "SELECT ID,NAME,SCORE_SUM,SCORE_AVG, AGE   FROM STUDENT";


      
return (List<Student>) jdbcTemplate.query(sql, new RowMapper<Student>(){
      

       <span class="hljs-meta">@Override</span></br>
      
 <span class="hljs-function"><span class="hljs-keyword">public</span> Student <span class="hljs-title">mapRow</span><span class="hljs-params">(ResultSet rs, <span class="hljs-keyword">int</span> rowNum)</span> <span class="hljs-keyword">throws</span> SQLException </span>{</br>
      
     Student stu = <span class="hljs-keyword">new</span> Student();</br>
      
     stu.setId(rs.getInt(<span class="hljs-string">"ID"</span>));</br>
      
     stu.setAge(rs.getInt(<span class="hljs-string">"AGE"</span>));</br>
      
     stu.setName(rs.getString(<span class="hljs-string">"NAME"</span>));</br>
      
     stu.setSumScore(rs.getString(<span class="hljs-string">"SCORE_SUM"</span>));</br>
      
     stu.setAvgScore(rs.getString(<span class="hljs-string">"SCORE_AVG"</span>));</br>
      
     <span class="hljs-keyword">return</span> stu;</br>
      
 }
      

      

      });

      
}
    


    /**
    

    • 指定数据源
      • 

    • @return
      • 

    • @author SHANHY
      • 

    • @create  2016年1月24日


      
*/


      
@TargetDataSource(name="ds2")


      
public List<Student> getListByDs2(){


      
String sql = "SELECT ID,NAME,SCORE_SUM,SCORE_AVG, AGE   FROM STUDENT";


      
return (List<Student>) jdbcTemplate.query(sql, new RowMapper<Student>(){
      

       <span class="hljs-meta">@Override</span></br>
      
 <span class="hljs-function"><span class="hljs-keyword">public</span> Student <span class="hljs-title">mapRow</span><span class="hljs-params">(ResultSet rs, <span class="hljs-keyword">int</span> rowNum)</span> <span class="hljs-keyword">throws</span> SQLException </span>{</br>
      
     Student stu = <span class="hljs-keyword">new</span> Student();</br>
      
     stu.setId(rs.getInt(<span class="hljs-string">"ID"</span>));</br>
      
     stu.setAge(rs.getInt(<span class="hljs-string">"AGE"</span>));</br>
      
     stu.setName(rs.getString(<span class="hljs-string">"NAME"</span>));</br>
      
     stu.setSumScore(rs.getString(<span class="hljs-string">"SCORE_SUM"</span>));</br>
      
     stu.setAvgScore(rs.getString(<span class="hljs-string">"SCORE_AVG"</span>));</br>
      
     <span class="hljs-keyword">return</span> stu;</br>
      
 }
      

      

      });

      
}

      
}

要注意的是，在使用MyBatis时，注解@TargetDataSource 不能直接在接口类Mapper上使用。
按上面的代码中StudentMapper为接口，代码如下：

package org.springboot.sample.mapper;


import java.util.List;


import org.springboot.sample.entity.Student;


/**

  • StudentMapper，映射SQL语句的接口，无逻辑实现
    • 

  • @author 单红宇(365384722)
    • 

  • @myblog http://blog.csdn.net/catoop/
    • 

  • @create 2016年1月20日


    
*/

    
public interface StudentMapper {
    

// 注解 @TargetDataSource 不可以在这里使用


    
List<Student> likeName(String name);
    

Student getById(int id);
    

String getNameById(int id);


}

请将下面几个类放到Spring Boot项目中。
DynamicDataSource.java
DynamicDataSourceAspect.java
DynamicDataSourceContextHolder.java
DynamicDataSourceRegister.java
TargetDataSource.java
MProxyTransactionManagementConfiguration.java
MTransactionInterceptor.java

package org.springboot.sample.datasource;


import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;


/**


  • 动态数据源
    • 

  • @author   单红宇(365384722)
    • 

  • @myblog  http://blog.csdn.net/catoop/
    • 

  • @create    2016年1月22日

    
*/

    
public class DynamicDataSource extends AbstractRoutingDataSource {
    

@Override

    
protected Object determineCurrentLookupKey() {


    
return DynamicDataSourceContextHolder.getDataSourceType();


    
}


}




package org.springboot.sample.datasource;


import org.aspectj.lang.JoinPoint;


import org.aspectj.lang.annotation.After;


import org.aspectj.lang.annotation.Aspect;


import org.aspectj.lang.annotation.Before;


import org.slf4j.Logger;


import org.slf4j.LoggerFactory;


import org.springframework.stereotype.Component;



/**

 * 切换数据源Advice


 *

 * @author 单红宇(365384722)


 * @myblog http://blog.csdn.net/catoop/


 * @create 2016年1月23日


 */

@Aspect


@Order(-1)// 保证该AOP在@Transactional之前执行

@Component

public class DynamicDataSourceAspect {


    private static final Logger logger = LoggerFactory.getLogger(DynamicDataSourceAspect.class);


    @Before("@annotation(ds)")

    public void changeDataSource(JoinPoint point, TargetDataSource ds) throws Throwable {


        String dsId = ds.name();


        if (!DynamicDataSourceContextHolder.containsDataSource(dsId)) {


            logger.error("数据源[{}]不存在，使用默认数据源 > {}", ds.name(), point.getSignature());


        } else {


            logger.debug("Use DataSource : {} > {}", ds.name(), point.getSignature());


            DynamicDataSourceContextHolder.setDataSourceType(ds.name());


        }

    }

    @After("@annotation(ds)")


    public void restoreDataSource(JoinPoint point, TargetDataSource ds) {


        logger.debug("Revert DataSource : {} > {}", ds.name(), point.getSignature());


        DynamicDataSourceContextHolder.clearDataSourceType();


    }

}


package org.springboot.sample.datasource;


import java.util.ArrayList;


import java.util.List;


public class DynamicDataSourceContextHolder {


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


    public static List<String> dataSourceIds = new ArrayList<>();




    public static void setDataSourceType(String dataSourceType) {


        contextHolder.set(dataSourceType);


    }


    public static String getDataSourceType() {


        return contextHolder.get();


    }

    public static void clearDataSourceType() {


        contextHolder.remove();


    }

    /**

     * 判断指定DataSrouce当前是否存在


     *

     * @param dataSourceId


     * @return


     * @author SHANHY


     * @create  2016年1月24日


     */

    public static boolean containsDataSource(String dataSourceId){


        return dataSourceIds.contains(dataSourceId);


    }

}


package org.springboot.sample.datasource;


import java.util.HashMap;


import java.util.Map;


import javax.sql.DataSource;


import org.slf4j.Logger;


import org.slf4j.LoggerFactory;


import org.springframework.beans.MutablePropertyValues;


import org.springframework.beans.PropertyValues;


import org.springframework.beans.factory.support.BeanDefinitionRegistry;


import org.springframework.beans.factory.support.GenericBeanDefinition;


import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;


import org.springframework.boot.bind.RelaxedDataBinder;


import org.springframework.boot.bind.RelaxedPropertyResolver;


import org.springframework.context.EnvironmentAware;


import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;


import org.springframework.core.convert.ConversionService;


import org.springframework.core.convert.support.DefaultConversionService;


import org.springframework.core.env.Environment;


import org.springframework.core.type.AnnotationMetadata;


/**

 * 动态数据源注册<br/>


 * 启动动态数据源请在启动类中（如SpringBootSampleApplication）


 * 添加 @Import(DynamicDataSourceRegister.class)


 *

 * @author 单红宇(365384722)


 * @myblog http://blog.csdn.net/catoop/


 * @create 2016年1月24日


 */

public class DynamicDataSourceRegister


        implements ImportBeanDefinitionRegistrar, EnvironmentAware {




    private static final Logger logger = LoggerFactory.getLogger(DynamicDataSourceRegister.class);


    private ConversionService conversionService = new DefaultConversionService(); 


    private PropertyValues dataSourcePropertyValues;


    // 如配置文件中未指定数据源类型，使用该默认值


    private static final Object DATASOURCE_TYPE_DEFAULT = "org.apache.tomcat.jdbc.pool.DataSource";

    // private static final Object DATASOURCE_TYPE_DEFAULT =


    // "com.zaxxer.hikari.HikariDataSource";


    // 数据源


    private DataSource defaultDataSource;


    private Map<String, DataSource> customDataSources = new HashMap<>();


    @Override


    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {


        Map<Object, Object> targetDataSources = new HashMap<Object, Object>();

        // 将主数据源添加到更多数据源中


        targetDataSources.put("dataSource", defaultDataSource);


        DynamicDataSourceContextHolder.dataSourceIds.add("dataSource");


        // 添加更多数据源


        targetDataSources.putAll(customDataSources);


        for (String key : customDataSources.keySet()) {


            DynamicDataSourceContextHolder.dataSourceIds.add(key);


        }

        // 创建DynamicDataSource


        GenericBeanDefinition beanDefinition = new GenericBeanDefinition();


        beanDefinition.setBeanClass(DynamicDataSource.class);


        beanDefinition.setSynthetic(true);


        MutablePropertyValues mpv = beanDefinition.getPropertyValues();


        mpv.addPropertyValue("defaultTargetDataSource", defaultDataSource);


        mpv.addPropertyValue("targetDataSources", targetDataSources);


        registry.registerBeanDefinition("dataSource", beanDefinition);


        logger.info("Dynamic DataSource Registry");


    }

    /**

     * 创建DataSource


     *

     * @param type


     * @param driverClassName


     * @param url


     * @param username


     * @param password


     * @return


     * @author SHANHY


     * @create 2016年1月24日


     */

    @SuppressWarnings("unchecked")


    public DataSource buildDataSource(Map<String, Object> dsMap) {


        try {


            Object type = dsMap.get("type");


            if (type == null)


                type = DATASOURCE_TYPE_DEFAULT;// 默认DataSource


            Class<? extends DataSource> dataSourceType;


            dataSourceType = (Class<? extends DataSource>) Class.forName((String) type);


            String driverClassName = dsMap.get("driver-class-name").toString();


            String url = dsMap.get("url").toString();


            String username = dsMap.get("username").toString();


            String password = dsMap.get("password").toString();


            DataSourceBuilder factory = DataSourceBuilder.create().driverClassName(driverClassName).url(url)


                    .username(username).password(password).type(dataSourceType);


            return factory.build();


        } catch (ClassNotFoundException e) {


            e.printStackTrace();


        }


        return null;


    }

    /**


     * 加载多数据源配置

     */

    @Override

    public void setEnvironment(Environment env) {


        initDefaultDataSource(env);


        initCustomDataSources(env);


    }

    /**

     * 初始化主数据源

     *

     * @author SHANHY

     * @create 2016年1月24日

     */

    private void initDefaultDataSource(Environment env) {


        // 读取主数据源


        RelaxedPropertyResolver propertyResolver = new RelaxedPropertyResolver(env, "spring.datasource.");


        Map<String, Object> dsMap = new HashMap<>();


        dsMap.put("type", propertyResolver.getProperty("type"));


        dsMap.put("driver-class-name", propertyResolver.getProperty("driver-class-name"));


        dsMap.put("url", propertyResolver.getProperty("url"));


        dsMap.put("username", propertyResolver.getProperty("username"));


        dsMap.put("password", propertyResolver.getProperty("password"));


        defaultDataSource = buildDataSource(dsMap);


        dataBinder(defaultDataSource, env);


    }

    /**

     * 为DataSource绑定更多数据


     *

     * @param dataSource


     * @param env


     * @author SHANHY


     * @create  2016年1月25日


     */


    private void dataBinder(DataSource dataSource, Environment env){


        RelaxedDataBinder dataBinder = new RelaxedDataBinder(dataSource);


        //dataBinder.setValidator(new LocalValidatorFactory().run(this.applicationContext));


        dataBinder.setConversionService(conversionService);


        dataBinder.setIgnoreNestedProperties(false);//false


        dataBinder.setIgnoreInvalidFields(false);//false


        dataBinder.setIgnoreUnknownFields(true);//true


        if(dataSourcePropertyValues == null){


            Map<String, Object> rpr = new RelaxedPropertyResolver(env, "spring.datasource").getSubProperties(".");


            Map<String, Object> values = new HashMap<>(rpr);


            // 排除已经设置的属性


            values.remove("type");


            values.remove("driver-class-name");


            values.remove("url");


            values.remove("username");


            values.remove("password");


            dataSourcePropertyValues = new MutablePropertyValues(values);


        }


        dataBinder.bind(dataSourcePropertyValues);


    }

    /**

     * 初始化更多数据源

     *

     * @author SHANHY

     * @create 2016年1月24日

     */

    private void initCustomDataSources(Environment env) {


        // 读取配置文件获取更多数据源，也可以通过defaultDataSource读取数据库获取更多数据源


        RelaxedPropertyResolver propertyResolver = new RelaxedPropertyResolver(env, "custom.datasource.");


        String dsPrefixs = propertyResolver.getProperty("names");


        for (String dsPrefix : dsPrefixs.split(",")) {// 多个数据源


            Map<String, Object> dsMap = propertyResolver.getSubProperties(dsPrefix + ".");


            DataSource ds = buildDataSource(dsMap);


            customDataSources.put(dsPrefix, ds);


            dataBinder(ds, env);


        }


    }


}


package org.springboot.sample.datasource;

import java.lang.annotation.Documented;

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

/**

 * 在方法上使用，用于指定使用哪个数据源

 *

 * @author   单红宇(365384722)


 * @myblog  http://blog.csdn.net/catoop/


 * @create    2016年1月23日

 */

@Target({ ElementType.METHOD, ElementType.TYPE })


@Retention(RetentionPolicy.RUNTIME)


@Documented


public @interface TargetDataSource {


    String name();


}

本文代码博主是经过测试后没有问题才发出来共享给大家的。对于连接池参数配置会应用到所有数据源上。
比如配置一个：

spring.datasource.maximum-pool-size=80

那么我们所有的数据源都会自动应用上。

<!-- 登录查看 begin -->

    <!-- 登录查看 end -->

Spring Boot 动态数据源（Spring 注解数据源）的更多相关文章

  1. 43. Spring Boot动态数据源（多数据源自动切换）【从零开始学Spring Boot】

    [视频&交流平台] àSpringBoot视频 http://study.163.com/course/introduction.htm?courseId=1004329008&utm ...

  2. Spring Boot HikariCP 一 ——集成多数据源

    其实这里介绍的东西主要是参考的另外一篇文章,数据库读写分离的. 参考文章就把链接贴出来,里面有那位的代码,简单明了https://gitee.com/comven/dynamic-datasource ...

  3. spring boot + druid + mybatis + atomikos 多数据源配置 并支持分布式事务

    文章目录 一.综述 1.1 项目说明 1.2 项目结构 二.配置多数据源并支持分布式事务 2.1 导入基本依赖 2.2 在yml中配置多数据源信息 2.3 进行多数据源的配置 三.整合结果测试 3.1 ...

  4. Spring boot配置多个Redis数据源操作实例

    原文:https://www.jianshu.com/p/c79b65b253fa Spring boot配置多个Redis数据源操作实例 在SpringBoot是项目中整合了两个Redis的操作实例 ...

  5. Spring Boot 2.x Redis多数据源配置(jedis,lettuce)

    Spring Boot 2.x Redis多数据源配置(jedis,lettuce) 96 不敢预言的预言家 0.1 2018.11.13 14:22* 字数 65 阅读 727评论 0喜欢 2 多数 ...

  6. 14、Spring Boot 2.x 集成 Druid 数据源

    14.Spring Boot 2.x 集成 Druid 数据源 完整源码: Spring-Boot-Demos

  7. Spring Boot的27个注解【核心】

    导读[约定大于配置] Spring Boot方式的项目开发已经逐步成为Java应用开发领域的主流框架,它不仅可以方便地创建生产级的Spring应用程序,还能轻松地通过一些注解配置与目前比较火热的微服务 ...

  8. Spring Boot 实战 —— MyBatis（注解版）使用方法

    原文链接: Spring Boot 实战 -- MyBatis(注解版)使用方法 简介 MyBatis 官网 是这么介绍它自己的: MyBatis 是一款优秀的持久层框架,它支持定制化 SQL.存储过 ...

  9. Spring Boot动态注入删除bean

    Spring Boot动态注入删除bean 概述 因为如果采用配置文件或者注解,我们要加入对象的话,还要重启服务,如果我们想要避免这一情况就得采用动态处理bean,包括:动态注入,动态删除. 动态注入 ...

  10. Spring Boot整合MyBatis(非注解版)

    Spring Boot整合MyBatis(非注解版),开发时采用的时IDEA,JDK1.8 直接上图: 文件夹不存在,创建一个新的路径文件夹 创建完成目录结构如下: 本人第一步习惯先把需要的包结构创建 ...

随机推荐

  1. 正确地在QML应用中使用fontsize

    我们知道我们有时须要显示text文本.可是,在QML应用中.我们应该怎样选择font的大小呢?在今天的这篇文章中,我们将展示在Ubuntu平台中的不同文字的大小.我们能够通过FontUtils来帮我们 ...

  2. HttpWebRequest使用证书请求

    HttpWebRequest使用证书请求 //是否使用证书                if (isUseCert)                {                    stri ...

  3. CString与 char *之间的转换

    http://www.cnblogs.com/watsonlong/archive/2011/04/15/2017086.html

  4. BZOJ4652: [Noi2016]循环之美(莫比乌斯反演，杜教筛)

    Description 牛牛是一个热爱算法设计的高中生.在他设计的算法中,常常会使用带小数的数进行计算.牛牛认为,如果在 k  进制下,一个数的小数部分是纯循环的,那么它就是美的.现在,牛牛想知道:对 ...

  5. mapper.xml中的常用标签

    mybatis的mapper xml文件中的常用标签 https://blog.csdn.net/qq_41426442/article/details/79663467 SQL语句标签 1.查询语句 ...

  6. Python线程池任务

    #!/usr/bin/env python # -*- coding:utf-8 -*- from concurrent.futures import ThreadPoolExecutor #线程池, ...

  7. nginx配置静态文件服务器的一个特殊需求的探索和分享, nginx处理不同路径返回统一文件,nginx改写,跳转请求.

    最近在做一个前后端分离的个人博客,在做自己博客的时候有个想法,本来是打算用nginx作为静态文件服务器使用,django做后端程序. 我的前端页面用vue写的,结果用组件用嗨了,发现页面列表和 详情都 ...

  8. Java反射之getInterfaces()方法

    今天学习Spring3框架,在理解模拟实现Spring Ioc容器的时候遇到了getInterfaces()方法.getInterfaces()方法和Java的反射机制有关.它能够获得这个对象所实现的 ...

  9. using the easy connect naming method 简单连接測试

    一直都不明确sqlnet.ora中的NAMES.DIRECTORY_PATH= (TNSNAMES, EZCONNECT)是什么意思.今天看到一篇文档,就是登陆选用的方式.做一个測试: tnsname ...

  10. Python笔记---错误笔记

    Python---错误笔记 1. Python编码问题: 我们在编写 Python 脚本时,往往会写上中文凝视. 可是有时候,当我们执行程序时.却发现例如以下错误:SyntaxError: Non-A ...