原帖地址：http://blog.csdn.net/sinat_29774479/article/details/75642932
本人应用场景：原来项目数据库用的mysql，后台框架用的是spring3.x+hibernate3.x(版本比较老) ,现在该项目的配套产品数据库用的是sqlserver.本以为hibernate是万能，起码能兼容主流数据库吧。实践的时候，配好数据库链接，切换驱动包，项目启动到时没有问题，但是执行HQL查询的时候报错了，还有sqlserver 的表字段时间类型用的datetime ,代码实体用java.util.date ，并注解@Temporal
 ，死活还是报错。奔溃，泪
后面一想，不对啊，怎么能改数据库呢，万一在扩展一个异库套产品呢。于是疯狂的搜一个项目配置两个数据源的资料，最简单粗暴的就是关于数据源的，sessionfactory,transationManger的都多配置一份。经过一番配置之后，以为大功告成，项目一启动，各种报错，大概是说默认的sessionfactory是单例的，不同同时存在两个sessionfactory,又经过一番调节之后，发现可以配多个数据源，但是不能配多个sessionfactory.心想，妈的，人家怎么行呢？同样的是spring，又疯狂搜资料，还是没有答案。
最后将sping和hibernate提升至4+，偶然发现，项目启动没有报错，经测试增删查改也没有错！！！
 
注意使用hibernate这个用resource指定id注入
@Resource(name="hibernateTemplate")

protected HibernateTemplate hibernateTemplate;

@Resource(name="sqlServer_hibernateTemplate")

protected HibernateTemplate hibernateTemplate;

Java动态数据源配置、动态连接池配置、多数据源负载均衡

大家好，今天给大家推荐一个自产的连接池插件。废话不多说，本文接口分为以下主题：

1. 插件开发背景；

2. 插件提供的能力；

3. 插件的使用介绍；

4. 插件的使用实例；

5. 插件的源码。

 

PS: 该插件已经提交到中央仓库，可以在maven配置中直接引用。截止当前时间，最新版本v1.1.0。获取该项目最新消息及源码，

请移步： 源码地址

<dependency>
    <groupId>com.xieahui.springboot</groupId>
    <artifactId>spring-boot-easy-connection-pool</artifactId>
    <version>1.1.0-RELEASE</version>
</dependency>

 

1. 插件的开发背景？

由于公司筹建数据中台服务，数据中台服务其中有个环节需要整合数据以及对外提供数据。数据中台项目中有两个特别明确的服务，一个是进数据的服务、一个是出数据的服务。这种服务通常都有一个特点，需要对外提供各种各样的数据，由于不同类型的数据存放在不同的数据源中，所以会导致该服务需要对接多种多样的数据源。如果想要设计一套以不变应万变的数据服务，那么动态管理数据源就变得尤其重要了。常规MySql数据负载的解决方案较多,但是向我们的Clickhouse、Impala等数据库可以通用的支持动态构建数据库连接池的组件就不是特别多了。基于这个场景，我决定自研这套支持JDBC驱动、可以动态从配置文件中读取、动态从数据库中读取、可以根据业务标识手动设置的、独立的、分组的动态数据源构建连接池插件。

 

2. 插件提供的能力？

支持动态从properties中获取数据配置；
	
支持动态从db中获取数据库配置；
	
可根据配置动态构建连接池；
	
可以从配置文件或db中动态构建分组连接池；
	
分组连接池支持负载均衡策略;
	
随机负载均衡；
		
轮询负载均衡；
	
	
支持根据实际业务动态扩展。
 

3. 插件的使用介绍？

插件简介

基于上述项目背景，统一封装了多数据源连接池动态化配置插件，连接池使用的是业界号称"最快的"Hikari（SpringBoot2默认的连接池）；只需在项目中引入插件，在属性文件中添加必要的数据源连接配置信息及连接池参数，就可以通过注解进而动态切换数据源；无论是读写分离、主从配置还是一主多从的数据源均可通过此动态配置生成DataSource连接池。 项目中各部分注释比较详细，对于二次开发扩展也非常方便，同时在启动过程会打印出详细的连接池配置流程以及连接池中的表信息：

 

插件功能特点

1. 动态支持多数据源连接池配置
2. 理论上支持无限多个数据源连接池
3. 通过注解切换数据源
4. 对于数据库读写分离、一主多从等业务场景非常适用
5. 代码逻辑简单，扩展来自原生Spring接口；注释详细，易于二次开发


使用实例

和该项目配置的实例项目 可以点击查看

V1.1.0 - 更新说明

