170713、springboot编程之多数据源切换

我们在开发过程中可能需要用到多个数据源，我们有一个项目（MySQL）就是和别的项目（SQL Server）混合使用了。其中SQL Server是别的公司开发的，有些基本数据需要从他们平台进行调取，那么在项目中就需要支持多数据源，不然就只能获取到自己的数据源的数据了。当然还有很多其它方面的使用场景，多数据库，比如有专门负责生成id的数据库，或者主从库分离等等。总之多数据源可能在实际中还是需要用到的。

在Spring Boot中使用单数据源的配置很简单，我们简单回忆下：只需要在application.properties进行基本的连接配置，在pom.xml引入基本的依赖即可。

那么多数据源的原理呢？其实很简单，就是读取配置文件，根据配置文件中的配置的数据源数量，动态创建dataSource并注册到Spring中。在上一节我们介绍了使用Java代码将对象注册到Spring中，多数据源就是基于这儿基础进行动态创建的。本节大概需要这么几个步骤：

（1）新建maven java project;

（2）在pom.xml添加相关依赖；

（3）编写app.java启动类;

（4）编写application.properties配置文件；

（5）编写多数据源注册文件；

（6）编写测试类

（7）测试

接下来让我们按照这个步骤来进行编写我们的代码吧。

（1）新建maven java project;

我们新建一个maven project进行测试，取名为：spring-boot-multids

（2）在pom.xml添加相关依赖；

在pom.xml文件中加入依赖的库文件，主要是spring boot基本的，数据库驱动，spring-jpa支持即可，具体pom.xml文件如下：

<project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

<modelVersion>4.0.0</modelVersion>

<groupId>com.kfit</groupId>

<artifactId>spring-boot-multids</artifactId>

<version>0.0.1-SNAPSHOT</version>

<packaging>jar</packaging>

<name>spring-boot-multids</name>

<url>http://maven.apache.org</url>

<properties>

<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

<!-- jdk版本号，这里需要你本地进行的jdk进行修改,这里angel使用的是1.8的版本. -->

<java.version>1.8</java.version>

</properties>

<!--

spring boot 父节点依赖,

引入这个之后相关的引入就不需要添加version配置，

spring boot会自动选择最合适的版本进行添加。

在这里使用的1.3.3版本，可能目前官方有最新的版本了，大家可以

使用最新的版本。

-->

<parent>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-parent</artifactId>

<version>1.3.3.RELEASE</version>

</parent>

<dependencies>

<!-- 单元测试包，在这里没有使用到. -->

<dependency>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

<scope>test</scope>

</dependency>

<!-- spring boot web支持：mvc,aop...

这个是最基本的，基本每一个基本的demo都是需要引入的。

-->

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-web</artifactId>

</dependency>

<!-- mysql驱动.

我们的demo是多数据源，在这里使用Mysql数据库.

-->

<dependency>

<groupId>mysql</groupId>

<artifactId>mysql-connector-java</artifactId>

</dependency>

<!-- spring jpa

spring jpa中带有自带的tomcat数据连接池;

在代码中我们也需要用到.

-->

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-data-jpa</artifactId>

</dependency>

</dependencies>

</project>

在上面的配置文件中都有相应的解释，大家可以自己解读下。

（3）编写app.java启动类;

编写spring boot的启动类：

com.kfit.App:

package com.kfit;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

/**

*

* @author Angel(QQ:412887952)

* @version v.0.1

*/

@SpringBootApplication

publicclass App {

publicstaticvoid main(String[] args) {

SpringApplication.run(App.class, args);

}

}

（4）编写application.properties配置文件；

在这里主要是多数据源的配置：

src/main/resources/application.properties:

########################################################

###配置文件包括1个主数据源和多个数据源，

###其中主数据源在Spring中的beanName默认为dataSource，

###另外几个数据源的beanName分包为：ds1、ds2、ds3

###其中datasource的type属性可以具体指定到我们需要的数据源上面，

