springboot 多数据源（三种数据库连接池--JDBC，dbcp2，Druid）

本文使用的是springboot2.0（在配置数据源时和springboot1.X略有区别）

首先：springboot默认支持的连接池有dbcp,dbcp2, tomcat, hikari四种连接池

由于Tomcat数据源连接池的性能和并发，在tomcat可用时，我们总是优先使用它。
如果HikariCP可用，我们将使用它。
如果Commons DBCP可用，我们将使用它，但在生产环境不推荐使用它。
最后，如果Commons DBCP2可用，我们将使用它

　　即自动优先级tomcat>HikariCP>DBCP>DBCP2（想要使用后面的连接池需要指定类型type：如：spring.datasource.ccjoin-settlement.type=org.apache.commons.dbcp2.BasicDataSource）

本例使用的是用多数据源，不同连接池：

需要的包：

spring-boot-starter-web(包含自带的tomcat)、mybatis-spring-boot-starter

springboot数据库连接：
有两种方法与数据库建立连接，一种是集成Mybatis，另一种用JdbcTemplate
用JdbcTemplate需要的包：
mysql-connector-java、spring-boot-starter-jdbc
集成mybatis需要的包：
mysql-connector-java、spring-boot-starter-jdbc、mybatis-spring-boot-starter

首先：目录结构如下

pom.xml如下

 <?xml version="1.0" encoding="UTF-8"?>

 <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.jmu.ccjoin</groupId>

     <artifactId>spring-boot</artifactId>

     <version>0.0.1-SNAPSHOT</version>

     <packaging>war</packaging>

     <name>spring-boot</name>

     <description>spring-boot</description>

     <parent>

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

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

         <version>2.0.4.RELEASE</version>

         <relativePath /> <!-- lookup parent from repository -->

     </parent>

     <properties>

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

         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

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

     </properties>

     <dependencies>

         <dependency>

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

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

         </dependency>

         <!-- tomcat自带jdbc连接池 -->

         <dependency>

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

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

             <!-- <scope>provided</scope> -->

         </dependency>

         <dependency>

             <groupId>org.mybatis.spring.boot</groupId>

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

             <version>1.3.2</version>

         </dependency>

         <dependency>

             <groupId>mysql</groupId>

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

             <scope>runtime</scope>

         </dependency>

         <dependency>

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

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

         </dependency>

         <!-- dbcp2数据库连接池 -->

         <dependency>

             <groupId>org.apache.commons</groupId>

             <artifactId>commons-dbcp2</artifactId>

         </dependency>

         <!-- dbcp数据库连接池 -->

         <dependency>

             <groupId>commons-dbcp</groupId>

             <artifactId>commons-dbcp</artifactId>

             <version>1.4</version>

         </dependency>

         <!-- druid数据库连接池 -->

         <dependency>

             <groupId>com.alibaba</groupId>

             <artifactId>druid</artifactId>

             <version>1.1.10</version>

         </dependency>

         <dependency>

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

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

             <scope>test</scope>

         </dependency>

         <dependency>

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

             <artifactId>spring-boot-configuration-processor</artifactId>

             <optional>false</optional>

         </dependency>

     </dependencies>

     <build>

         <finalName>spring-boot</finalName>

         <plugins>

             <plugin>

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

                 <artifactId>spring-boot-maven-plugin</artifactId>

                 <executions>

                     <execution>

                         <goals>

                             <goal>repackage</goal>

                         </goals>

                     </execution>

                 </executions>

             </plugin>

         </plugins>

     </build>

 </project>