主要增加如下：
 1. 更新数据库脚本；
 2. 更新注解TargetDataSource；
 3. 更新逻辑指定配置DynamicDbSource； 
 4. 增加数据源连接分组；
 5. 增加负载均衡策略：
    A. 随机负载均衡策略；
    B. 轮询负载均衡策略；

新增功能演示实例

该版本对应的演示实例:

easy-connection-pool-demo -> easy-jdbctemplate -> com.xieahui.easy.jdbctemplate.controller.GroupDSController

链接为： GroupDSController.java

更新数据库脚本

新增分组名称字段group_name、负载均衡类型字段balance_type、增加连接池名称pool_name非空唯一限制。 脚本路径：

resources->script->db_entity.sql

更新注解TargetDataSource

更新注解TargetDataSource适配分组、负载逻辑； 新增注解配置分组groupName、注解配置连接池名称poolName、注解配置负载均衡策略balanceType

更新逻辑指定配置DynamicDbSource

更新逻辑指定配置DynamicDbSource适配分组、负载逻辑； 新增指定(分组名称)方法setGroupName、指定(分组,具体数据源名称)方法setGroupNamePoolName、指定(分组,数据源名称,负载策略)方法setGroupNamePoolNameBalanceType

增加数据源连接分组

数据源加载优先级：

db -> properties

数据源使用优先级：

properties -> properties-group -> db -> db-group

增加负载均衡策略

分组后会涉及到分组数据源的选取策略，1.1.0版本实现了随机、轮询两种较常见的负载均衡策略。默认使用轮询策略。

V1.0.1 - 更新说明

新增从默认数据库中获取数据源连接信息，使用说明。

1. 开启从数据库中加载数据源属性设置：

spring.datasource.db.open=true

2. 创建数据库数据源表

最新脚本路径：

resources->script->db_entity.sql

