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

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/linxingliang/article/details/52324924

 

【视频&交流平台】

à SpringBoot视频

http://study.163.com/course/introduction.htm?courseId=1004329008&utm_campaign=commission&utm_source=400000000155061&utm_medium=share

à SpringCloud视频

http://study.163.com/course/introduction.htm?courseId=1004638001&utm_campaign=commission&utm_source=400000000155061&utm_medium=share

à Spring Boot源码

https://gitee.com/happyangellxq520/spring-boot

à Spring Boot交流平台

http://412887952-qq-com.iteye.com/blog/2321532

 


 

 


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

 

import java.util.HashMap;

import java.util.Map;

import java.util.Map.Entry;

 

import javax.sql.DataSource;

 

importorg.springframework.beans.BeansException;

importorg.springframework.beans.MutablePropertyValues;

importorg.springframework.beans.factory.annotation.AnnotatedGenericBeanDefinition;

importorg.springframework.beans.factory.config.BeanDefinition;

importorg.springframework.beans.factory.config.BeanDefinitionHolder;

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

importorg.springframework.beans.factory.support.BeanDefinitionReaderUtils;

importorg.springframework.beans.factory.support.BeanDefinitionRegistry;

importorg.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;

importorg.springframework.beans.factory.support.BeanNameGenerator;

importorg.springframework.boot.bind.RelaxedPropertyResolver;

importorg.springframework.context.EnvironmentAware;

importorg.springframework.context.annotation.AnnotationBeanNameGenerator;

importorg.springframework.context.annotation.AnnotationConfigUtils;

importorg.springframework.context.annotation.AnnotationScopeMetadataResolver;

importorg.springframework.context.annotation.Configuration;

import org.springframework.context.annotation.ScopeMetadata;

importorg.springframework.context.annotation.ScopeMetadataResolver;

importorg.springframework.core.env.Environment;

 

/**

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

 *

 接口:BeanDefinitionRegistryPostProcessor只要是注入bean,

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

 

 接口:接口 EnvironmentAware重写方法 setEnvironment

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

这个第24节介绍过.

 

 方法的执行顺序是:

 

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

 

 

 *

 *@author Angel(QQ:412887952)

 *@version v.0.1

 */

@Configuration

publicclassMultipleDataSourceBeanDefinitionRegistryPostProcessorimplementsBeanDefinitionRegistryPostProcessor,EnvironmentAware{

 

      

       //作用域对象.

       privateScopeMetadataResolverscopeMetadataResolver =new AnnotationScopeMetadataResolver();

       //bean名称生成器.

       privateBeanNameGeneratorbeanNameGenerator =new AnnotationBeanNameGenerator();

             

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

   privatestaticfinal ObjectDATASOURCE_TYPE_DEFAULT ="org.apache.tomcat.jdbc.pool.DataSource";

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

             

       // 存放DataSource配置的集合;

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

      

      

       @Override

       publicvoidpostProcessBeanFactory(ConfigurableListableBeanFactorybeanFactory)throws BeansException {

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

              //设置为主数据源;

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

             

              if(!dataSourceMap.isEmpty()){

                     //不为空的时候.

                     BeanDefinitionbd =null;

               Map<String, Object>dsMap =null;

               MutablePropertyValuesmpv =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

       publicvoidpostProcessBeanDefinitionRegistry(BeanDefinitionRegistryregistry)throws BeansException{

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

              try {

                     if(!dataSourceMap.isEmpty()){

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

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

                                   Objecttype =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

       publicvoidsetEnvironment(Environmentenvironment) {

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

             

              /*

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

               */

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

              RelaxedPropertyResolverpropertyResolver =newRelaxedPropertyResolver(environment,"custom.datasource.");

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

              StringdsPrefixs =propertyResolver.getProperty("names");

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

              for(StringdsPrefix: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(BeanDefinitionRegistryregistry, Stringname, Class<?>beanClass) {

        AnnotatedGenericBeanDefinitionabd =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 = newBeanDefinitionHolder(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;

 

importjavax.sql.DataSource;

 

importorg.springframework.beans.factory.annotation.Autowired;

importorg.springframework.beans.factory.annotation.Qualifier;

importorg.springframework.jdbc.core.JdbcTemplate;

importorg.springframework.jdbc.core.RowMapper;

import</span%

展开阅读全文
博主设置当前文章不允许评论。

没有更多推荐了,返回首页