ConfigProperties.java(把配置文件封装到bean并注入spring容器)

 package com.jmu.ccjoin.config;

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

 import org.springframework.context.annotation.PropertySource;

 import org.springframework.stereotype.Component;

 @Component

 @PropertySource("file:/var/opt/spring-boot-test/config.properties")

 public class ConfigProperties {

     @Value("${spring.datasource.jmuv3.jdbc-url}")

     private String jmuv3Url;

     @Value("${spring.datasource.jmuv3.driver-class-name}")

     private String jmuv3DriverClassName;

     @Value("${spring.datasource.jmuv3.username}")

     private String jmuv3Username;

     @Value("${spring.datasource.jmuv3.password}")

     private String jmuv3Password;

     @Value("${spring.datasource.ccjoin-settlement.jdbc-url}")

     private String ccjoinSettlementUrl;

     @Value("${spring.datasource.ccjoin-settlement.driver-class-name}")

     private String ccjoinSettlementDriverClassName;

     @Value("${spring.datasource.ccjoin-settlement.username}")

     private String ccjoinSettlementUsername;

     @Value("${spring.datasource.ccjoin-settlement.password}")

     private String ccjoinSettlementPassword;

     @Value("${spring.datasource.ccjoin-settlement.type}")

     private String ccjoinSettlementType;

     @Value("${spring.datasource.jmu-mp.jdbc-url}")

     private String jmuMpUrl;

     @Value("${spring.datasource.jmu-mp.driver-class-name}")

     private String jmuMpDriverClassName;

     @Value("${spring.datasource.jmu-mp.username}")

     private String jmuMpUsername;

     @Value("${spring.datasource.jmu-mp.password}")

     private String jmuMpPassword;

     /**

      * jmuv3Url的取得

      *

      * @return String jmuv3Url

      */

     public String getJmuv3Url() {

         return jmuv3Url;

     }

     /**

      * jmuv3Url的设定

      *

      * @param jmuv3Url

      *            jmuv3Url

      */

     public void setJmuv3Url(String jmuv3Url) {

         this.jmuv3Url = jmuv3Url;

     }

     /**

      * jmuv3DriverClassName的取得

      *

      * @return String jmuv3DriverClassName

      */

     public String getJmuv3DriverClassName() {

         return jmuv3DriverClassName;

     }

     /**

      * jmuv3DriverClassName的设定

      *

      * @param jmuv3DriverClassName

      *            jmuv3DriverClassName

      */

     public void setJmuv3DriverClassName(String jmuv3DriverClassName) {

         this.jmuv3DriverClassName = jmuv3DriverClassName;

     }

     /**

      * jmuv3Username的取得

      *

      * @return String jmuv3Username

      */

     public String getJmuv3Username() {

         return jmuv3Username;

     }

     /**

      * jmuv3Username的设定

      *

      * @param jmuv3Username

      *            jmuv3Username

      */

     public void setJmuv3Username(String jmuv3Username) {

         this.jmuv3Username = jmuv3Username;

     }

     /**

      * jmuv3Password的取得

      *

      * @return String jmuv3Password

      */

     public String getJmuv3Password() {

         return jmuv3Password;

     }

     /**

      * jmuv3Password的设定

      *

      * @param jmuv3Password

      *            jmuv3Password

      */

     public void setJmuv3Password(String jmuv3Password) {

         this.jmuv3Password = jmuv3Password;

     }

     /**

      * ccjoinSettlementUrl的取得

      *

      * @return String ccjoinSettlementUrl

      */

     public String getCcjoinSettlementUrl() {

         return ccjoinSettlementUrl;

     }

     /**

      * ccjoinSettlementUrl的设定

      *

      * @param ccjoinSettlementUrl

      *            ccjoinSettlementUrl

      */

     public void setCcjoinSettlementUrl(String ccjoinSettlementUrl) {

         this.ccjoinSettlementUrl = ccjoinSettlementUrl;

     }

     /**

      * ccjoinSettlementDriverClassName的取得

      *

      * @return String ccjoinSettlementDriverClassName

      */

     public String getCcjoinSettlementDriverClassName() {

         return ccjoinSettlementDriverClassName;

     }

     /**

      * ccjoinSettlementDriverClassName的设定

      *

      * @param ccjoinSettlementDriverClassName

      *            ccjoinSettlementDriverClassName

      */

     public void setCcjoinSettlementDriverClassName(String ccjoinSettlementDriverClassName) {

         this.ccjoinSettlementDriverClassName = ccjoinSettlementDriverClassName;

     }

     /**

      * ccjoinSettlementUsername的取得

      *

      * @return String ccjoinSettlementUsername

      */

     public String getCcjoinSettlementUsername() {

         return ccjoinSettlementUsername;

     }

     /**

      * ccjoinSettlementUsername的设定

      *

      * @param ccjoinSettlementUsername

      *            ccjoinSettlementUsername

      */

     public void setCcjoinSettlementUsername(String ccjoinSettlementUsername) {

         this.ccjoinSettlementUsername = ccjoinSettlementUsername;

     }

     /**

      * ccjoinSettlementPassword的取得

      *

      * @return String ccjoinSettlementPassword

      */

     public String getCcjoinSettlementPassword() {

         return ccjoinSettlementPassword;

     }

     /**

      * ccjoinSettlementPassword的设定

      *

      * @param ccjoinSettlementPassword

      *            ccjoinSettlementPassword

      */

     public void setCcjoinSettlementPassword(String ccjoinSettlementPassword) {

         this.ccjoinSettlementPassword = ccjoinSettlementPassword;

     }

     /**

      * ccjoinSettlementType的取得

      *

      * @return String ccjoinSettlementType

      */

     public String getCcjoinSettlementType() {

         return ccjoinSettlementType;

     }

     /**

      * ccjoinSettlementType的设定

      *

      * @param ccjoinSettlementType

      *            ccjoinSettlementType

      */

     public void setCcjoinSettlementType(String ccjoinSettlementType) {

         this.ccjoinSettlementType = ccjoinSettlementType;

     }

     /**

      * jmuMpUrl的取得

      *

      * @return String jmuMpUrl

      */

     public String getJmuMpUrl() {

         return jmuMpUrl;

     }

     /**

      * jmuMpUrl的设定

      *

      * @param jmuMpUrl

      *            jmuMpUrl

      */

     public void setJmuMpUrl(String jmuMpUrl) {

         this.jmuMpUrl = jmuMpUrl;

     }

     /**

      * jmuMpDriverClassName的取得

      *

      * @return String jmuMpDriverClassName

      */

     public String getJmuMpDriverClassName() {

         return jmuMpDriverClassName;

     }

     /**

      * jmuMpDriverClassName的设定

      *

      * @param jmuMpDriverClassName

      *            jmuMpDriverClassName

      */

     public void setJmuMpDriverClassName(String jmuMpDriverClassName) {

         this.jmuMpDriverClassName = jmuMpDriverClassName;

     }

     /**

      * jmuMpUsername的取得

      *

      * @return String jmuMpUsername

      */

     public String getJmuMpUsername() {

         return jmuMpUsername;

     }

     /**

      * jmuMpUsername的设定

      *

      * @param jmuMpUsername

      *            jmuMpUsername

      */

     public void setJmuMpUsername(String jmuMpUsername) {

         this.jmuMpUsername = jmuMpUsername;

     }

     /**

      * jmuMpPassword的取得

      *

      * @return String jmuMpPassword

      */

     public String getJmuMpPassword() {

         return jmuMpPassword;

     }

     /**

      * jmuMpPassword的设定

      *

      * @param jmuMpPassword

      *            jmuMpPassword

      */

     public void setJmuMpPassword(String jmuMpPassword) {

         this.jmuMpPassword = jmuMpPassword;

     }

 }