CREATE TABLE `db_entity` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `driver_class_name` varchar(45) DEFAULT 'com.mysql.cj.jdbc.Driver' COMMENT '驱动类',
  `jdbc_url` varchar(45) DEFAULT NULL COMMENT '数据库连接地址<jdbc:mysql://ip:port/db>,必填！',
  `pool_name` varchar(45) NOT NULL COMMENT '连接池名称,必填！',
  `username` varchar(45) DEFAULT NULL COMMENT '用户名',
  `password` varchar(45) DEFAULT NULL COMMENT '密码',
  `minimum_idle` int(11) DEFAULT '5' COMMENT '最小空闲连接数',
  `maximum_pool_size` int(11) DEFAULT '10' COMMENT '最大连接数',
  `connection_test_query` varchar(45) DEFAULT 'SELECT 1' COMMENT '测试连接是否有效SQL',
  `group_name` varchar(45) DEFAULT NULL COMMENT '分组名',
  `balance_type` varchar(45) DEFAULT NULL COMMENT '负载均衡类型',
  PRIMARY KEY (`id`),
  UNIQUE KEY `pool_name_UNIQUE` (`pool_name`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;



该表结构在resources/script/db_entity.sql文件中

3. 添加动态数据源注解

设置在执行的方法上：

@TargetDataSource

4. 动态指定数据源

// DynamicDbSource.set("db3");

@TargetDataSource
public List<MyDb3> findAll() throws InterruptedException {
    //动态数据源设置
    DynamicDbSource.set("db3");
    TimeUnit.SECONDS.sleep(60);
    return myDb3Dao.findAll();
}

PS: DynamicDbSource.set("连接池名称"),可以根据自己的实际业务逻辑设置数据源名称。例如我们需要根据请求的pk获取当前连接对应的数据源配置， 获取到名字后在这里设置为数据源名字即可。

5. 实例地址

https://github.com/xieyucan/easy-connection-pool-demo/blob/master/easy-jdbctemplate/src/main/java/com/xieahui/easy/jdbctemplate/service/MyDb3Service.java

启动信息

系统优先使用注解方法上的属性配置，注解方法上没有配置的情况下会读取DynamicDbSource设置的数据源配置。系统启动时会日志中会打印出当前创建连接 池的情况，以及连接池中的数据表。

com.zaxxer.hikari.HikariDataSource       : HikariCP1 - Starting...
com.zaxxer.hikari.HikariDataSource       : HikariCP1 - Start completed.
c.x.s.config.DynamicDataSourceRegister   : *** Create DataSource Default Success! ***
c.x.s.config.DynamicDataSourceRegister   : ***Print-Tables-Start***:
c.x.s.config.DynamicDataSourceRegister   : db
c.x.s.config.DynamicDataSourceRegister   : db_entity
c.x.s.config.DynamicDataSourceRegister   : hibernate_sequence
c.x.s.config.DynamicDataSourceRegister   : student
c.x.s.config.DynamicDataSourceRegister   : ***Print-Tables-End***.

com.zaxxer.hikari.HikariDataSource       : db3 - Starting...
com.zaxxer.hikari.HikariDataSource       : db3 - Start completed.
c.x.s.config.DynamicDataSourceRegister   : *** Create DataSource db3 Success! ***
c.x.s.config.DynamicDataSourceRegister   : ***Print-Tables-Start***:
c.x.s.config.DynamicDataSourceRegister   : my_db3
c.x.s.config.DynamicDataSourceRegister   : ***Print-Tables-End***.

com.zaxxer.hikari.HikariConfig           : HikariCP2 - idleTimeout has been set but has no effect because the pool is operating as a fixed size pool.
com.zaxxer.hikari.HikariDataSource       : HikariCP2 - Starting...
com.zaxxer.hikari.HikariDataSource       : HikariCP2 - Start completed.
c.x.s.config.DynamicDataSourceRegister   : *** Create DataSource db1 Success! ***
c.x.s.config.DynamicDataSourceRegister   : ***Print-Tables-Start***:
c.x.s.config.DynamicDataSourceRegister   : hibernate_sequence
c.x.s.config.DynamicDataSourceRegister   : student
c.x.s.config.DynamicDataSourceRegister   : teacher
c.x.s.config.DynamicDataSourceRegister   : user
c.x.s.config.DynamicDataSourceRegister   : ***Print-Tables-End***.

c.x.s.config.DynamicDataSourceRegister   : Dynamic DataSource Registry

在MyBatis中的用法

演示项目 easy-mybatis

演示用例 easy-mybatis-MyBatisApplicationTest

在JPA中的用法

演示项目 easy-jpa

演示用例 easy-jpa-JpaApplicationTest

在JdbcTemplate中的用法

演示项目 easy-jdbctemplate

演示用例 easy-jpa-JdbcTemplateApplicationTest

使用说明

插件是基于SpringBoot开发maven管理的，使用步骤如下：

1.添加插件maven依赖

<dependency>
    <groupId>com.xieahui.springboot</groupId>
    <artifactId>spring-boot-easy-connection-pool</artifactId>
    <version>1.0.1-RELEASE</version>
</dependency>

2.在启动类上添加注解开启动态数据源

@EnableDynamicDataSource

3.必要的连接属性配置 说明：spring.datasource.names属性配置数据资源名（如果连接的数据源较少，请在此处移除掉）。默认数据源使用了JPA，使用的持久层技术有JdbcUtils,Hibernate,IBatis和MyBatis,JdbcTemplate,Jpa（现有项目最常用的持久层技术是JPA+JdbcTemplate；持久层技术方案众多，好坏只有自己去品）。能解决业务场景问题、开发效率高用的开心就好。

server.port=8080
#db,数据源名字
spring.datasource.names=db1,db2,db3
spring.datasource.type=com.zaxxer.hikari.util.DriverDataSource
#jpa
spring.jpa.database=mysql
spring.jpa.show-sql=true
spring.jpa.generate-ddl=true
spring.jpa.hibernate.ddl-auto=update
#mysql-1
#表示使用基于DriverManager的配置
spring.datasource.hikari.jdbcUrl=jdbc:mysql://localhost:3306/db
#数据库连接用户名
spring.datasource.hikari.username=root
#数据库连接密码
spring.datasource.hikari.password=root
#数据库连接驱动
spring.datasource.hikari.driverClassName=com.mysql.cj.jdbc.Driver
#池中维护的最小空闲连接数,如果空闲连接低于此值并且总连接数小于maximumPoolSize，则HC将快速有效的添加其他连接
spring.datasource.hikari.minimumIdle=10
#池中维护的最大连接数
spring.datasource.hikari.maximumPoolSize=15
#控制连接是否自动提交事务
spring.datasource.hikari.autoCommit=true
#空闲连接闲置时间
spring.datasource.hikari.idleTimeout=30000
#连接池名称
spring.datasource.hikari.poolName=HikariCP1
#连接最长生命周期,如果不等于0且小于30秒则会被重置回30秒
spring.datasource.hikari.maxLifetime=1800000
#从池中获取连接的最大等待时间默认30000毫秒，如果小于250毫秒则被重置会30秒
spring.datasource.hikari.connectionTimeout=30000
#测试连接有效性最大超时时间,默认5秒如果小于250毫秒，则重置回5秒
spring.datasource.hikari.validationTimeout=5000
#测试连接是否有效SQL，PS:不同数据库的测试SQL有可能不一样！
spring.datasource.hikari.connectionTestQuery=SELECT 1
#控制默认情况下从池中获取的Connections是否处于只读模式
spring.datasource.hikari.readOnly=false
#是否在其自己的事务中隔离内部池查询，例如连接活动测试。通常使用默认值，默认值：false
spring.datasource.hikari.isolateInternalQueries=false
#此属性控制是否注册JMX管理Bean
spring.datasource.hikari.registerMbeans=false
#此属性控制是否可以通过JMX（Java Management Extensions，即Java管理扩展，它提供了一种在运行时动态管理资源的体系结构）挂起和恢复池
spring.datasource.hikari.allowPoolSuspension=false
#mysql-2
spring.datasource.db1.hikari.jdbcUrl=jdbc:mysql://localhost:3306/db1
spring.datasource.db1.hikari.username=root
spring.datasource.db1.hikari.password=root
spring.datasource.db1.hikari.driverClassName=com.mysql.cj.jdbc.Driver
spring.datasource.db1.hikari.minimumIdle=10
spring.datasource.db1.hikari.maximumPoolSize=15
spring.datasource.db1.hikari.autoCommit=true
spring.datasource.db1.hikari.idleTimeout=30000
spring.datasource.db1.hikari.poolName=HikariCP2
spring.datasource.db1.hikari.maxLifetime=1800000
spring.datasource.db1.hikari.connectionTimeout=30000
spring.datasource.db1.hikari.validationTimeout=5000
spring.datasource.db1.hikari.connectionTestQuery=SELECT 1
spring.datasource.db1.hikari.readOnly=false
spring.datasource.db1.hikari.isolateInternalQueries=false
spring.datasource.db1.hikari.registerMbeans=false
spring.datasource.db1.hikari.allowPoolSuspension=false
#mysql-2
spring.datasource.db2.hikari.jdbcUrl=jdbc:mysql://localhost:3306/db2
spring.datasource.db2.hikari.username=root
spring.datasource.db2.hikari.password=root
spring.datasource.db2.hikari.driverClassName=com.mysql.cj.jdbc.Driver
spring.datasource.db2.hikari.minimumIdle=10
spring.datasource.db2.hikari.maximumPoolSize=15
spring.datasource.db2.hikari.autoCommit=true
spring.datasource.db2.hikari.idleTimeout=30000
spring.datasource.db2.hikari.poolName=HikariCP3
spring.datasource.db2.hikari.maxLifetime=1800000
spring.datasource.db2.hikari.connectionTimeout=30000
spring.datasource.db2.hikari.validationTimeout=5000
spring.datasource.db2.hikari.connectionTestQuery=SELECT 1
spring.datasource.db2.hikari.readOnly=false
spring.datasource.db2.hikari.isolateInternalQueries=false
spring.datasource.db2.hikari.registerMbeans=false
spring.datasource.db2.hikari.allowPoolSuspension=false
#clickHouse-1
spring.datasource.db3.hikari.jdbcUrl=jdbc:clickhouse://
spring.datasource.db3.hikari.username=root
spring.datasource.db3.hikari.password=root
spring.datasource.db3.hikari.driverClassName=ru.yandex.clickhouse.ClickHouseDriver
spring.datasource.db3.hikari.minimumIdle=5
spring.datasource.db3.hikari.maximumPoolSize=10
spring.datasource.db3.hikari.autoCommit=true
spring.datasource.db3.hikari.idleTimeout=30000
spring.datasource.db3.hikari.poolName=HikariCP4
spring.datasource.db3.hikari.maxLifetime=1800000
spring.datasource.db3.hikari.connectionTimeout=30000
spring.datasource.db3.hikari.validationTimeout=5000
spring.datasource.db3.hikari.connectionTestQuery=SELECT 1
spring.datasource.db3.hikari.readOnly=false
spring.datasource.db3.hikari.isolateInternalQueries=false
spring.datasource.db3.hikari.registerMbeans=false
spring.datasource.db3.hikari.allowPoolSuspension=false

4.代码中应用 由于数据源动态切换是使用Aspect+注解完成的，所以调用时需要将Bean交给Spring的IOC容器管理。只有这样Spring才能通过AOP加强，触发我们的切换逻辑。

Controller:
@Resource
private StudentService studentService;
	
@GetMapping("/fcn")
public List<String> findCHNames() {
	return studentService.findClickHouseColumnName();
}

Service:
@Resource
private JdbcTemplate jdbcTemplate;

@TargetDataSource("db3")
public List<String> findClickHouseColumnName() {
	String sql = "show tables";
	List<String> strings = jdbcTemplate.queryForList(sql, String.class);
return strings;
}

 

4. 插件的使用实例？

简介

EasyConnectionPoolDemo是SpringBoot动态配置多数据源连接池spring-boot-easy-connection-pool项目的实例。

EasyConnectionPoolDemo项目中分别演示了使用常见Jpa、JdbcTemplate、MyBatis作为持久层框架的项目案例。

按理说spring-boot-easy-connection-pool处理的是DataSource，对各种持久层框架而言是透明的，使用场景也是很类似，比较简单。但是为了更加具体详细的说明演示 ，就做了这个项目。此项目中分别使用了两个数据、两个表进行演示；理论上而言：如果项目中添加了支持JDBC协议驱动的数据源配置，则可实现数据源动态切换逻辑。 该连接池项目还有一个特点：在启动阶段会打印详细的连接信息以及连接表信息，如下图所示：

 

V1.0.1 - 更新说明

新增从默认数据库中获取数据源连接信息，使用说明。

1. 实例地址

https://github.com/xieyucan/easy-connection-pool-demo/blob/master/easy-jdbctemplate/src/main/java/com/xieahui/easy/jdbctemplate/service/MyDb3Service.java

准备

该项目演示使用的是MySql数据库，所以运行项目的前提是要有MySql数据库。新建数据库及表

easy_pool_demo - student
	
db1 - user
easy_pool_demo作为了默认数据库，建表语句在项目根目录的script中。

MyBatis框架中的用法

MyBatis是一款非常优秀的持久层框架，尤其是在互联网企业中使用的人群超级多。

演示项目 easy-mybatis

演示用例 easy-mybatis-MyBatisApplicationTest

JPA中的用法

JPA是SpringBoot默认集成的持久层框架，如果使用过Hibernate，那么对JPA则很快上手。使用JPA开发CRUD，可以说是非常的迅速、顺手。 在管理项目中做功能开发没有比JPA开发效率更高的了，如果你觉得使用起来不是很方便，那一定是没有找到正确的用法。这个项目中只是为了演示spring-boot-easy-connection-pool项目 如何支持JPA的开发，并没有对JPA技术进行详细介绍。

演示项目 easy-jpa

演示用例 easy-jpa-JpaApplicationTest

JdbcTemplate中的用法

JdbcTemplate很早之前就在SpringJdbc中出现了。由于它只对原生数据连接操作使用模板模式进行简单包装（如果没有任何封装，那么使用起来是非常蹩脚的），所以更接近原生操作；这也注定了它比其他几个框架更加灵活且学习成本更低。我们则更容易根据自己的业务场景、使用习惯封装出独特的持久层方案。

演示项目 easy-jdbctemplate

演示用例 easy-jpa-JdbcTemplateApplicationTest

以上，如有问题可以邮件联系我。祝好！

插件实例源码地址

5. 插件的源码？

插件源码在github上，代码量很少并且有详细的注释。如果对您有所帮助，辛苦您帮我点个start。感谢！

源码地址

今天是2017年3月28日，天气晴，空闲了好几天，今天终于接受到一个任务，笼统的说是一个数据抽取吧，其中涉及到一个知识点，就是要配置多个数据源，身为一名刚毕业不到一年的菜鸟，立马去请教了组长这该如何做，组长很给力，直接给了我一个样例，让我跟着做，其中缘由是如何的呢，还需我自己查阅资料慢慢消化，在此，我也先记录一下Java配置多数据源的用法，一共需要配置四个地方，很简单。

注：这个知识点必须在对Java框架有一定了解的基础下学习才行。

第一步，是最重要的配置文件，在此我给它取名为spring-lt.xml，它是一个独立的配置文件，就是你需要配置数据源的适配器，代码如下：



<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:cache="http://www.springframework.org/schema/cache"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/cache
        http://www.springframework.org/schema/cache/spring-cache-3.2.xsd ">

        <description>这里设置大表远传的适配器。</description>

        <bean id="sqlSessionFactoryLT" class="org.mybatis.spring.SqlSessionFactoryBean">
            <property name="dataSource" ref="ltDataSource"></property>  <!-- ltDataSource 对应的是spring-core.xml中bean的id -->
            <property name="configLocation" value="classpath:mybatis-config.xml"></property>
            <property name="mapperLocations" value="classpath:com/wx/app/ygp/dao/externalConnection/*.xml">  </property>  <!-- 此路径就是*mapper.xml文件对应的路径 -->
        </bean>

        <bean id="myLtPlugs" class="org.mybatis.spring.mapper.MapperFactoryBean">
            <property name="mapperInterface" value="com.wx.app.ygp.dao.externalConnection.LtPlugs" />  <!-- 此路径就是dao接口的路径 -->
            <property name="sqlSessionFactory" ref="sqlSessionFactoryLT" />
        </bean>

</beans>

第二步，是在spring-core.xml中增加对这个数据源的配置，主要的作用是获取db.properties中的数据源的值，代码如下：



    <!-- 加载配置属性文件 -->
    <context:property-placeholder
            ignore-unresolvable="true" location="classpath*:db.properties"/>

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          destroy-method="close">
        <property name="url" value="${base.url}"/>
        <property name="username" value="${base.username}"/>
        <property name="password" value="${base.password}"/>
        <property name="driverClassName" value="${base.driver}"/>
    </bean>      <!-- 数据库1 -->

    <bean id="htDataSource" class="com.alibaba.druid.pool.DruidDataSource"
          destroy-method="close">
        <property name="url" value="${ht.url}"/>
        <property name="username" value="${ht.username}"/>
        <property name="password" value="${ht.password}"/>
        <property name="driverClassName" value="${ht.driver}"/>
    </bean>   <!-- 数据库2 -->

    <bean id="ltDataSource" class="com.alibaba.druid.pool.DruidDataSource"
          destroy-method="close">
        <property name="url" value="${lt.url}"/>
        <property name="username" value="${lt.username}"/>
        <property name="password" value="${lt.password}"/>
        <property name="driverClassName" value="${lt.driver}"/>
    </bean>  <!-- 数据库3 -->

    <bean id="multipleDataSource" class="com.wx.app.ygp.comm.MultipleDataSource">
        <property name="defaultTargetDataSource" ref="dataSource"/>
        <property name="targetDataSources">
            <map>
                <entry key="ygp" value-ref="dataSource"/>
                <entry key="ht" value-ref="htDataSource"/>
                <entry key="lt" value-ref="ltDataSource"/>
            </map>
        </property>
    </bean>

第三步，是在web.xml文件中增加spring-lt.xml的引入，代码如下：



    <!-- Spring和mybatis的配置文件 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            classpath:spring-core.xml;
            classpath:spring-mybatis.xml;
            classpath:spring-ht.xml;
            classpath:spring-lt.xml;
            classpath:spring-task.xml
        </param-value>
    </context-param>

最后一步，就是在db.properties文件中配置你的数据源，像账号，密码，啥的。。



lt.driver=com.mysql.jdbc.Driver
lt.url=jdbc:mysql://127.0.0.1:3306/ygp?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true
lt.username=root
lt.password=admin

完毕，这样就可以在项目中使用多个数据库啦~

参考：

https://my.oschina.net/simpleton/blog/916108
http://wenqy.com/2017/12/24/spring-boot%E5%AD%A6%E4%B9%A0%E7%B3%BB%E5%88%97%E4%B9%8Batomikos%E5%A4%9A%E6%95%B0%E6%8D%AE%E6%BA%90%E5%92%8C%E5%88%86%E5%B8%83%E5%BC%8F%E4%BA%8B%E5%8A%A15.html


需求描述
近期被分配了一个需求：

在项目里同时连接多个数据源
用户可以输入数据库连接信息动态建立连接

JDBC 与 DATASOURCE
在配置动态数据源前，必须先回顾一下jdbc与datasource，这对后面的功能实现有很大帮助
以下是jdbc伪代码
//注册driver
Class.forName("com.mysql.jdbc.Driver");
//建立数据库对象
Connection conn  = DriverManager.getConnection(url_encrypt,user,password);
//建立操作对象
Statement stmt= conn.createStatement();
//结果集
ResultSet rs = stmt.executeQuery("select * from information");
//依次关闭结果集，操作对象，数据库对象
if(rs!=null){
    rs.close();
}
if(stmt!=null){
    stmt.close();
}
if(conn!=null){
    conn.close();
}

可以看出，使用jdbc的步骤简单归纳如下：

加载数据库驱动driver
建立数据库连接connection
创建statement
通过statement执行sql，获得结果集ResultSet
依次关闭ResultSet，statement，connection

但是，每次通过jdbc建立连接不但繁琐，而且频繁建立和释放连接对系统资源消耗也很大，因此发展出了datasource

datasource是个接口，它只有两个方法
//无参数获取Connection
Connection getConnection() throws SQLException;
//通过username和password获取Connection
Connection getConnection(String username, String password) throws SQLException;

可以看出，这两个方法都可以获得connection，因此connection的创建与回收都由datasource管理而不用用户操心，而且通过数据库连接池也避免了connection的频繁创建与销毁，提升了系统性能
那么想要实现动态数据源，思路有两种：

同时创建多个datasource，不同的接口(或方法)采用不同的datasource
采用动态数据源，根据需要动态提供不同的connection

mybatis
现在我们已经有了初步思路，下一步就是如何把这个思路应用于mybatis上，这样就需要了解下mybatis与datasource间的关系
我们知道，使用mybatis时，我们做了以下工作：

写mapper接口
写.xml文件
通过@MapperScan指定mapper接口的扫描路径
配置mapper-locations指定.xml文件路径

这中间，mybatis做了很多工作，但这不是我们这篇文章的重点，但我们只需要了解以下内容：

mybatis会根据mapper接口与.xml文件生成mapper接口的实现类
这个mapper实现类会使用SqlSessionTemplate去执行SQL命令
如果某mapper想使用某特定数据库，就让它使用某特定的SqlSessionTemplate
SqlSessionTemplate可通过SqlSessionFactory去创建
SqlSessionFactory通过SqlSessionFactoryBean创建
SqlSessionFactoryBean可以通过setDataSource设置datasource，通过setMapperLocations设置.xml文件地址

梳理一下：

创建一个SqlSessionFactoryBean，设置datasource与xml文件路径
通过SqlSessionFactoryBean创建SqlSessionFactory
通过SqlSessionFactory创建SqlSessionTemplate
把这个SqlSessionTemplate“关联”到mapper接口

ps：以上总结是基于spring+mybatis，如果没有spring,链路如下：

datasource >> Environment >> Configuration >> SqlSessionFactoryBuilder >> SqlSessionFactory >> SqlSession
多数据源配置
现在我们先实现同时配置多个数据源吧
配置文件
spring:
  datasource:
    default:
      url: jdbc:postgresql://localhost:5432/default
      username: user
      password: pass
      driver-class-name: org.postgresql.Driver
      type: com.alibaba.druid.pool.DruidDataSource
    demo:
      url: jdbc:postgresql://localhost:5432/demo
      username: user
      password: pass
      driver-class-name: org.postgresql.Driver
    druid:
      url: jdbc:postgresql://localhost:5432/default
      username: user
      password: pass
      driver-class-name: org.postgresql.Driver
      type: com.alibaba.druid.pool.DruidDataSource
      # 下面为连接池的补充设置，应用到上面所有数据源中
      # 初始化大小，最小，最大
      initial-size: 5
      min-idle: 5
      max-active: 20
      # 配置获取连接等待超时的时间
      max-wait: 60000
      # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
      time-between-eviction-runs-millis: 60000
      # 配置一个连接在池中最小生存的时间，单位是毫秒
      min-evictable-idle-time-millis: 300000
      validation-query: SELECT 1
      test-while-idle: true
      test-on-borrow: false
      test-on-return: false
      # 打开PSCache，并且指定每个连接上PSCache的大小
      pool-prepared-statements: true
      #   配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
      max-pool-prepared-statement-per-connection-size: 20
      use-global-data-source-stat: true
      # 通过connectProperties属性来打开mergeSql功能；慢SQL记录
      filter:
        config:
          enabled: true
        stat:
          enabled: true
        wall:
          enabled: false
      connect-properties:
        druid.stat.mergeSql: true
        druid.stat.slowSqlMillis: 5000
      # 配置监控服务器
      stat-view-servlet:
        login-username: admin
        login-password: admin
        reset-enable: false
        url-pattern: /druid/*
        # 添加IP白名单
        #allow:
        # 添加IP黑名单，当白名单和黑名单重复时，黑名单优先级更高
        #deny:
        enabled: true
      web-stat-filter:
        # 添加过滤规则
        url-pattern: /*
        # 忽略过滤格式
        exclusions: "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*"
        enabled: true
      default-auto-commit: false
      connection-error-retry-attempts: 2
      break-after-acquire-failure: true

数据源
DefaultDataSourceConfig
@Configuration
@MapperScan(value = {"com.hy.mapper.default"},sqlSessionTemplateRef="sqlSessionTemplate")
public class DefaultDataSourceConfig {
    private Logger logger = LoggerFactory.getLogger(this.getClass().getName());

	//获取通用的DruidDataSource
	//注意：
	//	1.由于springbean默认是单例，而这个bean是其他datasource的“模版”，必须每次调用都生成新的对象，因此添加@Scope("prototype")注解
	//	2.通过@ConfigurationProperties(prefix = "spring.datasource.druid")读取配置文件spring.datasource.druid下的所有属性到DruidDataSource里
    @Bean(name="getDruidDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.druid")
    @Scope("prototype")
    public DruidDataSource getDruidDataSource(){
        DataSourceBuilder<DruidDataSource> dataSourceBuilder = DataSourceBuilder.create().type(DruidDataSource.class);
        DruidDataSource dataSource = dataSourceBuilder.build();
        //不能自动提交
        dataSource.setDefaultAutoCommit(false);
        return dataSource;
    }

	//默认的数据源
	//在通用数据源的基础上，读取spring.datasource.default下的配置
    @Bean(name="defaultDruidDataSource",initMethod = "init",destroyMethod = "close")
    @ConfigurationProperties(prefix = "spring.datasource.default")
    public DruidDataSource defaultDruidDataSource(){
        return getDruidDataSource();
    }

    @Bean(name = "sqlSessionFactoryBean")
    public SqlSessionFactoryBean sqlSessionFactoryBean(@Qualifier("defaultDruidDataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(dataSource);
        PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        // 扫描映射文件
        sessionFactory.setMapperLocations(resolver.getResources("classpath*:mapper/default/*.xml"));
        return sessionFactory;
    }

    @Bean(name = "sqlSessionTemplate")
    public SqlSessionTemplate sqlSessionTemplate(
        @Qualifier("sqlSessionFactoryBean") SqlSessionFactoryBean sqlSessionFactory) throws Exception {
        return new SqlSessionTemplate(sqlSessionFactory.getObject());
    }


    @Bean(name="transactionManager")
    public PlatformTransactionManager transactionManager(@Qualifier("dataSource") DataSource dataSource) {
        // 配置事务管理, 使用事务时在方法头部添加@Transactional注解即可
        return new DataSourceTransactionManager(dataSource);
    }
}


DemoDataSourceConfig
@Configuration
@MapperScan(value = {"com.hy.mapper.demo"},sqlSessionTemplateRef="sqlSessionTemplateForDemo")
public class DemoDataSourceConfig {

	//DEMO数据源
	//在通用数据源的基础上，读取spring.datasource.demo下的配置
    @Bean(name="demoDruidDataSource",initMethod = "init",destroyMethod = "close")
    @ConfigurationProperties(prefix = "spring.datasource.demo")
    public DruidDataSource demoDruidDataSource(@Qualifier("getDruidDataSource") DruidDataSource dataSource){
        return dataSource;
    }

    @Bean(name = "sqlSessionFactoryBeanForDemo")
    public SqlSessionFactoryBean sqlSessionFactoryBeanForDemo(@Qualifier("demoDruidDataSource") DataSource demoDataSource) throws Exception {
        SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(demoDataSource);
        PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        // 扫描映射文件
        sessionFactory.setMapperLocations(resolver.getResources("classpath*:mapper/demo/*.xml"));
        return sessionFactory;
    }

    @Bean(name = "sqlSessionTemplateForDemo")
    public SqlSessionTemplate sqlSessionTemplateForDemo(
        @Qualifier("sqlSessionFactoryBeanForDemo") SqlSessionFactoryBean sqlSessionFactory) throws Exception {
        return new SqlSessionTemplate(sqlSessionFactory.getObject());
    }


    @Bean(name="transactionManagerForDemo")
    public PlatformTransactionManager transactionManagerForDemo(@Qualifier("demoDruidDataSource") DataSource demoDataSource) {
        // 配置事务管理, 使用事务时在方法头部添加@Transactional注解即可
        return new DataSourceTransactionManager(demoDataSource);
    }
}


以上代码，就已经把mapper接口与特定数据源关联上了，可以随便写个service去验证
//student与teacher分别处于demo库与default库
@AutoWired
private StudentMapper studentMapper;
@AutoWired
private TeacherMapper teacherMapper;

@Override
public Student getStudentById(Integer id) {
    return studentMapper.searchById(id);
}

@Override
public Teacher getTeacherById(Integer id) {
    return teacherMapper.searchById(id);
}


这两个查询方法都可以顺利查询到数据
动态数据源
之前已经实现了多数据源配置，那现在我们进行动态数据源配置
这部分内容我完全参考：

JAVA中使用代码创建多数据源，并实现动态切换（一）
这位写的应该比我好得多，所以大家直接看这篇就行