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

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

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

(1)新建maven javaproject;

(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文件中加入依赖的库文件,主要是springboot基本的,数据库驱动,spring-jpa支持即可,具体pom.xml文件如下:

<projectxmlns="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.0http://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>

<!--

springboot父节点依赖,

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

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

在这里使用的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>

<!-- springjpa

springjpa中带有自带的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;

importorg.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;

mport 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()
 
 
 *
 *
 * @version v.0.1
 */
@Configuration
public class MultipleDataSourceBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor,EnvironmentAware{
 
    
    //作用域对象.
    private ScopeMetadataResolver scopeMetadataResolver = new AnnotationScopeMetadataResolver();
    //bean名称生成器.
    private BeanNameGenerator beanNameGenerator = new AnnotationBeanNameGenerator();
       
    //如配置文件中未指定数据源类型,使用该默认值
    private static final 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
    public void 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
    public void 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
    public void 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 lv
     * @create 2019年3月6日
     */
    private void 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 java.util.UUID;

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;

import com.springboot.sample.entity.Student;
 
/**
 * 测试;
 *
 * @version v.0.1
 */
@RestController
public class TestController {
    
    //没有指定为主数据源.
    @Autowired
    private DataSource dataSource;
    
    @Autowired
    @Qualifier("ds1")
    private DataSource dataSource1;
    
    @Autowired
    @Qualifier("ds2")
    private DataSource dataSource2;
   
    
    
    @Autowired
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
       System.out.println("TestController.setJdbcTemplate()");
       jdbcTemplate.setDataSource(dataSource);//设置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 jdbcTemplate0 = new JdbcTemplate(dataSource);
     
      System.out.println(jdbcTemplate.getDataSource());
       System.out.println(jdbcTemplate);
         
       /*
         * student只在test1中存在,test并没有此数据库;
         * 需要自己自己进行复制,不然会报错:Table 'test1.student' doesn't exist
         */
      
 
      String sql1 = "select * from student  ";
        jdbcTemplate0.query(sql, new RowMapper <String>(){
            @Override
            public String mapRow(ResultSet arg0, int arg1) throws SQLException {
                System.out.println(arg0.getString("name")+"--0-"+arg0.getString("name"));
                return"";
            }});
     
       return"ok.3";
    }
    
    
    @RequestMapping("/get4")
    public String get4(){
         JdbcTemplate jdbcTemplate2 = new JdbcTemplate(dataSource2);
       //观察控制台的打印信息.
       System.out.println(jdbcTemplate.getDataSource());
       System.out.println(jdbcTemplate);
         
       /*
         * student只在test1中存在,test并没有此数据库;
         * 需要自己自己进行复制,不然会报错:Table 'test1.student' doesn't exist
         */
       String sql = "select * from student";
       jdbcTemplate2.query(sql, new RowMapper<String>(){
 
                    @Override
                    public String mapRow(ResultSet rs, int arg1) throws SQLException {
                         System.out.println(rs.getString("name")+"---"+rs.getString("name"));
                        return null;
                    }
             
                   });
                  
                  return"ok.4";
    }
}

Spring Boot多数据源的更多相关文章

  1. Spring Boot多数据源配置(二)MongoDB

    在Spring Boot多数据源配置(一)durid.mysql.jpa 整合中已经讲过了Spring Boot如何配置mysql多数据源.本篇文章讲一下Spring Boot如何配置mongoDB多 ...

  2. (43). Spring Boot动态数据源(多数据源自动切换)【从零开始学Spring Boot】

    在上一篇我们介绍了多数据源,但是我们会发现在实际中我们很少直接获取数据源对象进行操作,我们常用的是jdbcTemplate或者是jpa进行操作数据库.那么这一节我们将要介绍怎么进行多数据源动态切换.添 ...

  3. 关于Spring Boot 多数据源的事务管理

    自己的一些理解:自从用了Spring Boot 以来,这近乎零配置和"约定大于配置"的设计范式用着确实爽,其实对零配置的理解是:应该说可以是零配置可以跑一个简单的项目,因为Spri ...

  4. 四、Spring Boot 多数据源 自动切换

    实现案例场景: 某系统除了需要从自己的主要数据库上读取和管理数据外,还有一部分业务涉及到其他多个数据库,要求可以在任何方法上可以灵活指定具体要操作的数据库.为了在开发中以最简单的方法使用,本文基于注解 ...

  5. spring boot多数据源配置(mysql,redis,mongodb)实战

    使用Spring Boot Starter提升效率 虽然不同的starter实现起来各有差异,但是他们基本上都会使用到两个相同的内容:ConfigurationProperties和AutoConfi ...

  6. 21. Spring Boot Druid 数据源配置解析

    1.数据源配置属性类源码 package org.springframework.boot.autoconfigure.jdbc; @ConfigurationProperties( prefix = ...

  7. spring boot 多数据源配置与使用

    在介绍使用JdbcTemplate和Spring-data-jpa时,都使用了单数据源.在单数据源的情况下,Spring Boot的配置非常简单,只需要在application.properties文 ...

  8. Spring Boot多数据源配置与使用

    在单数据源的情况下,Spring Boot的配置非常简单,只需要在application.properties文件中配置连接参数即可.但是往往随着业务量发展,我们通常会进行数据库拆分或是引入其他数据库 ...

  9. 【Spring】Spring boot多数据源历险记

    一.问题描述 笔者根据需求在开发过程中,需要在原项目的基础上(单数据源),新增一个数据源C,根据C数据源来实现业务.至于为什么不新建一个项目,大概是因为这只是个小功能,访问量不大,不需要单独申请个服务 ...

  10. spring boot(12)-数据源配置原理

    本篇讲的不仅是数据源配置,这也是spring boot实现自动配置的一部分.要理解数据源的配置原理,首先要理解第十篇tomcat连接池的配置 数据源配置源码 这里截取org.springframewo ...

随机推荐

  1. web开发 那些年基于Redis的Provider库

    因为session基于本地cache,以前我们自己写分布式缓存,或者数据库存储,或者cookie加密存储,来保存用户状态信息,但较少的直接通过创建一个继承 SessionStateStoreProvi ...

  2. Java 对象和实例的区别

    本来我以为是一样的,其实是不一样的 参看:http://www.blogjava.net/dreamstone/archive/2011/06/03/101733.html

  3. 分布式爬虫搭建系列 之四---scrapy分布式框架

    带录入SAFCDS 

  4. [019] Android平台调用WebService详解

    http://blog.csdn.net/lyq8479/article/details/6428288/ http://www.cnblogs.com/gzggyy/archive/2011/06/ ...

  5. libevent网络编程汇总

    libevent源码剖析: ========================================================== 1.libevent源码剖析一(序) 2.libeve ...

  6. PHP下的手机号码效验

    手机号是否合法有效,基本都是用正则匹配的,所以正则表达式是关键,可以用到java.c#等语言里. /** * 验证手机号是否合法 * * @param string $mobile * 验证的手机号 ...

  7. scala中存在的问题

    2017-12-27 scala学习中存在的问题: 1.表达式的概念要搞清楚 2.八种基本数据类型要搞清楚 Byte\Short\Int\Long\Char\Boolean\Double\Float都 ...

  8. js格式化时间和时间操作

    js格式化时间 function formatDateTime(inputTime) { var date = new Date(inputTime); var y = date.getFullYea ...

  9. AJAX省市县三级联动的实现

    省市县数据 本例子中省市县数据保存在MySQL数据库中,部分数据截图如下: 从数据库中读取数据 导入需要的jar包 连接池配置文件 <c3p0-config> <!-- 默认配置,如 ...

  10. SaeStorage使用示例

    新浪SAE官方地址:http://apidoc.sinaapp.com/sae/SaeStorage.html SaeStorage的代码详细:http://apidoc.sinaapp.com/__ ...