###不指定情况下默认为：org.apache.tomcat.jdbc.pool.DataSource

###当然你也可以把这些数据源配置到主dataSource数据库中，然后读取数据库生成多数据源。当然这样做的必要性并不大，难不成数据源还会经常变吗。

########################################################

# 主数据源，默认的

#spring.datasource.type=com.zaxxer.hikari.HikariDataSource

spring.datasource.driverClassName=com.mysql.jdbc.Driver

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

spring.datasource.username=root

spring.datasource.password=root

# 更多数据源

custom.datasource.names=ds1,ds2,ds3

#custom.datasource.ds1.type=com.zaxxer.hikari.HikariDataSource

custom.datasource.ds1.driverClassName =com.mysql.jdbc.Driver

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

custom.datasource.ds1.username=root

custom.datasource.ds1.password=root

#custom.datasource.ds2.type=com.zaxxer.hikari.HikariDataSource

custom.datasource.ds2.driverClassName =com.mysql.jdbc.Driver

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

custom.datasource.ds2.username=root

custom.datasource.ds2.password=root

#custom.datasource.ds3.type=com.zaxxer.hikari.HikariDataSource

custom.datasource.ds3.driverClassName =com.mysql.jdbc.Driver

custom.datasource.ds3.url=jdbc:mysql://localhost:3306/test

custom.datasource.ds3.username=root

custom.datasource.ds3.password=root

# 下面为连接池的补充设置，应用到上面所有数据源中

spring.datasource.maximum-pool-size=100

spring.datasource.max-idle=10

spring.datasource.max-wait=10000

spring.datasource.min-idle=5

spring.datasource.initial-size=5

spring.datasource.validation-query=SELECT 1

spring.datasource.test-on-borrow=false

spring.datasource.test-while-idle=true

spring.datasource.time-between-eviction-runs-millis=18800

（5）编写多数据源注册文件；

这个注入是最核心的部分，我们先看代码：

com.kfit.config.datasource.multids.MultipleDataSourceBeanDefinitionRegistryPostProcessor：

package com.kfit.config.datasource.multids;

import java.util.HashMap;

import java.util.Map;

import java.util.Map.Entry;

import javax.sql.DataSource;

import org.springframework.beans.BeansException;

import org.springframework.beans.MutablePropertyValues;

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

import org.springframework.beans.factory.config.BeanDefinition;

import org.springframework.beans.factory.config.BeanDefinitionHolder;

import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;

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

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

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

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

import org.springframework.boot.bind.RelaxedPropertyResolver;

import org.springframework.context.EnvironmentAware;

import org.springframework.context.annotation.AnnotationBeanNameGenerator;

import org.springframework.context.annotation.AnnotationConfigUtils;

import org.springframework.context.annotation.AnnotationScopeMetadataResolver;

import org.springframework.context.annotation.Configuration;

import org.springframework.context.annotation.ScopeMetadata;

import org.springframework.context.annotation.ScopeMetadataResolver;

import org.springframework.core.env.Environment;

/**

* 动态创建多数据源注册到Spring中

*

接口：BeanDefinitionRegistryPostProcessor只要是注入bean,

在上一节介绍过使用方式；

接口：接口 EnvironmentAware 重写方法 setEnvironment

可以在工程启动时，获取到系统环境变量和application配置文件中的变量。

这个第24节介绍过.

方法的执行顺序是：

setEnvironment()-->postProcessBeanDefinitionRegistry() --> postProcessBeanFactory()

*

* @author Angel(QQ:412887952)

* @version v.0.1

*/

@Configuration

