Spring 数据库连接配置

合集下载

SpringBoot配置文件中数据库密码加密两种方案（推荐）

SpringBoot配置⽂件中数据库密码加密两种⽅案（推荐）SpringBoot项⽬经常将连接数据库的密码明⽂放在配置⽂件⾥，安全性就⽐较低⼀些，尤其在⼀些企业对安全性要求很⾼，因此我们就考虑如何对密码进⾏加密。

介绍两种加密⽅式：jasypt 可加密配置⽂件中所有属性值; druid ⾃带了加解密,可对数据库密码进⾏加密。

jasypt 加解密jasypt 是⼀个简单易⽤的加解密Java库，可以快速集成到 Spring 项⽬中。

可以快速集成到 Spring Boot 项⽬中，并提供了⾃动配置，使⽤⾮常简单。

步骤如下：1）引⼊maven依赖<dependency><groupId>com.github.ulisesbocchio</groupId><artifactId>jasypt-spring-boot-starter</artifactId><version>2.1.1</version></dependency>2）在配置⽂件application#jasypt加密的盐值jasypt.encryptor.password=erp3）测试⽤例中⽣成加密后的密匙@AutowiredStringEncryptor encryptor;@Testpublic void getPass() {String url = encryptor.encrypt("jdbc:mysql://127.0.0.1:3306/erp-framework?useUnicode=true&characterEncoding=utf8");String name = encryptor.encrypt("root");String password = encryptor.encrypt("mysql");System.out.println(url+"----------------");System.out.println(name+"----------------");System.out.println(password+"----------------");Assert.assertTrue(name.length() > 0);Assert.assertTrue(password.length() > 0);}执⾏后，会⽣成：BA9uZ35umFic6NbuaLdGzZBodw/wSqvztMt9UGdlOtxxs/fr/W5kf8Bs6GzzHklNfkcU30g8aQ/XdihsZtqRz1J34zNIQxuH3BCG1kknFayp13G8RhkeF4ptBfx6i6nqnP4Uc0UKpjcsxxfTZImHBVvcTY0RDANk26IGB kyMvAncHqzcvGAildsK67w==7QCSL5/HKjxFQRPLGgGH7kAElrmf/mgQ4）将上⾯的⽣成的密匙如下替换，此处主要是数据库密码密⽂使⽤ENC进⾏标识first.spring.datasource.password=ENC(7QCSL5/HKjxFQRPLGgGH7kAElrmf/mgQ)ENC( )是固定写法，( )⾥⾯是加密后的信息。

Spring ibatis jta多数据源配置

Spring+iBatis+JOTM实现JTA事务JOTM是个开源的JTA事务管理组件，可以让程序脱离J2EE容器而获得分布式事务管理的能力。

测试过程如下：一、环境1、准备软件环境spring-framework-2.5.6.SEC01-with-dependencies.zipibatis-2.3.4ow2-jotm-dist-2.1.4-bin.tar.gzMySQL-5.1JDK1.52、创建数据库环境，注意数据库引擎为InnoDB，只有这样才能支持事务。