DataSourceConfigCcjoinSettlement.java（使用DBCP2连接池，优先级较低，有tomcat自带JDBC连接池时需要指定数据源类型type）

注意 @ConfigurationProperties注解不支持驼峰式

 package com.jmu.ccjoin.config;

 import javax.sql.DataSource;

 import org.apache.ibatis.session.SqlSessionFactory;

 import org.mybatis.spring.SqlSessionFactoryBean;

 import org.mybatis.spring.annotation.MapperScan;

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

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

 import org.springframework.boot.context.properties.ConfigurationProperties;

 import org.springframework.boot.jdbc.DataSourceBuilder;

 import org.springframework.context.annotation.Bean;

 import org.springframework.context.annotation.Configuration;

 import org.springframework.context.annotation.Primary;

 import org.springframework.core.env.Environment;

 import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

 import org.springframework.jdbc.datasource.DataSourceTransactionManager;

 @Configuration

 @MapperScan(basePackages = "com.jmu.ccjoin.dao.ccjoinSettlement", sqlSessionFactoryRef = "sqlSessionFactoryCcjoinSettlement")

 public class DataSourceConfigCcjoinSettlement {

     @Autowired

     private Environment env;

     @Bean(name = "ccjoinSettlement")

     @ConfigurationProperties(prefix = "spring.datasource.ccjoin-settlement")

     public DataSource dataSourceCcjoinSettlement() {

         // 使用DBCP2数据源(在配置文件配置所使用的数据源类型)

         return DataSourceBuilder.create().build();

     }

     @Bean(name = "sqlSessionFactoryCcjoinSettlement")

     public SqlSessionFactory createSqlSessionFactory(@Qualifier("ccjoinSettlement") DataSource ds) throws Exception {

         SqlSessionFactoryBean fb = new SqlSessionFactoryBean();

         fb.setDataSource(ds);

         fb.setTypeAliasesPackage(env.getProperty("spring.mybatis.typeAliasPackage"));

         fb.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(env.getProperty("spring.mybatis.mapper.ccjoinSettlement")));

         return fb.getObject();

     }

     @Bean(name = "transactionManagerCcjoinSettlement")

     @Primary

     public DataSourceTransactionManager transactionManager(@Qualifier("ccjoinSettlement") DataSource ds) throws Exception {

         return new DataSourceTransactionManager(ds);

     }

 }