publicclass MultipleDataSourceBeanDefinitionRegistryPostProcessor implementsBeanDefinitionRegistryPostProcessor,EnvironmentAware{

//作用域对象.

private ScopeMetadataResolver scopeMetadataResolver = newAnnotationScopeMetadataResolver();

//bean名称生成器.

private BeanNameGenerator beanNameGenerator = new AnnotationBeanNameGenerator();

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

privatestaticfinal Object DATASOURCE_TYPE_DEFAULT = "org.apache.tomcat.jdbc.pool.DataSource";

//  private static final Object DATASOURCE_TYPE_DEFAULT = "com.zaxxer.hikari.HikariDataSource";

// 存放DataSource配置的集合;

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

@Override

publicvoid postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throwsBeansException {

System.out.println("MultipleDataSourceBeanDefinitionRegistryPostProcessor.postProcessBeanFactory()");

//设置为主数据源;

beanFactory.getBeanDefinition("dataSource").setPrimary(true);

if(!dataSourceMap.isEmpty()){

//不为空的时候.

BeanDefinition bd = null;

Map<String, Object> dsMap = null;

MutablePropertyValues mpv = null;

for (Entry<String, Map<String, Object>> entry : dataSourceMap.entrySet()) {

bd = beanFactory.getBeanDefinition(entry.getKey());

mpv = bd.getPropertyValues();

dsMap = entry.getValue();

mpv.addPropertyValue("driverClassName", dsMap.get("driverClassName"));

mpv.addPropertyValue("url", dsMap.get("url"));

mpv.addPropertyValue("username", dsMap.get("username"));

mpv.addPropertyValue("password", dsMap.get("password"));

}

}

}

@SuppressWarnings("unchecked")

@Override

publicvoid postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throwsBeansException {

System.out.println("MultipleDataSourceBeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry()");

try {

if(!dataSourceMap.isEmpty()){

//不为空的时候，进行注册bean.

for(Entry<String,Map<String,Object>> entry:dataSourceMap.entrySet()){

Object type = entry.getValue().get("type");//获取数据源类型，没有设置为默认的数据源.

if(type == null){

type= DATASOURCE_TYPE_DEFAULT;

}

registerBean(registry, entry.getKey(),(Class<? extendsDataSource>)Class.forName(type.toString()));

}

}

} catch (ClassNotFoundException  e) {

//异常捕捉.

e.printStackTrace();

}

}

/**

* 注意重写的方法 setEnvironment 是在系统启动的时候被执行。

* 这个方法主要是：加载多数据源配置

* 从application.properties文件中进行加载;

*/

@Override

publicvoid setEnvironment(Environment environment) {

System.out.println("MultipleDataSourceBeanDefinitionRegistryPostProcessor.setEnvironment()");

/*

* 获取application.properties配置的多数据源配置，添加到map中，之后在postProcessBeanDefinitionRegistry进行注册。

*/

//获取到前缀是"custom.datasource." 的属性列表值.

RelaxedPropertyResolver propertyResolver = newRelaxedPropertyResolver(environment,"custom.datasource.");

//获取到所有数据源的名称.

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

String[] dsPrefixsArr = dsPrefixs.split(",");

for(String dsPrefix:dsPrefixsArr){

/*

* 获取到子属性，对应一个map;

* 也就是这个map的key就是

*

* type、driver-class-name等;

*

*

*/

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

//存放到一个map集合中，之后在注入进行使用.

dataSourceMap.put(dsPrefix, dsMap);

}

}

/**

* 注册Bean到Spring

*

* @param registry

* @param name

* @param beanClass

* @author SHANHY

* @create 2016年1月22日

*/

privatevoid registerBean(BeanDefinitionRegistry registry, String name, Class<?> beanClass) {

AnnotatedGenericBeanDefinition abd = newAnnotatedGenericBeanDefinition(beanClass);

//单例还是原型等等...作用域对象.

ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);

abd.setScope(scopeMetadata.getScopeName());

// 可以自动生成name

String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, registry));

AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);

BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);

BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);

}

}

在代码中已经加入了，注释，大家可以好好看，在这里简单说明下。

以上代码的执行顺序是：

setEnvironment()-->postProcessBeanDefinitionRegistry() --> postProcessBeanFactory()

在setEnvironment（）方法中主要是读取了application.properties的配置；

