42. Spring Boot多数据源【从零开始学Spring Boot】

我们在开发过程中可能需要用到多个数据源，我们有一个项目（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">

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

<version>0.0.1-SNAPSHOT</version>

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

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

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

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

</properties>

<!--

spring boot 父节点依赖,

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

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

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

使用最新的版本。

-->

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

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

<version>1.3.3.RELEASE</version>

</parent>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</dependency>

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

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

-->

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

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

</dependency>

<!-- mysql驱动.

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

-->

<groupId>mysql</groupId>

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

</dependency>

<!-- spring jpa

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

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

-->

<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 implements BeanDefinitionRegistryPostProcessor,EnvironmentAware{

//作用域对象.

private ScopeMetadataResolver scopeMetadataResolver = new AnnotationScopeMetadataResolver();

//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) throws BeansException {

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) throws BeansException {

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<? extends DataSource>)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 = new RelaxedPropertyResolver(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 = new AnnotatedGenericBeanDefinition(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接口上。

那么如何做到完全动态数据源呢，以至于实现我们可以为同一个Java类的不同方法，分别指定使用不同的数据源？下篇文章将为大家进行讲解，下期见！

【Spring Boot 系列博客】

视频&交流平台：

à悟空学院：https://t.cn/Rg3fKJD

学院中有Spring Boot相关的课程！点击「阅读原文」进行查看！

SpringBoot视频：http://t.cn/A6ZagYTi

Spring Cloud视频：http://t.cn/A6ZagxSR

SpringBoot Shiro视频：http://t.cn/A6Zag7IV

SpringBoot交流平台：https://t.cn/R3QDhU0

SpringData和JPA视频：http://t.cn/A6Zad1OH

SpringSecurity5.0视频：http://t.cn/A6ZadMBe

Sharding-JDBC分库分表实战：http://t.cn/A6ZarrqS

分布式事务解决方案「手写代码」：http://t.cn/A6ZaBnIr

网易云课堂视频最新更新：

第十一章 Spring Boot 日志

1、spring boot日志—理论

2、Spring Boot日志-logback

3、Spring Boot日志-log4j2

第十二章 Spring Boot 知识点2

1、spring boot 服务配置和部署

2、Spring Boot 定制URL匹配规则

历史章节：

第一章快速开始

1、Spring Boot之Hello World

2、Spring Boot之Hello World访问404

第二章 Spring Boot之JSON

1、spring boot返回json数据

2、Spring Boot完美使用FastJson解析JSON数据

第三章 Spring Boot热部署

1、Spring Boot热部署(springloader)

2、springboot + devtools（热部署）

第四章 Spring Boot数据库

1、Spring Boot JPA/Hibernate/Spring Data概念

2、Spring Boot JPA-Hibernate

3、Spring Boot Spring Data JPA介绍

4、Spring Boot JdbcTemplate

5、Spring Boot集成MyBatis

第五章 web开发

1、全局异常捕捉

2、配置server信息

3、spring boot使用thymeleaf

4、Spring Boot 使用freemarker

5、Spring Boot添加JSP支持

第六章定时任务

1、Spring Boot定时任务

2、Spring Boot 定时任务升级篇（动态修改cron参数）

3、Spring Boot 定时任务升级篇（动态添加修改删除定时任务）

4、Spring Boot 定时任务升级篇（集群/分布式下的定时任务说明）

5、Spring Boot Quartz介绍

6、Spring Boot Quartz在Java Project中使用

7、Spring Boot 集成Quartz普通使用

8、Spring Boot 集成Quartz升级版

9、Spring Boot 集成Quartz二次升级版

10、Spring Boot 集成Quartz-Job如何自动注入Spring容器托管的对象

第七章 Spring Boot MyBatis升级篇

1、Spring Boot MyBatis升级篇-注解

2、Spring Boot MyBatis升级篇-注解-自增ID

3、Spring Boot MyBatis升级篇-注解-增删改查

4、Spring Boot MyBatis升级篇-注解-分页查询

5、Spring Boot MyBatis升级篇-注解-分页PageHelper不生效

6、Spring Boot MyBatis升级篇-注解- mybatic insert异常：BindingException: Parameter 'name' not found

7、Spring Boot MyBatis升级篇-注解- #和$符号特别篇

8、Spring Boot MyBatis升级篇-注解-@Result

9、Spring Boot MyBatis升级篇-注解-动态SQL(if test)-方案一:<script>

10、Spring Boot MyBatis升级篇-注解-动态SQL(if test)-方案二:@Provider

11、Spring Boot MyBatis升级篇-注解-动态SQL-参数问题

12、Spring Boot MyBatis升级篇-注解-特别篇：@MapperScan和@Mapper

13、Spring Boot MyBatis升级篇-XML

14、Spring Boot MyBatis升级篇-XML-自增ID

15、Spring Boot MyBatis升级篇-XML-增删改查

16、Spring Boot MyBatis升级篇-XML-分页查询

17、Spring Boot MyBatis升级篇-XML-分页PageHelper不生效

18、Spring Boot MyBatis升级篇-XML-动态SQL(if test)

19、Spring Boot MyBatis升级篇-XML-注解-初尝试

20、Spring Boot MyBatis升级篇- pagehelper替换为pagehelper-spring-boot-starter

第八章 Spring Boot 知识点1

1、Spring Boot 拦截器HandlerInterceptor

2、Spring Boot启动加载数据CommandLineRunner

3、Spring Boot环境变量读取和属性对象的绑定

4、Spring Boot使用自定义的properties

5、Spring Boot使用自定义的properties

6、Spring Boot使用@SpringBootApplication

7、Spring Boot 监控和管理生产环境

第十章 Spring Boot 打包部署

1、Spring Boot打包部署（(提供Linux的sh文件)）

第十一章 Spring Boot 日志

1、spring boot日志—理论

2、Spring Boot日志-logback

3、Spring Boot日志-log4j2

分享到：

43. Spring Boot动态数据源（多数据源自动 ... | 41. Spring Boot 使用Java代码创建Bean并注 ...

2016-06-03 22:59
浏览 34332
评论(13)
论坛回复 / 浏览 (0 / 2420)
分类:编程语言
查看更多

13 楼林祥纤 2017-07-07

PanlJlove 写道

没有源码吗？

部分有源码！

12 楼 PanlJlove 2017-07-07

没有源码吗？

11 楼林祥纤 2017-05-26

小明男神写道

对楼主的敬意如滔滔江水太喜欢这个系列了！！实用易懂

哈哈

10 楼林祥纤 2017-05-26

forever1121 写道

灰常感谢，学到了很多

那就好！

9 楼 forever1121 2017-05-26

灰常感谢，学到了很多

8 楼小明男神 2016-11-10

对楼主的敬意如滔滔江水太喜欢这个系列了！！实用易懂

7 楼 k88520 2016-11-03

求问为什么访问第一个http://127.0.0.1:8080/get的时候控制台打印的是null呢主数据源为默认配置打印出来不应该是null啊还是说因为这篇文章是演示的所以主数据源没有加载进来所以打印出来的是null
@RequestMapping("/get")
    public String get(){
       //观察控制台的打印信息.
       System.out.println(dataSource);
       return"ok";
    }
就是这个打印出来的是null 其他都正常注入了

6 楼林祥纤 2016-08-26

kala888 写道

不支持application.yml

我错了, 是支持的

嗯。

5 楼 kala888 2016-08-26

问一个小问题:
如果要扩展其他的ds的配置,例如
spring.datasource.max-idle=8
spring.datasource.min-idle=8

是不只需要,将属性塞到mpv里就可以了?
mpv.addPropertyValue("url", dsMap.get("max-idle"));
]

4 楼 kala888 2016-08-26

kala888 写道

不支持application.yml

我错了, 是支持的

3 楼 kala888 2016-08-26

不支持application.yml

2 楼林祥纤 2016-08-02

ddsdggsg 写道

在实际开发中不能这么写？是指？

实际开发中，我们不会执行使用dataSource这样的类的，这里是为了讲解而已。

1 楼 ddsdggsg 2016-08-02

在实际开发中不能这么写？是指？

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论