DataSourceConfigJmuMp.java（使用第三方数据源阿里连接池Druid）

 package com.jmu.ccjoin.config;

 import javax.sql.DataSource;

 import org.apache.ibatis.session.SqlSessionFactory;

 import org.mybatis.spring.SqlSessionFactoryBean;

 import org.mybatis.spring.annotation.MapperScan;

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

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

 import org.springframework.boot.context.properties.ConfigurationProperties;

 import org.springframework.context.annotation.Bean;

 import org.springframework.context.annotation.Configuration;

 import org.springframework.context.annotation.Primary;

 import org.springframework.core.env.Environment;

 import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

 import org.springframework.jdbc.datasource.DataSourceTransactionManager;

 import com.alibaba.druid.pool.DruidDataSource;

 @Configuration

 @MapperScan(basePackages = "com.jmu.ccjoin.dao.jmuMp",sqlSessionFactoryRef="sqlSessionFactoryJmuMp" )

 public class DataSourceConfigJmuMp {

     @Autowired

     private ConfigProperties configProperties;

     @Autowired

     private Environment env;

     @Bean(name = "jmuMp")

     @ConfigurationProperties(prefix = "spring.datasource.jmu-mp")

     public DataSource dataSourceJmuMp() {

         // 使用Druid连接池

         DruidDataSource ds = new DruidDataSource();

         ds.setUrl(configProperties.getJmuMpUrl());

         ds.setUsername(configProperties.getJmuMpUsername());

         ds.setPassword(configProperties.getJmuMpPassword());

         return ds;

     }

     @Bean(name = "sqlSessionFactoryJmuMp")

     public SqlSessionFactory createSqlSessionFactory(@Qualifier("jmuMp") DataSource ds) throws Exception {

         SqlSessionFactoryBean fb = new SqlSessionFactoryBean();

         fb.setDataSource(ds);

         fb.setTypeAliasesPackage(env.getProperty("spring.mybatis.typeAliasPackage"));

         fb.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(env.getProperty("spring.mybatis.mapper.jmuMp")));

         return fb.getObject();

     }

     @Bean(name = "transactionManagerJmuMp")

     @Primary

     public DataSourceTransactionManager transactionManager(@Qualifier("jmuMp") DataSource ds) throws Exception {

         return new DataSourceTransactionManager(ds);

     }

 }

DataSourceConfigJmuv3.java（使用Tomcat自带的的jdbc连接池）

 package com.jmu.ccjoin.config;

 import javax.sql.DataSource;

 import org.apache.ibatis.session.SqlSessionFactory;

 import org.mybatis.spring.SqlSessionFactoryBean;

 import org.mybatis.spring.annotation.MapperScan;

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

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

 import org.springframework.boot.context.properties.ConfigurationProperties;

 import org.springframework.boot.jdbc.DataSourceBuilder;

 import org.springframework.context.annotation.Bean;

 import org.springframework.context.annotation.Configuration;

 import org.springframework.context.annotation.Primary;

 import org.springframework.core.env.Environment;

 import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

 import org.springframework.jdbc.datasource.DataSourceTransactionManager;

 @Configuration

 @MapperScan(basePackages = "com.jmu.ccjoin.dao.jmuv3", sqlSessionFactoryRef = "sqlSessionFactoryJmuv3")

 public class DataSourceConfigJmuv3 {

     @Autowired

     private Environment env;

     @Bean(name = "jmuv3")

     @Primary

     @ConfigurationProperties(prefix = "spring.datasource.jmuv3")

     public DataSource dataSourceJmuv3() {

         // 使用JDBC数据源

         return DataSourceBuilder.create().build();

     }

     @Bean(name = "sqlSessionFactoryJmuv3")

     @Primary

     public SqlSessionFactory createSqlSessionFactory(@Qualifier("jmuv3") DataSource ds) throws Exception {

         SqlSessionFactoryBean fb = new SqlSessionFactoryBean();

         fb.setDataSource(ds);

         fb.setTypeAliasesPackage(env.getProperty("spring.mybatis.typeAliasPackage"));

         fb.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(env.getProperty("spring.mybatis.mapper.jmuv3")));

         return fb.getObject();

     }

     @Bean(name = "transactionManagerJmuv3")

     @Primary

     public DataSourceTransactionManager transactionManager(@Qualifier("jmuv3") DataSource ds) throws Exception {

         return new DataSourceTransactionManager(ds);

     }

 }