在postProcessBeanDefinitionRegistry（）方法中主要注册为spring的bean对象；

在postProcessBeanFactory（）方法中主要是注入从setEnvironment方法中读取的application.properties配置信息。

需要注意的是这里并没有读取其它相同的数据源公共配置，这里我们不做介绍，在下节介绍，主要是因为这节在实际中我们并不会这么使用，这里只是过渡下，方便下节进行讲解。

（6）编写测试类

我们编写一个简单的类进行测试下，到底我们的多数据源是否注入成功了。

com.kfit.controller.TestController：

package com.kfit.controller;

import java.sql.ResultSet;

import java.sql.SQLException;

import javax.sql.DataSource;

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

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

import org.springframework.jdbc.core.JdbcTemplate;

import org.springframework.jdbc.core.RowMapper;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

/**

* 测试;

* @author Angel(QQ:412887952)

* @version v.0.1

*/

@RestController

publicclass TestController {

//没有指定为主数据源.

@Autowired

private DataSource dataSource;

@Autowired

@Qualifier("ds1")

private DataSource dataSource1;

@Autowired

@Qualifier("ds2")

private DataSource dataSource2;

private JdbcTemplate jdbcTemplate;

@Autowired

publicvoid setJdbcTemplate(JdbcTemplate jdbcTemplate) {

System.out.println("TestController.setJdbcTemplate()");

jdbcTemplate.setDataSource(dataSource1);//设置dataSource

this.jdbcTemplate = jdbcTemplate;

}

@RequestMapping("/get")

public String get(){

//观察控制台的打印信息.

System.out.println(dataSource);

return"ok";

}

@RequestMapping("/get1")

public String get1(){

//观察控制台的打印信息.

System.out.println(dataSource1);

return"ok.1";

}

@RequestMapping("/get2")

public String get2(){

//观察控制台的打印信息.

System.out.println(dataSource2);

return"ok.2";

}

@RequestMapping("/get3")

public String get3(){

//观察控制台的打印信息.

JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource1);

System.out.println(jdbcTemplate.getDataSource());

System.out.println(jdbcTemplate);

/*

* Demo1只在test1中存在，test并没有此数据库;

* 需要自己自己进行复制，不然会报错：Table 'test1.demo1' doesn't exist

*/

String sql = "select *from Demo1";

jdbcTemplate.query(sql, new RowMapper<String>(){

@Override

public String mapRow(ResultSet rs, introwNum) throws SQLException {

System.out.println(rs.getLong("id")+"---"+rs.getString("name"));

return"";

}

});

return"ok.3";

}

@RequestMapping("/get4")

public String get4(){

//观察控制台的打印信息.

System.out.println(jdbcTemplate.getDataSource());

System.out.println(jdbcTemplate);

/*

* Demo1只在test1中存在，test并没有此数据库;

* 需要自己自己进行复制，不然会报错：Table 'test1.demo1' doesn't exist

*/

String sql = "select *from Demo1";

jdbcTemplate.query(sql, new RowMapper<String>(){

@Override

public String mapRow(ResultSet rs, introwNum) throws SQLException {

System.out.println(rs.getLong("id")+"---"+rs.getString("name"));

return"";

}

});

return"ok.4";

}

}

以上代码在实际开发中，是绝对不能这么编写的，这里只是为了方便进行测试。

（7）测试

Run As 运行app.java进行测试：

访问：

http://127.0.0.1:8080/get

http://127.0.0.1:8080/get1

http://127.0.0.1:8080/get2

http://127.0.0.1:8080/get3

http://127.0.0.1:8080/get4

查看控制台的打印信息。

然而我们在项目中不一定需要直接使用dataSource的，大家都习惯使用JDBC的jdbcTemplate、Mybatis的sqlSessionTemplate，再或者就是以Mybatis为例直接动态代理到Mapper接口上。

代码地址：https://github.com/zrbfree/springboot-edu-multids.git