à悟空学院: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
我们在开发过程中可能需要用到多个数据源,我们有一个项目(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的启动类:
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进行测试:
访问:
查看控制台的打印信息。
然而我们在项目中不一定需要直接使用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
相关推荐
从零开始学Spring Boot.pdf从零开始学Spring Boot.pdf从零开始学Spring Boot.pdf从零开始学Spring Boot.pdf从零开始学Spring Boot.pdf从零开始学Spring Boot.pdf从零开始学Spring Boot.pdf从零开始学Spring Boot.pdf...
从零开始学Spring Boot,没有积分的...(2)Spring Boot返回json数据【从零开始学Spring Boot】 http://412887952-qq-com.iteye.com/blog/2291508 (15)Spring Boot使用Druid和监控配置【从零开始学Spring Boot】 ...
NULL 博文链接:https://412887952-qq-com.iteye.com/blog/2305992
Pro Spring Boot is your authoritative hands-on practical guide for increasing your Spring Framework-based enterprise Java and cloud application productivity while decreasing development time using the...
一个springboot的多数据配置,从mapper到controller完整的一个业务流程
spring boot 2多数据源,里面有hibernate和mybatis的多数据源代码。代码拿过去即可集成使用。
Spring Boot 学习示例 Spring Boot 2.0 Mysql 5.6 JDK 1.8 Maven license Spring Boot 使用的各种示例,以最简单、最实用为标准,此开源项目中的每个示例都以最小依赖,最简单为标准,帮助初学者快速掌握 Spring ...
NULL 博文链接:https://412887952-qq-com.iteye.com/blog/2293846
NULL 博文链接:https://412887952-qq-com.iteye.com/blog/2292739
赠送源代码:spring-boot-autoconfigure-2.3.12.RELEASE-sources.jar; 赠送Maven依赖信息文件:spring-boot-autoconfigure-2.3.12.RELEASE.pom; 包含翻译后的API文档:spring-boot-autoconfigure-2.3.12.RELEASE-...
2018.02.Spring Boot 2.0 Cookbook 2nd
从零开始学Spring Boot。是学习spring Boot的起步资料!!
This book will help you understand what Spring Boot is, how Spring Boot helps you build Spring-based applications quickly and easily, and the inner workings of Spring Boot using easy-to-follow ...
Spring Boot+Jpa多数据源配置Demo,可同时支持多种数据库,不同数据库,同时支持不同数据库的JdbcTemplate
NULL 博文链接:https://412887952-qq-com.iteye.com/blog/2295146
赠送源代码:spring-boot-configuration-processor-2.3.12.RELEASE-sources.jar; 赠送Maven依赖信息文件:spring-boot-configuration-processor-2.3.12.RELEASE.pom; 包含翻译后的API文档:spring-boot-...
Apress.Beginning.Spring.Boot.2.pdfApress.Beginning.Spring.Boot.2.pdfApress.Beginning.Spring.Boot.2.pdfApress.Beginning.Spring.Boot.2.pdfApress.Beginning.Spring.Boot.2.pdf
spring boot整合druid连接池,采用注解方式实现多数据源动态切换 jdk版本1.8 spring boot版本1.5.14
赠送源代码:spring-boot-2.3.12.RELEASE-sources.jar; 赠送Maven依赖信息文件:spring-boot-2.3.12.RELEASE.pom; 包含翻译后的API文档:spring-boot-2.3.12.RELEASE-javadoc-API文档-中文(简体)版.zip; Maven...