Application.java

 package com.jmu.ccjoin;

 import org.springframework.boot.SpringApplication;

 import org.springframework.boot.autoconfigure.SpringBootApplication;

 import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;

 import org.springframework.boot.builder.SpringApplicationBuilder;

 import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

 @SpringBootApplication(exclude = DataSourceAutoConfiguration.class)

 public class Application extends SpringBootServletInitializer {

     public static void main(String[] args) {

         SpringApplication.run(Application.class, args);

     }

     @Override

     protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {

         return builder.sources(Application.class);

     }

 }

application.yml配置文件

 server:

   port: 20001

   servlet:

     path: /spring-boot

 spring:

   mybatis:

     typeAliasPackage: com.jmu.ccjoin.entity

     mapper:

       jmuv3: classpath:mybatis/mysql/jmuv3/*.xml

       ccjoinSettlement: classpath:mybatis/mysql/ccjoinSettlement/*.xml

       jmuMp: classpath:mybatis/mysql/jmuMp/*.xml

外部配置文件（路径：D:\var\opt\spring-boot-test\config.properties）

 # 数据源1配置

 spring.datasource.jmuv3.jdbc-url=jdbc:mysql://172.16.1.23:3306/jmuv3?useUnicode=true&characterEncoding=utf8

 spring.datasource.jmuv3.driver-class-name=com.mysql.jdbc.Driver

 spring.datasource.jmuv3.username=root

 spring.datasource.jmuv3.password=123.com

 #数据源1的连接池（使用默认即tomcat自带的JDBC连接池）

 # 数据源2配置

 spring.datasource.ccjoin-settlement.jdbc-url=jdbc:mysql://172.16.1.23:3306/ccjoin_settlement?useUnicode=true&characterEncoding=utf8

 spring.datasource.ccjoin-settlement.driver-class-name=com.mysql.jdbc.Driver

 spring.datasource.ccjoin-settlement.username=root

 spring.datasource.ccjoin-settlement.password=123.com

 #数据源2的连接池配置（使用DBCP2连接池，也是springboot支持的连接池之一）

 spring.datasource.ccjoin-settlement.type=org.apache.commons.dbcp2.BasicDataSource

 # 数据源3配置

 spring.datasource.jmu-mp.jdbc-url=jdbc:mysql://172.16.1.23:3306/jmu_mp?useUnicode=true&characterEncoding=utf8

 spring.datasource.jmu-mp.driver-class-name=com.mysql.jdbc.Driver

 spring.datasource.jmu-mp.username=root

 spring.datasource.jmu-mp.password=123.com

 #数据源3的连接池配置（使用第三方数据源，Druid）

 #连接池配置

 spring.datasource.max-wait-millis=10000

 spring.datasource.min-idle=5

 spring.datasource.initial-size=5

 spring.datasource.validation-query=SELECT x

 spring.datasource.connection-properties=characterEncoding=utf8

注意配置文件中配置项后面的空格

springboot 多数据源（三种数据库连接池--JDBC，dbcp2，Druid）的更多相关文章

21Spring_JdbcTemplatem模板工具类的使用——配置文件（连接三种数据库连接池）
上一篇文章提到过DriverManagerDataSource只是Spring内置的数据库连接池,我们可选的方案还有c3p0数据库连接池以及DBCP数据库连接池. 所以这篇文章讲一下上面三种数据库连接 ...
Spring JDBC模版以及三种数据库连接池的使用
jar包版本有点乱,直接忽略版本号,将就一下. 这里引了aop包是因为在spring3版本之后用模版对数据库库操作时会出现问题,但是不会报错,也没有提示. 所以这里直接引入,以及之后会用到的DBCP与 ...
三种数据库连接池的配置及使用（For JDBC）
DBCP 一.导包 Apache官网下载DBCP包,导入两个包路径如下: commons-dbcp-1.4-bin\commons-dbcp-1.4\commons-dbcp-1.4.jar:连接池的 ...
python三种数据库连接池方式
psycopg2.pool – Connections pooling Creating new PostgreSQL connections can be an expensive operatio ...
SpringBoot2 集成三种连接池 c3p0 hikari druid
Hikari 1.首先集成 hikari springboot默认集成,只需要简单的配置即可 1.1 首先导入包 <dependency> <groupId>com.zaxxe ...
JdbcTemplae使用入门&&Spring三种连接池配置&&Spring配置文件引用外部properties文件
JdbcTemplate的使用 Spring为了各种支持的持久化技术,都提供了简单操作的模版和回调. JdbcTemplate 简化 JDBC 操作HibernateTemplate 简化 Hiber ...
JDBC（三）数据库连接池（DBCP、C3P0）
前言这段时间状态有一点浮躁,希望自己静下心来.还有特别多的东西还没有学懂.需要学习的东西非常的多,加油! 一.JDBC复习 Java Data Base Connectivity,java数据库连接 ...
SpringBoot 2.0 中 HikariCP 数据库连接池原理解析
作为后台服务开发,在日常工作中我们天天都在跟数据库打交道,一直在进行各种CRUD操作,都会使用到数据库连接池.按照发展历程,业界知名的数据库连接池有以下几种:c3p0.DBCP.Tomcat JDBC ...
Spring数据访问1 - 数据源配置及数据库连接池的概念
无论你要选择哪种数据访问方式,首先你都需要配置好数据源引用. Spring中配置数据源的几种方式通过在JDBC驱动程序定义的数据源: 通过JNDI查找的数据源: 连接池的数据源: 对于即将发布到生产 ...

随机推荐

linux文件夹作用
linux下的文件结构,看看每个文件夹都是干吗用的/bin 二进制可执行命令 /dev 设备特殊文件 /etc 系统管理和配置文件 /etc/rc.d 启动的配置文件和脚本 /home 用户主目录的基 ...
"Javascript高性能动画与页面渲染"笔记
前言:好久没翻阅我的gmail邮箱了,午休时就打开看了一下,看到InfoQ推荐的一篇名为“Javascript高性能动画与页面渲染”文章,粗略的看了一下,很赞!讲的很详细,对好些细节讲的都很好,很通俗 ...
第一行代码 Android 思维导图
第一行代码 Android 思维导图
ajax中没法用response下载文件啊
ajax 下载不太现实第一,http 不支持直接的二进制传输,二进制数据需要编码例如base64 ,这点服务器端可以实现第二,客户端获得编码后的文件要转换,js应该也可以第三点,最为致命,js无法操 ...
Debian9初始配置
1 进入root用户 su root 2 修改镜像源:编辑/etc/apt/sources.list文件 nano /etc/apt/sources.list 修改内容如下: deb http://m ...
Spring的IoC容器概述
以下内容引用自http://wiki.jikexueyuan.com/project/spring/ioc-containers.html: IoC容器 Spring容器是Spring框架的核心.容器 ...
[转] oracle里long类型的总结
1.LONG 数据类型中存储的是可变长字符串,最大长度限制是2GB. 2.对于超出一定长度的文本,基本只能用LONG类型来存储,数据字典中很多对象的定义就是用LONG来存储的.1.LONG 数据类型中 ...
PHP开发的一些趣事
配置运行环境studyPhp: http://www.phpstudy.net/phpstudy/PhpStudy20180211.zip PHP运行环境:5.4 首先做的是一个表单测试吧 <! ...
用Meta 取消流量器缓存方便调试
 <meta http-equiv="pragram" content="no-cache"& ...
微信小程序项目实战（二）board 首页
1.项目结构 2.页面 (1)数据(逻辑) board.js // pages/board/board.js Page({ /** * 页面的初始数据 */ data: { imgWrap: [] } ...

springboot 多数据源（三种数据库连接池--JDBC，dbcp2，Druid）

springboot 多数据源（三种数据库连接池--JDBC，dbcp2，Druid）的更多相关文章

随机推荐

热门专题