CREATE DATABASE IF NOT EXISTS testdb_a DEFAULT CHARACTER SET utf8;USE testdb_a;DROP TABLE IF EXISTS tab_a;CREATE TABLE tab_a (id bigint(20) NOT NULL,name varchar(60) DEFAULT NULL,address varchar(120) DEFAULT NULL,PRIMARY KEY (id)) ENGINE=InnoDB DEFAULT CHARSET=utf8;CREATE DATABASE IF NOT EXISTS testdb_b DEFAULT CHARACTER SET utf8;USE testdb_b;DROP TABLE IF EXISTS tab_b;CREATE TABLE tab_b (id bigint(20) NOT NULL,name varchar(60) DEFAULT NULL,address varchar(120) DEFAULT NULL,PRIMARY KEY (id)) ENGINE=InnoDB DEFAULT CHARSET=utf8;二、建立项目testJOTM1、建立项目后，准备依赖的类库，结构如下：│spring-aop.jar│spring-beans.jar│spring-context-support.jar│spring-context.jar│spring-core.jar│spring-jdbc.jar│spring-jms.jar│spring-orm.jar│spring-test.jar│spring-tx.jar│spring-web.jar│spring-webmvc-portlet.jar│spring-webmvc-struts.jar│spring-webmvc.jar│aspectjrt.jar│aspectjweaver.jar│cglib-nodep-2.1_3.jar│asm-2.2.3.jar│log4j-1.2.15.jar│asm-commons-2.2.3.jar│asm-util-2.2.3.jar│aopalliance.jar│mysql-connector-java-5.1.6-bin.jar│├─ibatis│ibatis-2.3.4.726.jar│sql-map-2.dtd│sql-map-config-2.dtd│├─jotm│license.txt│xapool.jar│jotm-core.jar│jotm-standalone.jar│jotm-jms.jar│jotm-datasource.jar│ow2-jta-1.1-spec.jar│jotm-client.jar│├─jakarta-commons│commons-attributes-api.jar│commons-attributes-compiler.jar│commons-beanutils.jar│commons-codec.jar│commons-collections.jar│commons-dbcp.jar│commons-digester.jar│commons-discovery.jar│commons-fileupload.jar│commons-httpclient.jar│commons-io.jar│commons-lang.jar│commons-logging.jar│commons-pool.jar│commons-validator.jar│├─junit│junit-3.8.2.jar│junit-4.4.jar│license.txt│└─log4jlog4j-1.2.15.jar2、根据表建立entity和SQLMappublic class TabA implements Serializable {private Long id;private String name;private String address;//省略getter/setterpublic class TabB implements Serializable {private Long id;private String name;private String address;//省略getter/setterTabA.xml<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE sqlMap PUBLIC "-////DTD SQL Map 2.0//EN" "/dtd/sql-map-2.dtd" ><sqlMap namespace="tab_a"><typeAlias alias="TabA" type="vasoft.stu.jtom.entity.TabA"/><resultMap id="result_base" class="TabA"><result property="id" column="id"/><result property="name" column="name"/><result property="address" column="address"/></resultMap><insert id="insert" parameterClass="TabA">insert into tab_a(id,name,address) values (#id#,#name#,#address#)<selectKey keyProperty="id" resultClass="long">select LAST_INSERT_ID()</selectKey></insert><update id="update" parameterClass="TabA">update tab_a setid = #id#,name = #name#,address = #address#where id = #id#</update><delete id="deleteById" parameterClass="long">delete from tab_awhere id = #value#</delete><select id="findById" parameterClass="long" resultMap="tab_a.result_base">select *from tab_awhere id = #value#</select></sqlMap>TabB.xml<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE sqlMap PUBLIC "-////DTD SQL Map 2.0//EN" "/dtd/sql-map-2.dtd" ><sqlMap namespace="tab_b"><typeAlias alias="TabB" type="vasoft.stu.jtom.entity.TabB"/><resultMap id="result_base" class="TabB"><result property="id" column="id"/><result property="name" column="name"/><result property="address" column="address"/></resultMap><insert id="insert" parameterClass="TabB">insert into tab_b(id,name,address) values (#id#,#name#,#address#)<selectKey keyProperty="id" resultClass="long">select LAST_INSERT_ID()</selectKey></insert><update id="update" parameterClass="TabB">update tab_b setid = #id#,name = #name#,address = #address#where id = #id#</update><delete id="deleteById" parameterClass="long">delete from tab_bwhere id = #value#</delete><select id="findById" parameterClass="long" resultMap="tab_b.result_base"> select *from tab_bwhere id = #value#</select></sqlMap>/*** TabADAO** @author leizhimin 2009-6-25 12:39:19*/public interface TabADAO {/*** 保存一个TabA对象** @param tabA TabA对象* @return 返回保存后的对象*/TabA saveTabA(TabA tabA);/*** 更新一个TabA** @param tabA TabA对象* @return 返回更新后的对象*/TabA updateTabA(TabA tabA);/*** 删除指定标识的一个TabA** @param id TabA标识*/void deleteTabAById(Long id);/*** 获取指定标识的TabA** @param id TabA标识* @return 所查询到的TabA*/TabA findTabAById(Long id);}/*** TabADAO** @author leizhimin 2009-6-25 12:43:55*/public class TabADAOImpl extends SqlMapClientDaoSupport implements TabADAO {/*** 保存一个TabA对象** @param tabA TabA对象* @return 返回保存后的对象*/public TabA saveTabA(TabA tabA) {Long id = (Long) getSqlMapClientTemplate().insert("tab_a.insert", tabA);tabA.setId(id);return tabA;}/*** 更新一个TabA** @param tabA TabA对象* @return 返回更新后的对象*/public TabA updateTabA(TabA tabA) {getSqlMapClientTemplate().update("tab_a.update", tabA);return tabA;}/*** 删除指定标识的一个TabA** @param id TabA标识*/public void deleteTabAById(Long id) {getSqlMapClientTemplate().delete("tab_a.deleteById",id);}/*** 获取指定标识的TabA** @param id TabA标识* @return 所查询到的TabA*/public TabA findTabAById(Long id) {return (TabA) getSqlMapClientTemplate().queryForObject("tab_a.findById",id);}}B的DAO和A类似，就不写了。

JAVA使用技巧：使用ORM框架简化数据库操作

JAVA使用技巧：使用ORM框架简化数据库操作引言：在软件开发领域，数据库操作是一个非常重要的环节。

传统的数据库操作方式需要编写大量的SQL语句，对于开发人员来说，这无疑增加了开发的复杂度和难度。

为了简化数据库操作，提高开发效率，ORM（Object-Relational Mapping）框架应运而生。

本文将介绍使用ORM框架简化数据库操作的技巧和方法。

一、什么是ORM框架ORM框架是一种将对象模型与关系数据库之间进行映射的技术。

它能够自动将数据库中的表和字段映射为对象和属性，从而实现对象和数据库的无缝交互。

ORM框架的出现，极大地简化了数据库操作，提高了开发效率。

二、为什么使用ORM框架1. 简化开发：使用ORM框架可以避免手写大量的SQL语句，开发人员只需要关注业务逻辑和对象操作，大大减少了代码量和开发难度。

2. 提高可维护性：ORM框架将数据库操作封装在框架内部，使得代码更加清晰、易于理解和维护。

3. 跨数据库支持：ORM框架通常支持多种数据库，开发人员无需关心具体的数据库实现细节，提高了代码的可移植性。

4. 性能优化：ORM框架通常会提供缓存、批量操作等性能优化机制，提高了数据库操作的效率。

三、常用的ORM框架1. Hibernate：Hibernate是一个开源的ORM框架，它是Java领域最流行的ORM框架之一。

Hibernate提供了丰富的功能和灵活的配置，支持多种数据库，是开发人员的首选。

2. MyBatis：MyBatis是另一个流行的ORM框架，它与Hibernate相比更加轻量级，适用于对SQL语句有更高要求的开发人员。

3. Spring Data JPA：Spring Data JPA是Spring框架提供的一种简化数据库访问的方式，它基于JPA（Java Persistence API）标准，提供了一套简单易用的API，可以快速实现数据库操作。

四、使用ORM框架的基本步骤1. 引入依赖：首先需要在项目中引入相应的ORM框架依赖。

SpringBoot整合Druid实现数据库连接池和监控

SpringBoot整合Druid实现数据库连接池和监控⽬录1、Druid的简介2、创建SpringBoot项⽬与数据表2.1 创建项⽬2.2 创建数据表3、Druid实现数据库连接池3.1 Druid的配置3.2 创建实体类（Entity层）3.3 数据库映射层（Mapper层）3.4 业务逻辑层（Service层）3.5 控制器⽅法（Controller层）3.6 显⽰页⾯（View层）4、Druid实现监控功能1、Druid的简介Druid是Java语⾔中使⽤的⽐较多的数据库连接池。

Druid还提供了强⼤的监控和扩展功能。

下⾯将介绍SpringBoot整合Druid实现数据库连接池和监控功能。

官⽅⽂档：《》2、创建SpringBoot项⽬与数据表【实例】SpringBoot整合Druid实现数据库连接池和监控，使⽤MyBaits操作数据库，获取⽤户信息，如下图：2.1 创建项⽬（1）创建SpringBoot项⽬，项⽬结构如下图：（2）使⽤Maven添加依赖⽂件在pom.xml配置信息⽂件中，添加Druid连接池、MyBatis、MySQL数据库、Thymeleaf模板引擎等相关依赖：<dependency><groupId>com.alibaba</groupId><artifactId>druid-spring-boot-starter</artifactId><version>1.1.23</version></dependency><dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>2.1.3</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.20</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-thymeleaf</artifactId></dependency>2.2 创建数据表使⽤MySQL数据库，创建 tb_user ⽤户信息表，并添加数据。

SpringMVC+Spring+Mybatis框架配置详细步骤(eclipse普通版)

SSI框架搭建SpringMVC3.1.2+Spring3.1.2+Mybatis3.2.6编号：SSI-SMVC3-S3-I3版本：V1.0级别：公开编写时间：2016-02-17目录1 导言 (1)1.1 目的 (1)1.2 范围 (1)1.3 说明 (1)2 搭建SpringMVC (2)2.1 搭建所需jar包 (2)2.2 其他依赖包 (3)2.3 搭建步骤 (4)2.3.1 创建项目 (4)2.3.2 导入jar包 (6)2.3.3 配置web.xml (7)2.3.4 配置spring-servlet.xml (9)2.3.5 配置applicationContext.xml (10)2.3.6 配置log4j.properties (10)3 整合mybatis (11)3.1 整合所需jar包 (11)3.2 其他依赖包 (11)3.3 整合步骤 (11)3.3.1 导入jar包 (11)3.3.2 配置config.properties (12)3.3.3 配置spring-dataSource.xml (12)3.3.4 配置applicationContext.xml (15)3.3.5 配置mybatis-config.xml (16)3.3.6 创建实体model (17)3.3.7 创建实例化dao (19)3.3.8 创建业务服务service (21)3.3.9 创建控制层controller (23)3.3.10 页面代码 (28)3.3.11 启动项目 (37)1导言1.1 目的本文档是根据个人的工作经验搭建的轻量级SSI框架，也是实际应用中比较全面的基础框架，用于指导SSI框架初学者学习搭建SSI框架，希望能给各位使用者提供帮助，同时也希望朋友们尽量去帮助其他人。

1.2 范围本次框架搭建的版本是SpringMVC3.1.2+Spring3.1.2+Mybatis3.2.6，数据库采用的是mysql，在eclipse开发工具下搭建直接搭建的web项目，页面采用的是h5，ajax实现数据访问，如果页面为jsp等，则修改controller的返回类型即可。

spring中的数据库配置

spring中的数据库配置spring中的数据库配置1.使⽤org.springframework.jdbc.datasource.DriveManagerDataSource1 <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">2 <property name="driverClassName">3 <value>${jdbc.driverClassName}</value>4 </property>5 <property name="url">6 <value>${jdbc.url}</value>7 </property>8 <property name="username">9 <value>${ername}</value>10 </property>11 <property name="password">12 <value>${jdbc.password}</value>13 </property>14 </bean>说明：DriverManagerDataSource建⽴连接是只要能建⽴连接就新建⼀个connection，根本没有连接池的概念。

2.使⽤org.springframework.jndi.JndiObjectFactoryBean1 <bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">2 <property name="jndiName">3 <value>java:comp/env/jdbc/roseindiaDB_local</value>4 </property>5 </bean>说明：JndiObjectFactoryBean能够通过JNDI获取DataSource,但是这种⽅式需要在web服务器中配置数据源，⽐如在tomcat的server.xml处配置数据源。

springboot配置文件里部分配置未生效的解决

springboot配置⽂件⾥部分配置未⽣效的解决springboot 配置⽂件⾥部分配置未⽣效最近⽤springboot搭了个项⽬，上线过段时间就会出现卡死，猜测是数据库连接池的连接被占满，⽤的连接池是druid，于是给项⽬加上了⼀个数据库连接池监控。

代码如下：@Configurationpublic class DruidConfiguration {/**** 注册⼀个StatViewServlet** @return**/@Beanpublic ServletRegistrationBean DruidStatViewServle2() {// org.springframework.boot.context.embedded.ServletRegistrationBean提供类的进⾏注册.ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new StatViewServlet(),"/druid/*");// 添加初始化参数：initParams// ⽩名单：// servletRegistrationBean.addInitParameter("allow", "127.0.0.1");// IP⿊名单 (存在共同时，deny优先于allow) : 如果满⾜deny的话提⽰:Sorry, you are not// permitted to view this page.// servletRegistrationBean.addInitParameter("deny", "192.168.1.73");// 登录查看信息的账号密码.servletRegistrationBean.addInitParameter("loginUsername", "admin");servletRegistrationBean.addInitParameter("loginPassword", "admin");// 是否能够重置数据.servletRegistrationBean.addInitParameter("resetEnable", "false");return servletRegistrationBean;}/**** 注册⼀个：filterRegistrationBean** @return**/@Beanpublic FilterRegistrationBean druidStatFilter2() {FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(new WebStatFilter());// 添加过滤规则.filterRegistrationBean.addUrlPatterns("/*");// 添加不需要忽略的格式信息.filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid2/*");return filterRegistrationBean;}}于是重启项⽬，进⼊监控页⾯发现与配置⽂件⾥⾯的部分配置对应不上，当时也没在意，以为是显⽰的默认配置。

springboot配置mysql数据库spring.datasource.url报错的解决

springboot配置mysql数据库spring.datasource.url报错的解决⽬录springboot配置mysql数据库spring.datasource.url报错springboot下datasource连接配置基本设置datasourceJPAjooqh2JTAspringboot配置mysql数据库spring.datasource.url报错spring.datasource.url=jdbc:mysql://abc:3306/abcd?useUnicode=true&characterEncoding=utf8很常规地配置了这个mysql的url后发现报错Wed Oct 24 14:59:16 CST 2018 WARN: Establishing SSL connection without server's identity verification is notrecommended. According to MySQL 5.5.45+, 5.6.26+ and 5.7.6+ requirements SSL connection must beestablished by default if explicit option isn't set. For compliance with existing applications not using SSL theverifyServerCertificate property is set to 'false'. You need either to explicitly disable SSL by setting useSSL=false, or set useSSL=true and provide truststore for server certificate verification.根据介绍，这⾥需要在URL那指定useSSL这个属性然后试过useSSL=truespring.datasource.url=jdbc:mysql://abc:3306/abcd?useUnicode=true&characterEncoding=utf8&useSSL=true⼜报了⼀个错Caused by: java.security.cert.CertificateException: java.security.cert.CertPathValidatorException: Path does not chain with any of the trust anchorsatcom.mysql.jdbc.ExportControlled$X509TrustManagerWrapper.checkServerTrusted(ExportControlled.java:302)at sun.security.ssl.AbstractTrustManagerWrapper.checkServerTrusted(SSLContextImpl.java:984)at sun.security.ssl.ClientHandshaker.serverCertificate(ClientHandshaker.java:1496)... 31 common frames omittedCaused by: java.security.cert.CertPathValidatorException: Path does not chain with any of the trust anchorsat sun.security.provider.certpath.PKIXCertPathValidator.validate(PKIXCertPathValidator.java:153)at sun.security.provider.certpath.PKIXCertPathValidator.engineValidate(PKIXCertPathValidator.java:79)at java.security.cert.CertPathValidator.validate(CertPathValidator.java:292)atcom.mysql.jdbc.ExportControlled$X509TrustManagerWrapper.checkServerTrusted(ExportControlled.java:295)... 33 common frames omitted没有证书设置的话这⾥只能useSSL=false最终这样设置spring.datasource.url=jdbc:mysql://abc:3306/abcd?useUnicode=true&characterEncoding=utf8&useSSL=falsespringboot下datasource连接配置基本设置spring.datasource.secondary.url=jdbc:mysql://localhost:3306/test2?useUnicode=true&characterEncoding=utf-8ername=testspring.datasource.secondary.password=123456spring.datasource.secondary.driver-class-name=com.mysql.jdbc.Driver#验证连接的有效性spring.datasource.secondary.test-while-idle=true#获取连接时候验证，会影响性能spring.datasource.secondary.test-on-borrow=false#在连接归还到连接池时是否测试该连接spring.datasource.secondary.test-on-return=falsespring.datasource.secondary.validation-query=SELECT 1 FROM DUAL#空闲连接回收的时间间隔，与test-while-idle⼀起使⽤，设置5分钟spring.datasource.secondary.time-between-eviction-runs-millis=300000#连接池空闲连接的有效时间，设置30分钟spring.datasource.secondary.min-evictable-idle-time-millis=1800000spring.datasource.secondary.initial-size=5#指定连接池中最⼤的活跃连接数.spring.datasource.secondary.max-active=50#指定连接池等待连接返回的最⼤等待时间，毫秒单位.spring.datasource.secondary.max-wait=60000#指定必须保持连接的最⼩值spring.datasource.secondary.min-idle=5datasourcespring.dao.exceptiontranslation.enabled是否开启PersistenceExceptionTranslationPostProcessor，默认为true spring.datasource.abandon-when-percentage-full设定超时被废弃的连接占到多少⽐例时要被关闭或上报spring.datasource.allow-pool-suspension使⽤Hikari pool时，是否允许连接池暂停，默认为: falsespring.datasource.alternate-username-allowed是否允许替代的⽤户名.spring.datasource.auto-commit指定updates是否⾃动提交.spring.datasource.catalog指定默认的catalog.mit-on-return设置当连接被归还时，是否要提交所有还未完成的事务spring.datasource.connection-init-sql指定连接被创建，再被添加到连接池之前执⾏的sql.spring.datasource.connection-init-sqls使⽤DBCP connection pool时，指定初始化时要执⾏的sqlspring.datasource.connection-properties.[key]在使⽤DBCP connection pool时指定要配置的属性spring.datasource.connection-test-query指定校验连接合法性执⾏的sql语句spring.datasource.connection-timeout指定连接的超时时间，毫秒单位.spring.datasource.continue-on-error在初始化数据库时，遇到错误是否继续，默认falsespring.datasource.data指定Data (DML)脚本spring.datasource.data-source-class-name指定数据源的全限定名.spring.datasource.data-source-jndi指定jndi的地址spring.datasource.data-source-properties.[key]使⽤Hikari connection pool时，指定要设置的属性spring.datasource.db-properties使⽤Tomcat connection pool，指定要设置的属性spring.datasource.default-auto-commit是否⾃动提交.spring.datasource.default-catalog指定连接默认的catalog.spring.datasource.default-read-only是否设置默认连接只读.spring.datasource.default-transaction-isolation指定连接的事务的默认隔离级别.spring.datasource.driver-class-name指定driver的类名，默认从jdbc url中⾃动探测.spring.datasource.fair-queue是否采⽤FIFO返回连接.spring.datasource.health-check-properties.[key]使⽤Hikari connection pool时，在⼼跳检查时传递的属性spring.datasource.idle-timeout指定连接多久没被使⽤时，被设置为空闲，默认为10msspring.datasource.ignore-exception-on-pre-load当初始化连接池时，是否忽略异常.spring.datasource.init-sql当连接创建时，执⾏的sqlspring.datasource.initial-size指定启动连接池时，初始建⽴的连接数量spring.datasource.initialization-fail-fast当创建连接池时，没法创建指定最⼩连接数量是否抛异常spring.datasource.initialize指定初始化数据源，是否⽤data.sql来初始化，默认: truespring.datasource.isolate-internal-queries指定内部查询是否要被隔离，默认为falsespring.datasource.jdbc-interceptors使⽤Tomcat connection pool时，指定jdbc拦截器，分号分隔spring.datasource.jdbc-url指定JDBC URL.spring.datasource.jmx-enabled是否开启JMX，默认为: falsespring.datasource.jndi-name指定jndi的名称.spring.datasource.leak-detection-threshold使⽤Hikari connection pool时，多少毫秒检测⼀次连接泄露.spring.datasource.log-abandoned使⽤DBCP connection pool，是否追踪废弃statement或连接，默认为: false spring.datasource.log-validation-errors当使⽤Tomcat connection pool是否打印校验错误.spring.datasource.login-timeout指定连接数据库的超时时间.spring.datasource.max-active指定连接池中最⼤的活跃连接数.spring.datasource.max-age指定连接池中连接的最⼤年龄spring.datasource.max-idle指定连接池最⼤的空闲连接数量.spring.datasource.max-lifetime指定连接池中连接的最⼤⽣存时间，毫秒单位.spring.datasource.max-open-prepared-statements指定最⼤的打开的prepared statements数量.spring.datasource.max-wait指定连接池等待连接返回的最⼤等待时间，毫秒单位.spring.datasource.maximum-pool-size指定连接池最⼤的连接数，包括使⽤中的和空闲的连接.spring.datasource.min-evictable-idle-time-millis指定⼀个空闲连接最少空闲多久后可被清除.spring.datasource.min-idle指定必须保持连接的最⼩值(For DBCP and Tomcat connection pools)spring.datasource.minimum-idle指定连接维护的最⼩空闲连接数，当使⽤HikariCP时指定.指定数据源名.spring.datasource.num-tests-per-eviction-run指定运⾏每个idle object evictor线程时的对象数量spring.datasource.password指定数据库密码.spring.datasource.platform指定schema要使⽤的Platform(schema-${platform}.sql)，默认为:allspring.datasource.pool-name指定连接池名字.spring.datasource.pool-prepared-statements指定是否池化statements.spring.datasource.propagate-interrupt-state在等待连接时，如果线程被中断，是否传播中断状态.spring.datasource.read-only当使⽤Hikari connection pool时，是否标记数据源只读spring.datasource.register-mbeans指定Hikari connection pool是否注册JMX MBeans.spring.datasource.remove-abandoned指定当连接超过废弃超时时间时，是否⽴刻删除该连接.spring.datasource.remove-abandoned-timeout指定连接应该被废弃的时间.spring.datasource.rollback-on-return在归还连接时，是否回滚等待中的事务.spring.datasource.schema指定Schema (DDL)脚本.spring.datasource.separator指定初始化脚本的语句分隔符，默认: ;spring.datasource.sql-script-encoding指定SQL scripts编码.spring.datasource.suspect-timeout指定打印废弃连接前的超时时间.spring.datasource.test-on-borrow当从连接池借⽤连接时，是否测试该连接.spring.datasource.test-on-connect创建时，是否测试连接spring.datasource.test-on-return在连接归还到连接池时是否测试该连接.spring.datasource.test-while-idle当连接空闲时，是否执⾏连接测试.spring.datasource.time-between-eviction-runs-millis指定空闲连接检查、废弃连接清理、空闲连接池⼤⼩调整之间的操作时间间隔spring.datasource.transaction-isolation指定事务隔离级别，使⽤Hikari connection pool时指定spring.datasource.url指定JDBC URL.e-disposable-connection-facade是否对连接进⾏包装，防⽌连接关闭之后被使⽤.e-equals⽐较⽅法名时是否使⽤String.equals()替换==.e-lock是否对连接操作加锁ername指定数据库名.spring.datasource.validation-interval指定多少ms执⾏⼀次连接校验.spring.datasource.validation-query指定获取连接时连接校验的sql查询语句.spring.datasource.validation-query-timeout指定连接校验查询的超时时间.spring.datasource.validation-timeout设定连接校验的超时时间，当使⽤Hikari connection pool时指定spring.datasource.validator-class-name⽤来测试查询的validator全限定名.spring.datasource.xa.data-source-class-name指定数据源的全限定名.spring.datasource.xa.properties指定传递给XA data source的属性JPAspring.jpa.database指定⽬标数据库.spring.jpa.database-platform指定⽬标数据库的类型.spring.jpa.generate-ddl是否在启动时初始化schema，默认为falsespring.jpa.hibernate.ddl-auto指定DDL mode (none, validate, update, create, create-drop). 当使⽤内嵌数据库时，默认是create-drop，否则为none.spring.jpa.hibernate.naming-strategy指定命名策略.spring.jpa.open-in-view是否注册OpenEntityManagerInViewInterceptor，绑定JPAEntityManager到请求线程中，默认为: true spring.jpa.properties添加额外的属性到JPA provider.spring.jpa.show-sql是否开启sql的log，默认为: falsejooqspring.jooq.sql-dialect指定JOOQ使⽤的SQLDialect，⽐如POSTGRES.h2spring.h2.console.enabled是否开启控制台，默认为falsespring.h2.console.path指定控制台路径，默认为: /h2-consoleJTAspring.jta.allow-multiple-lrc是否允许 multiple LRC，默认为: falsespring.jta.asynchronous2-pc指定两阶段提交是否可以异步，默认为: falsespring.jta.background-recovery-interval指定多少分钟跑⼀次recovery process，默认为: 1spring.jta.background-recovery-interval-seconds指定多久跑⼀次recoveryprocess，默认: 60spring.jta.current-node-only-recovery是否过滤掉其他⾮本JVM的recovery，默认为: truespring.jta.debug-zero-resource-transaction是否追踪没有使⽤指定资源的事务，默认为: falsespring.jta.default-transaction-timeout设定默认的事务超时时间，默认为60spring.jta.disable-jmx是否禁⽤jmx，默认为falsespring.jta.enabled是否开启JTA support，默认为: truespring.jta.exception-analyzer设置指定的异常分析类spring.jta.filter-log-status使⽤Bitronix Transaction Manager时，是否写mandatory logs，开启的话，可以节省磁盘空间，但是调试会复杂写，默认为falsespring.jta.force-batching-enabled使⽤Bitronix Transaction Manager时，是否批量写磁盘，默认为true.spring.jta.forced-write-enabled使⽤Bitronix Transaction Manager时，是否强制写⽇志到磁盘，默认为truespring.jta.graceful-shutdown-interval当使⽤Bitronix Transaction Manager，指定shutdown时等待事务结束的时间，超过则中断，默认为60spring.jta.jndi-transaction-synchronization-registry-name当使⽤BitronixTransaction Manager时，在JNDI下得事务同步registry，默认为:java:comp/TransactionSynchronizationRegistryspring.jta.jndi-user-transaction-name指定在JNDI使⽤Bitronix Transaction Manager的名称，默认:java:comp/UserTransaction spring.jta.journal当使⽤Bitronix Transaction Manager，指定The journal是否disk还是null还是⼀个类的全限定名，默认disk spring.jta.log-dirTransaction logs directory.spring.jta.log-part1-filename指定The journal fragment⽂件1的名字，默认: btm1.tlogspring.jta.log-part2-filename指定The journal fragment⽂件2的名字，默认: btm2.tlogspring.jta.max-log-size-in-mb指定journal fragments⼤⼩的最⼤值. 默认: 2Mspring.jta.resource-configuration-filename指定Bitronix Transaction Manager配置⽂件名.spring.jta.server-id指定Bitronix Transaction Manager实例的id.spring.jta.skip-corrupted-logs是否忽略corrupted log files⽂件，默认为false.spring.jta.transaction-manager-id指定Transaction manager的唯⼀标识.jta.warn-about-zero-resource-transaction当使⽤Bitronix Transaction Manager时，是否对没有使⽤指定资源的事务进⾏警告，默认为: true以上为个⼈经验，希望能给⼤家⼀个参考，也希望⼤家多多⽀持。

SpringBoot多数据库连接（mysql+oracle）的实现

SpringBoot多数据库连接（mysql+oracle）的实现出于业务需求，有时我们需要在spring boot web应⽤程序中配置多个数据源并连接到多个数据库。

使⽤过Spring Boot框架的⼩伙伴们，想必都发现了Spring Boot对JPA提供了⾮常好的⽀持，在开发过程中可以很简洁的代码轻松访问数据库，获取我们想要的数据。

因此在这⾥，使⽤Spring Boot和JPA配置多个数据源的场景。

项⽬配置在本⽂中，主要使⽤两个不同的数据库，分别为：mysql(springboot)【primary，优先搜寻该数据库】：mysql数据库，包含User的信息oracle(springboot): oracle数据库，包含Country信息项⽬依赖为了⽀持Mysql和Oracle数据库，我们必须要在pom.xml⽂件中添加相应的依赖。

<dependencies><dependency><groupId>com.oracle</groupId><artifactId>ojdbc6</artifactId><version>11.2.0.3.0</version><scope>compile</scope></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jpa</artifactId></dependency><dependency><groupId>javax.persistence</groupId><artifactId>javax.persistence-api</artifactId><version>2.2</version></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.18.12</version></dependency></dependencies>包管理为了⽅便代码的开发，我们将mysql和oracle分开放在两个不同的package下⾯，具体的包结构如下：将不同的模型分开放⼊mysql和oracle包⽬录下，需要注意的是，mysql和oracle为两个不同的数据库，所以两个数据库中可能存在某个表名称⼀致的场景。

Spring2连接多数据库,实现读写分离

Spring2连接多数据库，实现读写分离Spring2.0.1以后的版本已经支持配置多数据源，并且可以在运行的时候动态加载不同的数据源。

通过继承AbstractRoutingDataSource就可以实现多数据源的动态转换。

目前做的项目就是需要访问2个数据源，每个数据源的表结构都是相同的，所以要求数据源的变动对于编码人员来说是透明，也就是说同样SQL语句在不同的环境下操作的数据库是不一样的。

具体的流程如下：一、建立一个获得和设置上下文的类package com.lvye.base.dao.impl.jdbc;/**连接哪个数据源的环境变量* @author wenc*/public class JdbcContextHolder {private static final ThreadLocal<String> contextHolder = new ThreadLocal<String>();public static void setJdbcType(String jdbcType) {contextHolder.set(jdbcType);}public static void setSlave(){setJdbcType("slave");}public static void setMaster(){clearJdbcType();}public static String getJdbcType() {return (String) contextHolder.get();}public static void clearJdbcType() {contextHolder.remove();}}二、建立动态数据源类，这个类必须继承AbstractRoutingDataSourcepackage com.lvye.base.dao.impl.jdbc;import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;public class DynamicDataSource extends AbstractRoutingDataSource{/* (non-Javadoc)* @see org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource#determineCurrentLook upKey()* @author wenc*/@Overrideprotected Object determineCurrentLookupKey() {return JdbcContextHolder.getJdbcType();}}这个类实现了determineCurrentLookupKey方法，该方法返回一个Object，一般是返回字符串。

springboot配置MySQL数据库连接、Hikari连接池和Mybatis的简单配置方法

springboot配置MySQL数据库连接、Hikari连接池和Mybatis的简单配置⽅法此⽅法为极简配置，⽀持MySQL数据库多库连接、⽀持Hikari连接池、⽀持MyBatis（包括Dao类和xml⽂件位置的配置）。

1、pom.xml中引⼊依赖：<dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>1.1.1</version><exclusions><exclusion><groupId>org.apache.tomcat</groupId><artifactId>tomcat-jdbc</artifactId></exclusion></exclusions></dependency><dependency><groupId>com.zaxxer</groupId><artifactId>HikariCP</artifactId></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId></dependency>我们使⽤了mybatis-spring-boot-starter，并让它把tomcat-jdbc连接池排除掉，这样spring-boot就会寻找是否有HikariCP可⽤，第⼆个依赖就被找到了，然后mysql-connector也有了。

SpringBoot数据库连接池参数

SpringBoot数据库连接池参数Tomcat JDBC 连接池Spring Boot 默认选择 Tomcat JDBC Pool 作为数据库连接池。

Tomcat（8）连接池常⽤的属性：属性描述默认值defaultAutoCommit连接池中创建的连接默认是否⾃动提交事务驱动的缺省值defaultReadOnly连接池中创建的连接默认是否为只读状态-defaultCatalog连接池中创建的连接默认的 catalog-driverClassName驱动类的名称-username数据库账户-password数据库密码-maxActive连接池同⼀时间可分配的最⼤活跃连接数100maxIdle始终保留在池中的最⼤连接数，如果启⽤，将定期检查限制连接，超出此属性设定的值且空闲时间超过minEvictableIdleTimeMillis的连接则释放与maxActive设定的值相同minIdle始终保留在池中的最⼩连接数，池中的连接数量若低于此值则创建新的连接，如果连接验证失败将缩⼩⾄此值与initialSize设定的值相同initialSize连接池启动时创建的初始连接数量10maxWait最⼤等待时间（毫秒），如果在没有连接可⽤的情况下等待超过此时间，则抛出异常30000（30秒）testOnBorrow当从连接池中取出⼀个连接时是否进⾏验证，若验证失败则从池中删除该连接并尝试取出另⼀个连接false testOnConnect当⼀个连接⾸次被创建时是否进⾏验证，若验证失败则抛出 SQLException 异常false testOnReturn当⼀个连接使⽤完归还到连接池时是否进⾏验证false testWhileIdle对池中空闲的连接是否进⾏验证，验证失败则回收此连接false validationQuery在连接池返回连接给调⽤者前⽤来对连接进⾏验证的查询 SQL null validationQueryTimeout SQL 查询验证超时时间（秒），⼩于或等于 0 的数值表⽰禁⽤-1timeBetweenEvictionRunsMillis在空闲连接回收器线程运⾏期间休眠时间（毫秒），该值不应该⼩于 1 秒，它决定线程多久验证空闲连接或丢弃连接的频率5000（5秒）minEvictableIdleTimeMillis连接在池中保持空闲⽽不被回收的最⼩时间（毫秒）60000（60秒）removeAbandoned标记是否删除泄露的连接，如果连接超出removeAbandonedTimeout的限制，且该属性设置为 true，则连接被认为是被泄露并且可以被删除falseremoveAbandonedTimeout泄露的连接可以被删除的超时时间（秒），该值应设置为应⽤程序查询可能执⾏的最长时间60# src/main/resources/application.properties1 2 3 4 5 6 7 8 9 10 11spring.datasource.url=jdbc:mysql://127.0.0.1/spring_boot_testing_storage ername=rootspring.datasource.password=rootspring.datasource.driver-class-name=com.mysql.jdbc.Driverspring.datasource.tomcat.default-auto-commit=truespring.datasource.tomcat.initial-size=3spring.datasource.tomcat.max-active=120spring.datasource.tomcat.max-wait=10000spring.datasource.tomcat.test-on-borrow=truespring.datasource.tomcat.test-while-idle=truespring.datasource.tomcat.validation-query=SELECT 111 12 13 14 15 16spring.datasource.tomcat.validation-query=SELECT 1spring.datasource.tomcat.validation-query-timeout=3spring.datasource.tomcat.time-between-eviction-runs-millis=10000 spring.datasource.tomcat.min-evictable-idle-time-millis=120000 spring.datasource.tomcat.remove-abandoned=truespring.datasource.tomcat.remove-abandoned-timeout=120Spring Boot Data Jpa 依赖声明：# pom.xml1 2 3 4<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jpa</artifactId> </dependency>HikariCP 连接池Spring Boot 如果发现 Tomcat 连接池不可⽤，则尝试选择 HikariCP 作为默认连接池。

Springboot默认数据源Hikari的配置详解（转）

Springboot默认数据源Hikari的配置详解（转）【转发⾃：】基本概念在开始说明Spring Boot中的数据源配置之前，我们先搞清楚关于数据访问的这些基本概念：什么是JDBC？Java数据库连接（Java Database Connectivity，简称JDBC）是Java语⾔中⽤来规范客户端程序如何来访问数据库的应⽤程序接⼝，提供了诸如查询和更新数据库中数据的⽅法。

JDBC也是Sun Microsystems的商标。

我们通常说的JDBC是⾯向关系型数据库的。

JDBC API主要位于JDK中的java.sql包中（之后扩展的内容位于javax.sql包中），主要包括（斜体代表接⼝，需驱动程序提供者来具体实现）：DriverManager：负责加载各种不同驱动程序（Driver），并根据不同的请求，向调⽤者返回相应的数据库连接（Connection）。

Driver：驱动程序，会将⾃⾝加载到DriverManager中去，并处理相应的请求并返回相应的数据库连接（Connection）。

Connection：数据库连接，负责与进⾏数据库间通讯，SQL执⾏以及事务处理都是在某个特定Connection环境中进⾏的。

可以产⽣⽤以执⾏SQL的Statement。

Statement：⽤以执⾏SQL查询和更新（针对静态SQL语句和单次执⾏）。

PreparedStatement：⽤以执⾏包含动态参数的SQL查询和更新（在服务器端编译，允许重复执⾏以提⾼效率）。

CallableStatement：⽤以调⽤数据库中的存储过程。

SQLException：代表在数据库连接的建⽴和关闭和SQL语句的执⾏过程中发⽣了例外情况（即错误）。

什么是数据源？可以看到，在java.sql中并没有数据源（Data Source）的概念。

这是由于在java.sql中包含的是JDBC内核API，另外还有个javax.sql包，其中包含了JDBC标准的扩展API。

springboot配置内存数据库H2教程详解

springboot配置内存数据库H2教程详解业务背景：因soa系统要供外⽹访问,处于安全考虑⽤springboot做了个前置模块，⽤来转发外⽹调⽤的请求和soa返回的应答。

其中外⽹的请求接⼝地址在DB2数据库中对应专门的⼀张表来维护，要是springboot直接访问数据库，还要专门申请权限等，⽐较⿇烦，⽽⼀张表⽤内置的H2数据库维护也⽐较简单，就可以作为替代的办法。

环境：springboot+maven3.3+jdk1.71.springboot的Maven⼯程结构说明⼀下，resource下的templates⽂件夹没啥⽤。

我忘记删掉了。

2. ⾸先引⼊依赖jar包 pom.xml<project xmlns="/POM/4.0.0" xmlns:xsi="/2001/XMLSchema-instance" xsi:schemalocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"><modelversion>4.0.0</modelversion><groupid>com.zlf</groupid>spring-boot</artifactid><version>1.0-SNAPSHOT</version><parent><groupid>org.springframework.boot</groupid>spring-boot-starter-parent</artifactid><version>1.4.3.RELEASE</version></parent><properties><project.build.sourceencoding>UTF-8</project.build.sourceencoding><tomcat.version>7.0.72</tomcat.version><java.version>1.8</java.version></properties><!-- Spring通过添加spring-boot-starter-*这样的依赖就能⽀持具体的某个功能。

spring配置详解

spring配置详解1.前⾔公司⽼项⽬的后台，均是基于spring框架搭建，其中还⽤到了log4j.jar等开源架包。

在新项⽬中，则是spring和hibernate框架均有使⽤，利⽤了hibernate框架，来实现持久化，简化sql操作等。

Hibernate配置⽂件可以有两种格式，⼀种是 hibernate.properties，另⼀种是hibernate.cfg.xml。

后者稍微⽅便⼀些，当增加hbm映射⽂件的时候，可以直接在 hibernate.cfg.xml ⾥⾯增加，不必像 hibernate.properties 必须在初始化代码中加⼊。

我们新项⽬中使⽤的是hibernate.cfg.xml格式。

不过在本⽂中不将细述，后续有机会再补上。

公司项⽬中，中间件主要有tomcat，webshpere，WebLogic。

以下，将对项⽬中spring基本配置，log4j的配置，还有中间件的相关参数配置做⼀个初步的介绍。

2.spring配置——以⽼GIS项⽬为例⼦GISV13中的配置涉及到了SpringMVC,IOC,AOP, Quartz⽅⾯的配置。

配置的实现是通过注记配置和XML配置来合作实现。

这⾥，我将按照Spring的配置流程，将其他⼏个⽅⾯的配置融合其中，来进⾏全⾯解析。

2.1SpringMVC的配置2.1.1.web.xml的配置Web程序中，当中间件启动时，中间件会⾸先读取web.xml中的配置。

在web.xml中可以配置监听器，过滤器，servlet映射等等。

在Spring 框架中，我们主要需配置容器初始化时读取的spring容器配置⽂件的路径以及springMVC中的分发器DispatcherServlet。

在GISV13的web.xml中，我们定义了如下内容：InitGISConfigServlet定义了容器启动时，⾸先要运⾏这个⽅法。

然后servletname为MVC的这部分便是定义了springMVC的分发器以及此servlet所对应的加载配置⽂件的路径。

SpringBoot中实现连接多个Redis分别读写数据

SpringBoot中实现连接多个Redis分别读写数据场景在SpringBoot项⽬中需要连接两个Redis实例，并实现从A中获取数据并存取到B中。

另外A中redis的地址和密码不能外漏，则将A的地址和密码写在jar包中，B中redis参数可以在外置配置⽂件application.yml中进⾏动态配置。

注：实现1、新建SpringBoot项⽬并添加依赖<dependency><groupId>redis.clients</groupId><artifactId>jedis</artifactId><version>3.3.0</version></dependency><dependency><groupId>org.springframework.data</groupId><artifactId>spring-data-redis</artifactId><version>2.3.6.RELEASE</version></dependency><dependency><groupId>com.alibaba</groupId><artifactId>fastjson</artifactId><version>1.2.75</version></dependency>2、完整的pom⽂件代码<?xml version="1.0" encoding="UTF-8"?><project xmlns="/POM/4.0.0" xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/POM/4.0.0 https:///xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.3.7.RELEASE</version><relativePath/> </parent><groupId>com.example</groupId><artifactId>demo</artifactId><version>0.0.1-SNAPSHOT</version><name>demo</name><description>Demo project for Spring Boot</description><properties><java.version>1.8</java.version></properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency><dependency><groupId>redis.clients</groupId><artifactId>jedis</artifactId><version>3.3.0</version></dependency><dependency><groupId>org.springframework.data</groupId><artifactId>spring-data-redis</artifactId><version>2.3.6.RELEASE</version></dependency><dependency><groupId>com.alibaba</groupId><artifactId>fastjson</artifactId><version>1.2.75</version></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build></project>3、在配置⽂件application.properties中配置B的redis的参数server.port=9090er.host=另⼀个redis的地址er.port=6379er.password=1234564、新建Redis的配置类package com.example.demo.config;import com.fasterxml.jackson.annotation.JsonAutoDetect;import com.fasterxml.jackson.annotation.JsonTypeInfo;import com.fasterxml.jackson.annotation.PropertyAccessor;import com.fasterxml.jackson.databind.ObjectMapper;import issezFaireSubTypeValidator;import org.springframework.beans.factory.annotation.Value;import org.springframework.cache.annotation.CachingConfigurerSupport;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.data.redis.connection.RedisConnectionFactory;import org.springframework.data.redis.connection.RedisStandaloneConfiguration;import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;import org.springframework.data.redis.core.RedisTemplate;import org.springframework.data.redis.serializer.StringRedisSerializer;import redis.clients.jedis.JedisPoolConfig;@Configuration@EnableCachingpublic class RedisConfig extends CachingConfigurerSupport {//order@Value("127.0.0.1")private String orderHost;@Value("6379")private String orderPort;@Value("123456")private String orderPassword;//user@Value("${er.host}")private String userHost;@Value("${er.port}")private String userPort;@Value("${er.password}")private String userPassword;private static final int MAX_IDLE = 200; //最⼤空闲连接数private static final int MAX_TOTAL = 1024; //最⼤连接数private static final long MAX_WAIT_MILLIS = 10000; //建⽴连接最长等待时间//配置⼯⼚public RedisConnectionFactory connectionFactory(String host, int port, String password,int index) {RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();redisStandaloneConfiguration.setHostName(host);redisStandaloneConfiguration.setPort(port);redisStandaloneConfiguration.setPassword(password);redisStandaloneConfiguration.setDatabase(index);return new JedisConnectionFactory(redisStandaloneConfiguration);}//连接池配置public JedisPoolConfig poolConfig(int maxIdle, int maxTotal, long maxWaitMillis, boolean testOnBorrow) {JedisPoolConfig poolConfig = new JedisPoolConfig();poolConfig.setMaxIdle(maxIdle);poolConfig.setMaxTotal(maxTotal);poolConfig.setMaxWaitMillis(maxWaitMillis);poolConfig.setTestOnBorrow(testOnBorrow);return poolConfig;}@Bean("redisTemplateOrder")public RedisTemplate<Object, Object> redisTemplateOrder(RedisConnectionFactory connectionFactory) {RedisTemplate<Object, Object> template = new RedisTemplate<>();template.setConnectionFactory(connectionFactory(orderHost, Integer.parseInt(orderPort),orderPassword,0)); FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);ObjectMapper mapper = new ObjectMapper();mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance ,ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);serializer.setObjectMapper(mapper);template.setValueSerializer(serializer);// 使⽤StringRedisSerializer来序列化和反序列化redis的key值template.setKeySerializer(new StringRedisSerializer());template.afterPropertiesSet();return template;}@Bean("redisTemplateUser")public RedisTemplate<Object, Object> redisTemplateUser(RedisConnectionFactory connectionFactory) {RedisTemplate<Object, Object> template = new RedisTemplate<>();template.setConnectionFactory(connectionFactory(userHost, Integer.parseInt(userPort),userPassword,0)); FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);ObjectMapper mapper = new ObjectMapper();mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance ,ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);serializer.setObjectMapper(mapper);template.setValueSerializer(serializer);// 使⽤StringRedisSerializer来序列化和反序列化redis的key值template.setKeySerializer(new StringRedisSerializer());template.afterPropertiesSet();return template;}}注意：这⾥连接的是两个Redis，其中A的Redis命名为order,其参数直接在注解中固定赋值。

springboot配置多数据源...

springboot配置多数据源...⽬录前⾔框架简介基本使⽤框架说明与 springboot 的整合数据准备引⼊依赖springboot 配置⽂件启动类实体类service 层controller 层测试前⾔前篇博客介绍了⽤基本的⽅式做多数据源，可以应对⼀般的情况，但是遇到⼀些复杂的情况就需要扩展下功能了，⽐如：动态增减数据源、数据源分组，纯粹多库，读写分离⼀主多从，从其他数据库或者配置中⼼读取数据源等等。

其实就算没有这些需求，使⽤此款框架实现多数据源也⽐之前要便捷，快速的多框架简介dynamic-datasource-spring-boot-starter是⼀个基于springboot的快速集成多数据源的启动器它跟mybatis-plus是⼀个⽣态圈⾥的，都是由苞⽶⾖团队出品，很容易集成mybatis-plus基本使⽤框架说明本框架只做切换数据源这件核⼼的事情，并不限制你的具体操作，切换了数据源可以做任何CRUD配置⽂件所有以下划线_分割的数据源⾸部即为组的名称，相同组名称的数据源会放在⼀个组下切换数据源可以是组名，也可以是具体数据源名称。

组名则切换时采⽤负载均衡算法切换默认的数据源名称为master，你可以通过spring.datasource.dynamic.primary修改⽅法上的注解优先于类上注解DS⽀持继承抽象类上的DS，暂不⽀持继承接⼝上的DS与 springboot 的整合数据准备springboot版本：2.0.6.RELEASEmysql版本：5.7分别创建数据库test1，test2，数据库表均为goods，数据不相同CREATE TABLE `goods` (`goodsId` bigint(11) unsigned NOT NULL AUTO_INCREMENT COMMENT 'id',`goodsName` varchar(500) NOT NULL DEFAULT '' COMMENT 'name',`subject` varchar(200) NOT NULL DEFAULT '' COMMENT '标题',`price` decimal(15,2) NOT NULL DEFAULT '0.00' COMMENT '价格',`stock` int(11) NOT NULL DEFAULT '0' COMMENT 'stock',PRIMARY KEY (`goodsId`)) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8mb4 COMMENT='商品表';test1数据库数据如下test2数据库数据如下引⼊依赖⾄于其他依赖，不再赘述<dependency><groupId>com.baomidou</groupId><artifactId>dynamic-datasource-spring-boot-starter</artifactId><version>3.3.2</version></dependency>springboot 配置⽂件配置⽂件详情可以参考官⽅⽂档server.port=8080#设置test1为主数据源spring.datasource.dynamic.primary=master#test1主数据源配置spring.datasource.dynamic.datasource.master.url=jdbc:mysql://127.0.0.1:3306/test1?characterEncoding=utf8&useSSL=false&autoReconnect=true&serverTimezone=UTC ername=rootspring.datasource.dynamic.datasource.master.password=123456spring.datasource.dynamic.datasource.master.driver-class-name=com.mysql.jdbc.Driverspring.datasource.dynamic.datasource.master.type=com.alibaba.druid.pool.DruidDataSource#druid连接池配置spring.datasource.dynamic.datasource.master.druid.initial-size=5spring.datasource.dynamic.datasource.master.druid.max-active=20spring.datasource.dynamic.datasource.master.druid.min-idle=5spring.datasource.dynamic.datasource.master.druid.max-wait=60000#test2从数据源配置spring.datasource.dynamic.datasource.slave.url=jdbc:mysql://127.0.0.1:3306/test2?characterEncoding=utf8&useSSL=false&autoReconnect=true&serverTimezone=UTC ername=rootspring.datasource.dynamic.datasource.slave.password=123456spring.datasource.dynamic.datasource.slave.driver-class-name=com.mysql.jdbc.Driverspring.datasource.dynamic.datasource.slave.type=com.alibaba.druid.pool.DruidDataSource#druid连接池配置spring.datasource.dynamic.datasource.slave.druid.initial-size=5spring.datasource.dynamic.datasource.slave.druid.max-active=20spring.datasource.dynamic.datasource.slave.druid.min-idle=5spring.datasource.dynamic.datasource.slave.druid.max-wait=60000#mybatis配置mybatis.mapper-locations=classpath:org/example/mapper/*.xmlmybatis.configuration.cache-enabled=true#开启驼峰命名mybatis.configuration.map-underscore-to-camel-case=true#打印SQLmybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl启动类需要排除掉DruidDataSourceAutoConfigure类，不然启动会报错找不到配置的url@SpringBootApplication(exclude = DruidDataSourceAutoConfigure.class)@Slf4jpublic class App {public static void main(String[] args) {SpringApplication.run(App.class, args);("------springboot running-----");}}实体类@Data@ApiModelpublic class Goods implements Serializable {@ApiModelProperty(value = "商品id")private Long goodsid;@ApiModelProperty(value = "商品名称")@NotBlank(message = "商品名称不能为空")private String goodsname;@ApiModelProperty(value = "商品描述")@NotBlank(message = "商品描述不能为空")private String subject;@ApiModelProperty(value = "商品价格")@NotNull(message = "商品价格不能为空")private BigDecimal price;@ApiModelProperty(value = "商品库存", example = "0")@NotNull(message = "商品库存不能为空")private Integer stock;}service 层⾄于dao层，使⽤的是mybatis-generator插件⾃动⽣成@Servicepublic class GoodServiceImpl implements GoodService {@Autowiredprivate GoodsMapper goodsMapper;@Overridepublic Goods selectOneGoods(Long goodsid) {return goodsMapper.selectByPrimaryKey(goodsid);}@Overridepublic int addGoods(Goods goods) {return goodsMapper.insertSelective(goods);}}controller 层@Controller@RequestMapping(path = "/goods")@Api(tags = "商品管理相关接⼝")@Slf4jpublic class GoodsController {@Autowiredprivate GoodService goodService;@GetMapping(path = "/selectOne")@ResponseBody@ApiOperation(value = "查询商品接⼝")@ApiImplicitParam(name = "id", value = "商品id", required = true)public ResultMap selectOne(@RequestParam(name = "id", defaultValue = "3") Long goodsid) {Goods goods = goodService.selectOneGoods(goodsid);("查询到的商品数据：" + goods.toString());if (StringUtils.isEmpty(goods)) {return new ResultMap().fail().message("查询失败，没有您要的数据");}return new ResultMap().success().message("查询成功").data(goods);}@PostMapping(path = "/addGoods")@ResponseBody@ApiOperation(value = "添加商品的接⼝")public ResultMap addGoods(@Valid Goods goods, @NotNull BindingResult bindingResult) {if (bindingResult.hasErrors()){String defaultMessage = Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage(); return new ResultMap().fail().message(defaultMessage);}int i = goodService.addGoods(goods);if (i > 0) {return new ResultMap().success().message("添加成功");}return new ResultMap().fail().message("添加失败");}}测试service层⽅法上都没有注解@DS使⽤postman测试第⼀个接⼝使⽤postman测试第⼆个接⼝以上两个接⼝测试说明：它们都默认操作的是主数据源test1，证明我们配置⽂件中配置的主数据源test1是配置正确的，已经⽣效service层⽅法上加上注解@DS再测试@Servicepublic class GoodServiceImpl implements GoodService {@Autowiredprivate GoodsMapper goodsMapper;@DS(value = "slave")// 切换数据源，并指定要访问的数据库名称@Overridepublic Goods selectOneGoods(Long goodsid) {return goodsMapper.selectByPrimaryKey(goodsid);}@Overridepublic int addGoods(Goods goods) {return goodsMapper.insertSelective(goods);}}使⽤postman测试第⼀个接⼝此时@DS注解已⽣效，发⽣了数据源的动态切换使⽤postman测试第⼆个接⼝由于该接⼝没有@DS注解，所以没有发⽣数据源的切换，依然操作的是test1默认数据源@DS注解说明注解结果没有@DS默认数据源@DS("dsName")dsName可以为组名也可以为具体某个库的名称@DS 可以注解在⽅法上或类上，同时存在就近原则⽅法上注解优先于类上注解@DS 官⽅建议使⽤在 service 层的⽅法上到此这篇关于springboot配置多数据源的⼀款框架的⽂章就介绍到这了,更多相关springboot多数据源配置内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。

Spring数据库连接池（JDBC）详解

Spring数据库连接池（JDBC）详解数据库连接池对⼀个简单的数据库应⽤，由于对数据库的访问不是很频繁，这时可以简单地在需要访问数据库时，就新创建⼀个连接，就完后就关闭它，这样做也不会带来什么性能上的开销。

但是对于⼀个复杂的数据库应⽤，情况就完全不同⽽，频繁的建⽴、关闭连接，会极⼤地减低系统的性能，因为对于连接的使⽤成了系统性能的瓶颈。

通过建⽴⼀个数据库连接池以及⼀套连接使⽤管理策略，可以达到连接复⽤的效果，使得⼀个数据库连接可以得到安全、⾼效的复⽤，避免了数据库连接频繁建⽴、关闭的开销。

数据库连接池的基本原理是在内部对象池中维护⼀定数量的数据库连接，并对外暴露数据库连接获取和返回⽅法。

如：外部使⽤者可通过getConnection⽅法获取连接，使⽤完毕后再通过releaseConnection⽅法将连接返回，注意此时连接并没有关闭，⽽是由连接池管理器回收，并为下⼀次使⽤做好准备。

数据库连接池技术带来的好处：1、资源重⽤由于数据库连接得到重⽤，避免了频繁创建、释放链接引起的⼤量性能开销。

在减少系统消耗的基础上，另⼀⽅⾯也增进了系统运⾏环境的平稳性（减少内存碎⽚以及数据库临时进⾏/线程数量）2、更快地系统响应速度数据库连接池在初始化过程中，往往已经创建了若⼲数据库连接池置于池中备⽤。

此时连接的初始化⼯作均已完成，对于业务请求处理⽽⾔，直接利⽤现有可⽤连接，避免了数据库连接初始化和释放过程的时间开销，从⽽缩减了系统整体响应时间3、统⼀的连接管理，避免数据库连接泄露在较为完备的数据库连接池实现中，可根据预先的连接占⽤超时设定，强制收回被占⽤连接，从⽽避免了常规数据库连接操作中可能出现的资源泄露。

⽬前数据库连接池产品是⾮常多的，主要有：1、dbcpdbcp，即DataBase Connection PoolApache出品，Spring开发组推荐使⽤的数据库连接池，开发较为活跃，是⼀个使⽤极为⼴泛的数据库连接池产品。

springboot如何连接两个数据库（多个）

springboot如何连接两个数据库（多个）⽬录⼀、启动类⼆、application.yml⽂件三、创建配置类四、结构五、多数据源的事物问题⼀、启动类1.启动类需要不⽤加mybatis的@MapperScan注解@SpringBootApplicationpublic class AppPush {public static void main(String[] args) {SpringApplication.run(AppPush.class,args);}}⼆、application.yml⽂件配置俩个或多个数据库连接，我这⾥⽤的是postgresql，⽤mysql等也是⼀样spring:datasource:# driver-class-name: org.postgresql.Driver# url: jdbc:postgresql://127.0.0.1/aaa# username: root# password: rootone:driver-class-name: org.postgresql.Driverurl: jdbc:postgresql://127.0.0.1/aaausername: rootpassword: roottwo:driver-class-name: org.postgresql.Driverurl: jdbc:postgresql://127.0.0.1/bbbusername: rootpassword: root三、创建配置类1.注意：@MapperScan 的basePackages就是你包的路径，sqlSessionFactoryRef 可以随便起名但是着两个类不能重复！One配置类package com.wys.config;import org.apache.ibatis.session.SqlSessionFactory;import org.mybatis.spring.SqlSessionFactoryBean;import org.mybatis.spring.SqlSessionTemplate;import org.mybatis.spring.annotation.MapperScan;import org.springframework.beans.factory.annotation.Qualifier;import org.springframework.beans.factory.annotation.Value;import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;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.io.support.PathMatchingResourcePatternResolver;import org.springframework.jdbc.datasource.DriverManagerDataSource;import javax.sql.DataSource;/*** @program:* @description: 数据库配置1* @author: wys* @create: 2019-12-03 16:20**/@Configuration@MapperScan(basePackages = "com.wys.mapper.**", sqlSessionFactoryRef = "oneSqlSessionFactory")public class OneDataSourceConfig {@Value("${spring.datasource.one.driver-class-name}")String driverClass;@Value("${spring.datasource.one.url}")String url;@Value("${ername}")String userName;@Value("${spring.datasource.one.password}")String passWord;@Primary@Bean(name = "oneDataSource")@ConfigurationProperties("spring.datasource.one")public DataSource masterDataSource() {DriverManagerDataSource dataSource = new DriverManagerDataSource();dataSource.setDriverClassName(driverClass);dataSource.setUrl(url);dataSource.setUsername(userName);dataSource.setPassword(passWord);return dataSource;}@Bean(name = "oneSqlSessionFactory")public SqlSessionFactory sqlSessionFactory(@Qualifier("oneDataSource") DataSource dataSource) throws Exception {SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();sessionFactoryBean.setDataSource(dataSource);sessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mybatis/mapper-postgre/*.xml"));return sessionFactoryBean.getObject();}@Bean(name = "oneSqlSessionTemplate")public SqlSessionTemplate sqlSessionFactoryTemplate(@Qualifier("oneSqlSessionFactory")SqlSessionFactory sqlSessionFactory ) throws Exception { return new SqlSessionTemplate(sqlSessionFactory);}}Two配置类package com.wys.config;import org.apache.ibatis.session.SqlSessionFactory;import org.mybatis.spring.SqlSessionFactoryBean;import org.mybatis.spring.SqlSessionTemplate;import org.mybatis.spring.annotation.MapperScan;import org.springframework.beans.factory.annotation.Qualifier;import org.springframework.beans.factory.annotation.Value;import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;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.io.support.PathMatchingResourcePatternResolver;import org.springframework.jdbc.datasource.DriverManagerDataSource;import javax.sql.DataSource;/*** @program:* @description: 数据库配置2* @author: wys* @create: 2019-12-03 17:03**/@Configuration@MapperScan(basePackages = "com.wys.mappers",sqlSessionFactoryRef = "twoSqlSessionFactory")public class TwoDataSourceConfig {@Value("${spring.datasource.two.driver-class-name}")String driverClass;@Value("${spring.datasource.two.url}")String url;@Value("${ername}")String userName;@Value("${spring.datasource.two.password}")String passWord;@Bean(name = "twoDataSource")@ConfigurationProperties("spring.datasource.two")public DataSource masterDataSource(){DriverManagerDataSource dataSource = new DriverManagerDataSource();dataSource.setDriverClassName(driverClass);dataSource.setUrl(url);dataSource.setUsername(userName);dataSource.setPassword(passWord);return dataSource;}@Bean(name = "twoSqlSessionFactory")public SqlSessionFactory sqlSessionFactory(@Qualifier("twoDataSource") DataSource dataSource) throws Exception {SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();sessionFactoryBean.setDataSource(dataSource);sessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mybatis/mapper-postgres/*.xml"));return sessionFactoryBean.getObject();}@Bean(name = "twoSqlSessionTemplate")public SqlSessionTemplate sqlSessionFactoryTemplate(@Qualifier("twoSqlSessionFactory")SqlSessionFactory sqlSessionFactory ) throws Exception { return new SqlSessionTemplate(sqlSessionFactory);}}四、结构可能有⼈不清楚项⽬的结构，我在下⾯放了⼀张类结构图，能更清晰和⽅便理解。

spring配置datasource三种方式数据库连接池

spring配置datasource三种⽅式数据库连接池尊重原创(原⽂链接)：/kunkun378263/article/details/85063551、使⽤org.springframework.jdbc.datasource.DriverManagerDataSource说明：DriverManagerDataSource建⽴连接是只要有连接就新建⼀个connection,根本没有连接池的作⽤。

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"><property name="driverClassName"><value>${jdbc.driverClassName}</value></property><property name="url"><value>${jdbc.url}</value></property><property name="username"><value>${ername}</value></property><property name="password"><value>${jdbc.password}</value></property></bean>2、使⽤mons.dbcp.BasicDataSource说明:这是⼀种推荐说明的数据源配置⽅式，它真正使⽤了连接池技术<bean id="dataSource" class="mons.dbcp.BasicDataSource"><property name="driverClassName"><value>oracle.jdbc.driver.OracleDriver</value></property><property name="url"><value>jdbc:oracle:thin:@localhost:1521:orcl</value></property><property name="username"><value>test</value></property><property name="password"><value>test</value></property><property name="maxActive"><value>255</value></property><property name="maxIdle"><value>2</value></property><property name="maxWait"><value>120000</value></property></bean>3、使⽤org.springframework.jndi.JndiObjectFactoryBean说明:JndiObjectFactoryBean 能够通过JNDI获取DataSource<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean"><property name="jndiName"><value>java:comp/env/jdbc/roseindiaDB_local</value></property></bean>总结：3种⽅式中的第⼀种没有使⽤连接池，故少在项⽬中⽤到，第三种⽅式需要在web server中配置数据源，不⽅便于部署，本⼈推荐使⽤每⼆种⽅式进⾏数据源的配置。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

<property name="driverClassName" value="com.microsoft.jdbc.sqlserver.SQLServerDriver" />
<property name="url" value="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName = testDB" />
<property name="driverClassName" value="org.postgresql.Driver" />
<property name="url" value="jdbc:postgresql://localhost/ testDB" />
<property name="username" value="rootl" />
<property name="driverClassName" value="com.ibm.db2.jdbc.app.DB2Driver" />
<property name="url" value="jdbc:db2:thin:@localhost:5000/testDB" />
<property name="username" value="rootl" />
<property name="dataSource">
<ref local="dataSourceJDBC" />
</property>
<property name="sprocName">
<value>DSW.S_CUSTOMER</value>
</property>
<property name="password">
<value>pass4spring</value>
</property>
</bean>
<bean id="SearchImpl" class="com.springsproc.dao.jdbc.SearchDAOImpl">
<property name="password" value="1234" />
</bean>
mons.dbcp.BasicDataSource 需要commons-pool.jar，commons-dbcp-1.2.2.jar，commons-collections-3.2.jar三个JAR包
</property>
<property name="url">
<value>jdbc:db2:testDB</value>
</property>
<property name="username">
<value>dsw</value>
</property>
<property name="username" value="rootl" />
<property name="password" value="1234" />
</bean>
三 MySQL
<bean id="dataSource" class="mons.dbcp.BasicDataSource" destroy-method="close">
Spring 数据库连接配置
一ＯＲＡＣＬＥ
<bean id="dataSource" class="mons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver" />
<property name="username" value="rootl" />
<property name="password" value="1234" />
</bean>
二 DB2
<bean id="dataSource" class="mons.dbcp.BasicDataSource" destroy-method="close">
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"/dtd/spring-beans.dtd">
<beans>
<bean id="dataSourceJDBC"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>COM.ibm.db2.jdbc.app.DB2Driver</value>
<property name="password" value="1234" />
</bean>
三;dataSource" class="mons.dbcp.BasicDataSource" destroy-method="close">
</bean>
</beans>
<property name="url" value="jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS_LIST=(ADDRESS=(PROTOCOL=TCP)(HOST=192.168.1.101)(PORT=1521)))(CONNECT_DATA=(SERVICE_NAME=orcl)(SERVER=DEDICATED)))" />