Spring配置数据源的四种方式

合集下载

SpringBoot多数据源配置详细教程（JdbcTemplate、mybatis）

SpringBoot多数据源配置详细教程（JdbcTemplate、mybatis）多数据源配置⾸先是配置⽂件这⾥采⽤yml配置⽂件，其他类型配置⽂件同理我配置了两个数据源，⼀个名字叫ds1数据源，⼀个名字叫ds2数据源,如果你想配置更多的数据源，继续加就⾏了spring:# 数据源配置datasource:ds1: #数据源1driver-class-name: com.mysql.jdbc.Driver # mysql的驱动你可以配置别的关系型数据库url: jdbc:mysql://ip:3306/db1 #数据源地址username: root # ⽤户名password: root # 密码ds2: # 数据源2driver-class-name: com.mysql.jdbc.Driver # mysql的驱动你可以配置别的关系型数据库url: jdbc:mysql://ip:3307/db2#数据源地址username: root # ⽤户名password: root # 密码多数据源配置增加⼀个Springboot的配置类/*** 多数据源配置*/@Configurationpublic class DataSourceConfig {//主数据源配置 ds1数据源@Primary@Bean(name = "ds1DataSourceProperties")@ConfigurationProperties(prefix = "spring.datasource.ds1")public DataSourceProperties ds1DataSourceProperties() {return new DataSourceProperties();}//主数据源 ds1数据源@Primary@Bean(name = "ds1DataSource")public DataSource ds1DataSource(@Qualifier("ds1DataSourceProperties") DataSourceProperties dataSourceProperties) {return dataSourceProperties.initializeDataSourceBuilder().build();}//第⼆个ds2数据源配置@Bean(name = "ds2DataSourceProperties")@ConfigurationProperties(prefix = "spring.datasource.ds2")public DataSourceProperties ds2DataSourceProperties() {return new DataSourceProperties();}//第⼆个ds2数据源@Bean("ds2DataSource")public DataSource ds2DataSource(@Qualifier("ds2DataSourceProperties") DataSourceProperties dataSourceProperties) {return dataSourceProperties.initializeDataSourceBuilder().build();}}JdbcTemplate多数据源配置增加⼀个Springboot配置类/*** 依赖于数据源配置** @see DataSourceConfig*/@Configurationpublic class JdbcTemplateDataSourceConfig {//JdbcTemplate主数据源ds1数据源@Primary@Bean(name = "ds1JdbcTemplate")public JdbcTemplate ds1JdbcTemplate(@Qualifier("ds1DataSource") DataSource dataSource) {return new JdbcTemplate(dataSource);}//JdbcTemplate第⼆个ds2数据源@Bean(name = "ds2JdbcTemplate")public JdbcTemplate ds2JdbcTemplate(@Qualifier("ds2DataSource") DataSource dataSource) {return new JdbcTemplate(dataSource);}}mybatis 多数据源配置增加⼀个SpringBoot配置类mybatis多数据源的原理是根据不同包，调⽤不同的数据源，你只需要把你的mapper.java和mapper.xml(我喜欢叫dao.java和dao.xml)写在某个package中，springboot⾃动帮你实现数据源切换核⼼代码就这句@MapperScan(basePackages ="com.web.ds2.**.dao", sqlSessionTemplateRef = "ds2SqlSessionTemplate")⽤来指定包扫描指定sqlSessionTemplateRef和sqlSessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath*:com/web/ds2/**/*.xml"));⽤来指定mapper.xml的路径详细配置代码如下/*** Mybatis主数据源ds1配置* 多数据源配置依赖数据源配置* @see DataSourceConfig*/@Configuration@MapperScan(basePackages ="com.web.ds1.**.dao", sqlSessionTemplateRef = "ds1SqlSessionTemplate")public class MybatisPlusConfig4ds1 {//主数据源 ds1数据源@Primary@Bean("ds1SqlSessionFactory")public SqlSessionFactory ds1SqlSessionFactory(@Qualifier("ds1DataSource") DataSource dataSource) throws Exception {MybatisSqlSessionFactoryBean sqlSessionFactory = new MybatisSqlSessionFactoryBean();sqlSessionFactory.setDataSource(dataSource);sqlSessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath*:com/web/ds1/**/*.xml"));return sqlSessionFactory.getObject();}@Primary@Bean(name = "ds1TransactionManager")public DataSourceTransactionManager ds1TransactionManager(@Qualifier("ds1DataSource") DataSource dataSource) {return new DataSourceTransactionManager(dataSource);}@Primary@Bean(name = "ds1SqlSessionTemplate")public SqlSessionTemplate ds1SqlSessionTemplate(@Qualifier("ds1SqlSessionFactory") SqlSessionFactory sqlSessionFactory) {return new SqlSessionTemplate(sqlSessionFactory);}}/*** Mybatis 第⼆个ds2数据源配置* @see DataSourceConfig*/@Configuration@MapperScan(basePackages ="com.web.ds2.**.dao", sqlSessionTemplateRef = "ds2SqlSessionTemplate")public class MybatisPlusConfig4ds2 {//ds2数据源@Bean("ds2SqlSessionFactory")public SqlSessionFactory ds2SqlSessionFactory(@Qualifier("ds2DataSource") DataSource dataSource) throws Exception {MybatisSqlSessionFactoryBean sqlSessionFactory = new MybatisSqlSessionFactoryBean();sqlSessionFactory.setDataSource(dataSource);sqlSessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath*:com/web/ds2/**/*.xml"));return sqlSessionFactory.getObject();}//事务⽀持@Bean(name = "ds2TransactionManager")public DataSourceTransactionManager ds2TransactionManager(@Qualifier("ds2DataSource") DataSource dataSource) {return new DataSourceTransactionManager(dataSource);}@Bean(name = "ds2SqlSessionTemplate")public SqlSessionTemplate ds2SqlSessionTemplate(@Qualifier("ds2SqlSessionFactory") SqlSessionFactory sqlSessionFactory) { return new SqlSessionTemplate(sqlSessionFactory);}}mybatis-plus 多数据源配置相对于mybatis的多数据源配置就是改了下 SqlSessionFactory核⼼代码就是修改mybatis为mybatis-plus，如下@Bean("ds2SqlSessionFactory")public SqlSessionFactory ds2SqlSessionFactory(@Qualifier("ds2DataSource") DataSource dataSource) throws Exception {MybatisSqlSessionFactoryBean sqlSessionFactory = new MybatisSqlSessionFactoryBean();sqlSessionFactory.setDataSource(dataSource);MybatisConfiguration configuration = new MybatisConfiguration();configuration.setDefaultScriptingLanguage(MybatisXMLLanguageDriver.class);configuration.setJdbcTypeForNull(JdbcType.NULL);sqlSessionFactory.setConfiguration(configuration);sqlSessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath*:com/web/ds2/**/*.xml"));sqlSessionFactory.setPlugins(new Interceptor[]{new PaginationInterceptor(),new PerformanceInterceptor()// .setFormat(true),});sqlSessionFactory.setGlobalConfig(new GlobalConfig().setBanner(false));return sqlSessionFactory.getObject();}全部配置代码如下/*** Mybatis-plus ds2数据源配置* 多数据源配置依赖数据源配置* @see DataSourceConfig*/@Configuration@MapperScan(basePackages ="com.web.ds2.**.dao", sqlSessionTemplateRef = "ds2SqlSessionTemplate")public class MybatisPlusConfig4ds2{//ds2数据源@Bean("ds2SqlSessionFactory")public SqlSessionFactory ds2SqlSessionFactory(@Qualifier("ds2DataSource") DataSource dataSource) throws Exception {MybatisSqlSessionFactoryBean sqlSessionFactory = new MybatisSqlSessionFactoryBean();sqlSessionFactory.setDataSource(dataSource);MybatisConfiguration configuration = new MybatisConfiguration();configuration.setDefaultScriptingLanguage(MybatisXMLLanguageDriver.class);configuration.setJdbcTypeForNull(JdbcType.NULL);sqlSessionFactory.setConfiguration(configuration);sqlSessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath*:com/web/ds2/**/*.xml"));sqlSessionFactory.setPlugins(new Interceptor[]{new PaginationInterceptor(),new PerformanceInterceptor()// .setFormat(true),});sqlSessionFactory.setGlobalConfig(new GlobalConfig().setBanner(false));return sqlSessionFactory.getObject();}@Bean(name = "ds2TransactionManager")public DataSourceTransactionManager ds2TransactionManager(@Qualifier("ds2DataSource") DataSource dataSource) {return new DataSourceTransactionManager(dataSource);}@Bean(name = "ds2SqlSessionTemplate")public SqlSessionTemplate ds2SqlSessionTemplate(@Qualifier("ds2SqlSessionFactory") SqlSessionFactory sqlSessionFactory) {return new SqlSessionTemplate(sqlSessionFactory);}}/*** Mybatis-plus 主数据源ds1配置* 多数据源配置依赖数据源配置* @see DataSourceConfig*/@Configuration@MapperScan(basePackages ="com.web.ds1.**.dao", sqlSessionTemplateRef = "ds1SqlSessionTemplate")public class MybatisPlusConfig4ds1 {//主数据源 ds1数据源@Primary@Bean("ds1SqlSessionFactory")public SqlSessionFactory ds1SqlSessionFactory(@Qualifier("ds1DataSource") DataSource dataSource) throws Exception {MybatisSqlSessionFactoryBean sqlSessionFactory = new MybatisSqlSessionFactoryBean();sqlSessionFactory.setDataSource(dataSource);MybatisConfiguration configuration = new MybatisConfiguration();configuration.setDefaultScriptingLanguage(MybatisXMLLanguageDriver.class);configuration.setJdbcTypeForNull(JdbcType.NULL);sqlSessionFactory.setConfiguration(configuration);sqlSessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath*:com/ds1/web/ds1/**/*.xml"));sqlSessionFactory.setPlugins(new Interceptor[]{new PaginationInterceptor(),new PerformanceInterceptor()// .setFormat(true),});sqlSessionFactory.setGlobalConfig(new GlobalConfig().setBanner(false));return sqlSessionFactory.getObject();}@Primary@Bean(name = "ds1TransactionManager")public DataSourceTransactionManager ds1TransactionManager(@Qualifier("ds1DataSource") DataSource dataSource) {return new DataSourceTransactionManager(dataSource);}@Primary@Bean(name = "ds1SqlSessionTemplate")public SqlSessionTemplate ds1SqlSessionTemplate(@Qualifier("ds1SqlSessionFactory") SqlSessionFactory sqlSessionFactory) {return new SqlSessionTemplate(sqlSessionFactory);}}到此这篇关于SpringBoot多数据源配置详细教程(JdbcTemplate、mybatis)的⽂章就介绍到这了,更多相关SpringBoot多数据源配置内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。

基于注解的Spring多数据源配置和使用

基于注解的Spring多数据源配置和使⽤前⼀段时间研究了⼀下spring多数据源的配置和使⽤，为了后期从多个数据源拉取数据定时进⾏数据分析和报表统计做准备。

由于之前做过的项⽬都是单数据源的，没有遇到这种场景，所以也⼀直没有去了解过如何配置多数据源。

后来发现其实基于spring来配置和使⽤多数据源还是⽐较简单的，因为spring框架已经预留了这样的接⼝可以⽅便数据源的切换。

先看⼀下spring获取数据源的源码：可以看到AbstractRoutingDataSource获取数据源之前会先调⽤determineCurrentLookupKey⽅法查找当前的lookupKey，这个lookupKey就是数据源标识。

因此通过重写这个查找数据源标识的⽅法就可以让spring切换到指定的数据源了。

第⼀步：创建⼀个DynamicDataSource的类，继承AbstractRoutingDataSource并重写determineCurrentLookupKey⽅法，代码如下：1public class DynamicDataSource extends AbstractRoutingDataSource {23 @Override4protected Object determineCurrentLookupKey() {5// 从⾃定义的位置获取数据源标识6return DynamicDataSourceHolder.getDataSource();7 }89 }第⼆步：创建DynamicDataSourceHolder⽤于持有当前线程中使⽤的数据源标识，代码如下：1public class DynamicDataSourceHolder {2/**3 * 注意：数据源标识保存在线程变量中，避免多线程操作数据源时互相⼲扰4*/5private static final ThreadLocal<String> THREAD_DATA_SOURCE = new ThreadLocal<String>();67public static String getDataSource() {8return THREAD_DATA_SOURCE.get();9 }1011public static void setDataSource(String dataSource) {12 THREAD_DATA_SOURCE.set(dataSource);13 }1415public static void clearDataSource() {16 THREAD_DATA_SOURCE.remove();17 }1819 }第三步：配置多个数据源和第⼀步⾥创建的DynamicDataSource的bean，简化的配置如下：12<bean id="dataSource1" class="mons.dbcp.BasicDataSource" destroy-method="close">3<property name="driverClassName" value="${db1.driver}"/>4<property name="url" value="${db1.url}"/>5<property name="username" value="${ername}"/>6<property name="password" value="${db1.password}"/>7</bean>89<bean id="dataSource2" class="mons.dbcp.BasicDataSource" destroy-method="close">10<property name="driverClassName" value="${db2.driver}"/>11<property name="url" value="${db2.url}"/>12<property name="username" value="${ername}"/>13<property name="password" value="${db2.password}"/>14</bean>1516<bean id="dataSource3" class="mons.dbcp.BasicDataSource" destroy-method="close">17<property name="driverClassName" value="${db3.driver}"/>18<property name="url" value="${db3.url}"/>19<property name="username" value="${ername}"/>20<property name="password" value="${db3.password}"/>21</bean>2223<bean id="dynamicDataSource" class="com.test.context.datasource.DynamicDataSource">24<property name="targetDataSources">25<map key-type="ng.String">2627<entry key="dataSource1" value-ref="dataSource1"></entry>28<entry key="dataSource2" value-ref="dataSource2"></entry>29<entry key="dataSource3 " value-ref="dataSource3"></entry>30</map>31</property>3233<property name="defaultTargetDataSource" ref="dataSource1"/>34</bean>到这⾥已经可以使⽤多数据源了，在操作数据库之前只要DynamicDataSourceHolder.setDataSource("dataSource2")即可切换到数据源2并对数据库db2进⾏操作了。

Spring事务五种不同的代理配置

Spring事务配置的五种方式前段时间对Spring的事务配置做了比较深入的研究，在此之间对Spring的事务配置虽说也配置过，但是一直没有一个清楚的认识。

通过这次的学习发觉Spring的事务配置只要把思路理清，还是比较好掌握的。

总结如下：Spring配置文件中关于事务配置总是由三个组成部分，分别是DataSource、TransactionManager和代理机制这三部分，无论哪种配置方式，一般变化的只是代理机制这部分。

DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化，比如使用Hibernate进行数据访问时，DataSource实际为SessionFactory，TransactionManager的实现为 HibernateTransactionManager。

具体如下图：根据代理机制的不同，总结了五种Spring事务的配置方式，配置文件如下：第一种方式：每个Bean都有一个代理<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd"><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml"/><property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/></bean><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/></bean><bean id="userDaoTarget" class="erDaoImpl"> <property name="sessionFactory" ref="sessionFactory"/></bean><bean id="userDao"class="org.springframework.transaction.interceptor.TransactionProxyFactoryB ean"><property name="transactionManager" ref="transactionManager"/> <property name="target" ref="userDaoTarget"/><property name="proxyInterfaces"value="com.bluesky.spring.dao.GeneratorDao"/><property name="transactionAttributes"><props><prop key="*">PROPAGATION_REQUIRED</prop></props></property></bean></beans>第二种方式：所有Bean共享一个代理基类<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd"><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml"/><property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/></bean><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/></bean><bean id="transactionBase"class="org.springframework.transaction.interceptor.TransactionP roxyFact oryBean"lazy-init="true" abstract="true"><property name="transactionManager" ref="transactionManager"/><property name="transactionAttributes"><props><prop key="*">PROPAGATION_REQUIRED</prop></props></property></bean><bean id="userDaoTarget" class="erDaoImpl"> <property name="sessionFactory" ref="sessionFactory"/></bean><bean id="userDao" parent="transactionBase"><property name="target" ref="userDaoTarget"/></bean></beans>第三种方式：使用拦截器<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd"><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml"/><property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/></bean><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/></bean><bean id="transactionInterceptor"class="org.springframework.transaction.interceptor.TransactionInterceptor"><property name="transactionManager" ref="transactionManager"/><property name="transactionAttributes"><props><prop key="*">PROPAGATION_REQUIRED</prop></props></property></bean><beanclass="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"> <property name="beanNames"><list><value>*Dao</value></list></property><property name="interceptorNames"><list><value>transactionInterceptor</value></list></property></bean><bean id="userDao" class="erDaoImpl"><property name="sessionFactory" ref="sessionFactory"/></bean></beans>第四种方式：使用tx标签配置的拦截器<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd /schema/aop/schema/aop/spring-aop-2.5.xsd/schema/tx/schema/tx/spring-tx-2.5.xsd"><context:annotation-config /><context:component-scan base-package="com.bluesky"/><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml"/><property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/></bean><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/></bean><tx:advice id="txAdvice" transaction-manager="transactionManager"> <tx:attributes><tx:method name="*" propagation="REQUIRED"/></tx:attributes></tx:advice><aop:config><aop:pointcut id="interceptorPointCuts"expression="execution(* com.bluesky.spring.dao.*.*(..))"/> <aop:advisor advice-ref="txAdvice"pointcut-ref="interceptorPointCuts"/></aop:config></beans>第五种方式：全注解<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd /schema/aop/schema/aop/spring-aop-2.5.xsd/schema/tx/schema/tx/spring-tx-2.5.xsd"><context:annotation-config /><context:component-scan base-package="com.bluesky"/><tx:annotation-driven transaction-manager="transactionManager"/><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml"/><property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/></bean><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/></bean></beans>此时在DAO上需加上@Transactional注解，如下：package com.bluesky.spring.dao;import java.util.List;import org.hibernate.SessionFactory;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.orm.hibernate3.support.HibernateDaoSupport;import ponent;import er;@Transactional@Component("userDao")public class UserDaoImpl extends HibernateDaoSupport implements UserDao {public List<User> listUsers() {return this.getSession().createQuery("from User").list();}}。

spring配置的五种方式

Spring事务配置的五种方式前段时间对Spring的事务配置做了比较深入的研究，在此之间对Spring的事务配置虽说也配置过，但是一直没有一个清楚的认识。

通过这次的学习发觉Spring的事务配置只要把思路理清，还是比较好掌握的。

具体如下图：根据代理机制的不同，总结了五种Spring事务的配置方式，配置文件如下：第一种方式：每个Bean都有一个代理<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd"><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml" /><property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" /></bean><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"><property name="sessionFactory" ref="sessionFactory" /></bean><bean id="userDaoTarget" class="erDaoImpl"><property name="sessionFactory" ref="sessionFactory" /></bean><bean id="userDao"class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"> <property name="transactionManager" ref="transactionManager" /><property name="target" ref="userDaoTarget" /><property name="proxyInterfaces" value="com.bluesky.spring.dao.GeneratorDao" /><property name="transactionAttributes"><props><prop key="*">PROPAGATION_REQUIRED</prop></props></property></bean></beans>第二种方式：所有Bean共享一个代理基类<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd"><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml" /><property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" /></bean><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"><property name="sessionFactory" ref="sessionFactory" /></bean><bean id="transactionBase"class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"lazy-init="true" abstract="true"><property name="transactionManager" ref="transactionManager" /><property name="transactionAttributes"><props><prop key="*">PROPAGATION_REQUIRED</prop></props></property></bean><bean id="userDaoTarget" class="erDaoImpl"><property name="sessionFactory" ref="sessionFactory" /></bean><bean id="userDao" parent="transactionBase" ><property name="target" ref="userDaoTarget" /></bean></beans>第三种方式：使用拦截器<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd"><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml" /><property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" /></bean><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"><property name="sessionFactory" ref="sessionFactory" /></bean><bean id="transactionInterceptor"class="org.springframework.transaction.interceptor.TransactionInterceptor"><property name="transactionManager" ref="transactionManager" /><property name="transactionAttributes"><props><prop key="*">PROPAGATION_REQUIRED</prop></props></property></bean><beanclass="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"> <property name="beanNames"><list><value>*Dao</value></list></property><property name="interceptorNames"><list><value>transactionInterceptor</value></list></property></bean><bean id="userDao" class="erDaoImpl"><property name="sessionFactory" ref="sessionFactory" /></bean></beans>第四种方式：使用tx标签配置的拦截器<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd/schema/tx/schema/tx/spring-tx-2.5.xsd"><context:annotation-config /><context:component-scan base-package="com.bluesky" /><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml" /><property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" /></bean><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"><property name="sessionFactory" ref="sessionFactory" /></bean><tx:advice id="txAdvice" transaction-manager="transactionManager"><tx:attributes><tx:method name="*" propagation="REQUIRED" /></tx:attributes></tx:advice><aop:config><aop:pointcut id="interceptorPointCuts"expression="execution(* com.bluesky.spring.dao.*.*(..))" /><aop:advisor advice-ref="txAdvice"pointcut-ref="interceptorPointCuts" /></aop:config></beans>第五种方式：全注解<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd/schema/tx/schema/tx/spring-tx-2.5.xsd"><context:annotation-config /><context:component-scan base-package="com.bluesky" /><tx:annotation-driven transaction-manager="transactionManager"/><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml" /><property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" /></bean><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"><property name="sessionFactory" ref="sessionFactory" /></bean></beans>此时在DAO上需加上@Transactional注解，如下：package com.bluesky.spring.dao;import java.util.List;import org.hibernate.SessionFactory;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.orm.hibernate3.support.HibernateDaoSupport;import ponent;import er;@Transactional@Component("userDao")public class UserDaoImpl extends HibernateDaoSupport implements UserDao {public List<User> listUsers() {return this.getSession().createQuery("from User").list();}}。

Spring中配置DataSource的六种方式

Spring中配置DataSource的六种⽅式第⼀种：beans.xmlXml代码1. <bean id="dataSource" class="mons.dbcp.BasicDataSource"2. destroy-method="close">3. <property name="driverClassName" value="com.microsoft.sqlserver.jdbc.SQLServerDriver" />4. <property name="url"5. value="jdbc:sqlserver://localhost:1433;DatabaseName=spring" />6. <property name="username" value="sa" />7. <property name="password" value="********" />8. </bean>第⼆种：beans.xml<bean id="mappings"Xml代码1. class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">2. <property name="locations" value="classpath:jdbc.properties"></property>3. </bean>4. <bean id="dataSource" class="mons.dbcp.BasicDataSource"5. destroy-method="close">6. <property name="driverClassName" value="${jdbc.driverClassName}" />7. <property name="url" value="${jdbc.url}" />8. <property name="username" value="${ername}" />9. <property name="password" value="${jdbc.password}" />10. </bean>在src⽂件夹⾥新建⼀个jdbc.properties⽂件，⾥⾯的内容为如下：Xml代码1. jdbc.driverClassName=com.microsoft.sqlserver.jdbc.SQLServerDriver2. jdbcjdbc.url=jdbc:sqlserver://localhost:1433;DatabaseName=spring3. ername=sa4. jdbc.password=********第三种：beans.xmlXml代码1. <bean id="mappings"2. class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">3. <property name="locations" value="classpath:jdbc.properties"></property>4. </bean>5. <bean id="dataSource" class="mons.dbcp.BasicDataSource"6. destroy-method="close">7. <property name="driverClassName" value="${jdbc.driverClassName}" />8. <property name="url" value="${jdbc.url}" />9. <property name="username" value="${ername}" />10. <property name="password" value="${jdbc.password}" />11. </bean>12.13. <context:property-placeholder location="classpath:jdbc.properties" />在src⽂件夹⾥新建⼀个jdbc.properties⽂件，⾥⾯的内容为如下：14. jdbc.driverClassName=com.microsoft.sqlserver.jdbc.SQLServerDriver15. jdbcjdbc.url=jdbc:sqlserver://localhost:1433;DatabaseName=spring16. ername=sa17. jdbc.password=********其中第⼆种与第三种类似，只是指定配置⽂件的⽅法不⼀样。

SpringSpringBoot配置连接数据库的方法

SpringSpringBoot配置连接数据库的⽅法Spring配置连接数据库设置jdbc.propertiesjdbc.driverClassName=com.mysql.jdbc.Driverjdbc.url=jdbc:mysql://127.0.0.1:3306/SSMername=rootjdbc.password=root创建配置类/*** @Author: Promsing* @Date: 2021/5/30 - 14:52* @Description:连接数据库的配置类* @version： 1.0*/@Configuration//声明该类是⼀个java配置类，相当于⼀个xml配置⽂件@PropertySource("classpath:jdbc.properties") //读取资源⽂件public class JdbcConfiguration {@Value("${jdbc.driverClassName}")private String driverClassName;@Value("${jdbc.url}")private String url;@Value("${ername}")private String username;@Value("${jdbc.password}")private String password;@Bean //将返回值注⼊到IOC容器中public DataSource dataSource(){DruidDataSource dataSource=new DruidDataSource();//设置连接数据库的四⼤参数dataSource.setDriverClassName(this.driverClassName);dataSource.setUrl(this.url);dataSource.setUsername(ername);dataSource.setPassword(this.password);return dataSource;}}SpringBoot配置连接数据库设置application.propertiesjdbc.driverClassName=com.mysql.jdbc.Driverjdbc.url=jdbc:mysql://127.0.0.1:3306/SSMername=rootjdbc.password=root创建配置类-JdbcProperties/*** @Author: Promsing* @Date: 2021/5/30 - 15:41* @Description: 封装了读取出来的配置⽂件* @version： 1.0*/@ConfigurationProperties(prefix = "jdbc")public class JdbcProperties {private String driverClassName;private String url;private String username;private String password;public void setDriverClassName(String driverClassName) {this.driverClassName = driverClassName;}public void setUrl(String url) {this.url = url;}public void setUsername(String username) {ername = username;}public void setPassword(String password) {this.password = password;}public String getDriverClassName() {return driverClassName;}public String getUrl() {return url;}public String getUsername() {return username;}public String getPassword() {return password;}}创建配置类-JdbcConfiguration/*** @Author: Promsing* @Date: 2021/5/30 - 14:52* @Description: 连接数据库的Java配置类* @version： 1.0*/@Configuration//声明该类是⼀个java配置类，相当于⼀个西xml配置⽂件@EnableConfigurationProperties(JdbcProperties.class) //加载JDBC的配置类public class JdbcConfiguration {@Autowiredprivate JdbcProperties jdbcProperties;//⽅式⼀@Bean //将返回值注⼊到IOC容器中public DataSource dataSource(){DruidDataSource dataSource=new DruidDataSource();//设置连接数据库的四⼤参数dataSource.setDriverClassName(this.jdbcProperties.getDriverClassName()); dataSource.setUrl(this.jdbcProperties.getUrl());dataSource.setUsername(this.jdbcProperties.getUsername());dataSource.setPassword(this.jdbcProperties.getPassword());return dataSource;}/*//⽅式⼆：最优雅最简单--直接换掉⽅式⼀@Bean //将返回值注⼊到IOC容器中@ConfigurationProperties(prefix = "jdbc")public DataSource dataSource(){DruidDataSource dataSource=new DruidDataSource();return dataSource;}* *//*//⽅式三通过构造函数注⼊--在⽅式⼀上的⽅式修改public JdbcConfiguration(JdbcProperties jdbcProperties) {this.jdbcProperties = jdbcProperties;}* *//*//⽅式四通过⽅法的参数注⼊--直接换掉⽅式⼀public DataSource dataSource(dbcProperties jdbcProperties){DruidDataSource dataSource=new DruidDataSource();//设置连接数据库的四⼤参数dataSource.setDriverClassName(jdbcProperties.getDriverClassName());dataSource.setUrl(jdbcProperties.getUrl());dataSource.setUsername(jdbcProperties.getUsername());dataSource.setPassword(jdbcProperties.getPassword());return dataSource;// }* */}SpringBoot的四种属性注⼊⽅式1. Autowired注⼊2.直接在@Bean⽅法中使⽤@ConfigurationProperties(prefix = "jdbc")3.构造函数主语4.@Bean⽅法形参注⼊需要注意的是配置⽂件中的名称要与 JdbcProperties中的属性名称要⼀致。

springboot进行动态数据源配置（基于注解方式）

springboot进⾏动态数据源配置（基于注解⽅式）⼀、应⽤场景项⽬需要从⾃⼰的数据库上读取和管理数据外，还有⼀部分业务涉及到其他多个数据库。

为了能够灵活地指定具体的数据库，本⽂基于注解和AOP的⽅法实现多数据源⾃动切换。

在使⽤过程中，只需要添加注解就可以使⽤，简单⽅便。

⼆、准备⼯作2.1 创建数据表USE test;CREATE TABLE `user` (`id` int(11) NOT NULL AUTO_INCREMENT,`name` varchar(255) NOT NULL,`age` int(11) NOT NULL,PRIMARY KEY (`id`)) ENGINE=InnoDB AUTO_INCREMENT=3DEFAULT CHARSET=utf8USE test1;CREATE TABLE `teacher` (`tid` int(11) NOT NULL AUTO_INCREMENT,`tname` varchar(255) NOT NULL,`tage` int(11) NOT NULL,PRIMARY KEY (`tid`)) ENGINE=InnoDB AUTO_INCREMENT=3DEFAULT CHARSET=utf8USE test2;CREATE TABLE `student` (`sid` int(11) NOT NULL AUTO_INCREMENT,`sname` varchar(255) NOT NULL,`sage` int(11) NOT NULL,PRIMARY KEY (`sid`)) ENGINE=InnoDB AUTO_INCREMENT=3DEFAULT CHARSET=utf82.2 添加依赖spring boot：1.5.8.RELEASEmysql：5.1.44mybatis:1.3.2druid:1.1.3<?xml version="1.0" encoding="UTF-8"?><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.example</groupId><artifactId>dynamic-data-source</artifactId><version>0.0.1-SNAPSHOT</version><packaging>jar</packaging><name>dynamic-data-source</name><description>Demo project for Spring Boot</description><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>1.5.8.RELEASE</version><relativePath/></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><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><scope>runtime</scope></dependency><dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>1.3.2</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId></dependency><dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.1.3</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin><plugin><groupId>org.mybatis.generator</groupId><artifactId>mybatis-generator-maven-plugin</artifactId><version>1.3.2</version><configuration><overwrite>true</overwrite><verbose>true</verbose></configuration></plugin></plugins></build></project>2.3 ⽣成 bean、dao、mapper使⽤MyBatis Generator⾃动⽣成，⽅法如下：三、动态数据源3.1 配置⽂件 application.properties custom.datasource.defaultname=defaults=ds1,ds2# 默认数据源custom.datasource.driver-class-name=com.mysql.jdbc.Driver custom.datasource.url=jdbc:mysql://localhost:3306/test ername=rootcustom.datasource.password=root# 更多数据源custom.datasource.ds1.driver-class-name=com.mysql.jdbc.Driver custom.datasource.ds1.url=jdbc:mysql://localhost:3306/test1 ername=rootcustom.datasource.ds1.password=rootcustom.datasource.ds2.driver-class-name=com.mysql.jdbc.Drivercustom.datasource.ds2.url=jdbc:mysql://localhost:3306/test2ername=rootcustom.datasource.ds2.password=rootcustom.datasource.filters=statcustom.datasource.maxActive=100custom.datasource.initialSize=1custom.datasource.minIdle=1custom.datasource.timeBetweenEvictionRunsMillis=60000custom.datasource.minEvictableIdleTimeMillis=300000custom.datasource.validationQuery=select 'x'custom.datasource.testWhileIdle=truecustom.datasource.testOnBorrow=falsecustom.datasource.testOnReturn=falsecustom.datasource.poolPreparedStatements=truecustom.datasource.maxOpenPreparedStatements=100mybatis.type-aliases-package=com.example.demo.model.*mybatis.mapper-locations=classpath:mapper/**/*.xml3.2 动态数据源核⼼代码DynamicDataSource：动态数据源切换；DynamicDataSourceAspect：利⽤AOP切⾯实现数据源的动态切换；DynamicDataSourceContextHolder：动态切换数据源；DynamicDataSourceRegister：动态数据源注册；TargetDataSource：在⽅法上使⽤，⽤于指定使⽤哪个数据源。

springboot不同类型多数据源配置及使用

springboot不同类型多数据源配置及使⽤springboot多数据源配置：datasource.master.jdbc=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8&useSSL=true ername=rootdatasource.master.password=123456datasource.master.driver-class-name=com.mysql.jdbc.Driverdatasource.master.url=jdbc:oracle:thin:@localhost:1521:testername=acctdatasource.master.password=123456datasource.master.driver-class-name=oracle.jdbc.driver.OracleDriverdatasource.master.max-idle=10datasource.master.max-wait=10000datasource.master.min-idle=5datasource.master.initial-size=5datasource.master.validation-query=SELECT 1datasource.master.test-on-borrow=falsedatasource.master.test-while-idle=truedatasource.master.time-between-eviction-runs-millis=18800第⼀个数据源实现：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.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.context.annotation.PropertySource;import org.springframework.core.io.support.PathMatchingResourcePatternResolver;import org.springframework.jdbc.datasource.DataSourceTransactionManager;/*** 主数据源配置* @author zyl**/@Configuration//读取⾃定义配置⽂件 datasource.properties@PropertySource("classpath:config/datasource.properties")//扫描 Mapper 接⼝并容器管理@MapperScan(basePackages = MasterDataSourceConfig.PACKAGE, sqlSessionFactoryRef = "masterSqlSessionFactory") public class MasterDataSourceConfig {// 精确到 master ⽬录，以便跟其他数据源隔离static final String PACKAGE = "com.acct.dao.master";static final String TYPE_ALIASES_PACKAGE = "com.acct.domain.entity.master";static final String MAPPER_LOCATION = "classpath:mapper/master/*.xml";@Bean(name = "masterDataSource")@Primary@ConfigurationProperties(prefix = "datasource.master")public DataSource masterDataSource() {return DataSourceBuilder.create().build();}@Bean(name = "masterTransactionManager")@Primarypublic DataSourceTransactionManager masterTransactionManager() {return new DataSourceTransactionManager(masterDataSource());}@Bean(name = "masterSqlSessionFactory")@Primarypublic SqlSessionFactory masterSqlSessionFactory(@Qualifier("masterDataSource") DataSource masterDataSource) throws Exception {final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();sessionFactory.setDataSource(masterDataSource);sessionFactory.setTypeAliasesPackage(MasterDataSourceConfig.TYPE_ALIASES_PACKAGE);sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(MasterDataSourceConfig.MAPPER_LOCATION));return sessionFactory.getObject();}}@Primary 注解默认为第⼀个数据源第⼆个数据源实现：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.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.PropertySource;import org.springframework.core.io.support.PathMatchingResourcePatternResolver;import org.springframework.jdbc.datasource.DataSourceTransactionManager;/*** 从数据源配置* @author zyl**/@Configuration//读取⾃定义配置⽂件 datasource.properties@PropertySource("classpath:config/datasource.properties")// 扫描 Mapper 接⼝并容器管理@MapperScan(basePackages = ClusterDataSourceConfig.PACKAGE, sqlSessionFactoryRef = "clusterSqlSessionFactory") public class ClusterDataSourceConfig {// 精确到 cluster ⽬录，以便跟其他数据源隔离static final String PACKAGE = "com.acct.dao.cluster";static final String TYPE_ALIASES_PACKAGE = "com.acct.domain.entity.cluster";static final String MAPPER_LOCATION = "classpath:mapper/cluster/*.xml";@Bean(name = "clusterDataSource")@ConfigurationProperties(prefix = "datasource.cluster")public DataSource clusterDataSource() {return DataSourceBuilder.create().build();}@Bean(name = "clusterTransactionManager")public DataSourceTransactionManager clusterTransactionManager() {return new DataSourceTransactionManager(clusterDataSource());}@Bean(name = "clusterSqlSessionFactory")public SqlSessionFactory clusterSqlSessionFactory(@Qualifier("clusterDataSource") DataSource clusterDataSource) throws Exception {final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();sessionFactory.setDataSource(clusterDataSource);sessionFactory.setTypeAliasesPackage(ClusterDataSourceConfig.TYPE_ALIASES_PACKAGE);sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(ClusterDataSourceConfig.MAPPER_LOCATION)); return sessionFactory.getObject();}}⽬录结构:启动正常，ok！。

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

Spring配置数据源的四种方式Spring框架支持四种数据源的配置:
1.自带数据源(DriverManagerDataSource)
2.DBCP数据源
3.C3P0数据源
4.JNDI数据源
准备：
2.Spring-config.xml中引入配置文件（注册JDBC属性配置文件）
方式二：(需要添加context约束)
第二种方式：DBCP数据源
便Spring容器关闭时，数据源能够正常关闭。

除以上必须的数据源属性外，还有一些常用的属性：defaultAutoCommit：设置从数据源中返回的连接是否采用自动提交机制，默认值为true；
defaultReadOnly：设置数据源是否仅能执行只读操作，默认值为false；
maxActive：最大连接数据库连接数，设置为0时，表示没有限制；
maxIdle：最大等待连接中的数量，设置为0时，表示没有限制；
maxWait：最大等待秒数，单位为毫秒，超过时间会报出错误信息；
validationQuery：用于验证连接是否成功的查询SQL语句，SQL语句必须至少要返回一行数据，如你可以简单地设置为：“select count(*) from user”；
removeAbandoned：是否自我中断，默认是false ；
removeAbandonedTimeout：几秒后数据连接会自动断开，在removeAbandoned为true，提供该值；
logAbandoned：是否记录中断事件，默认为false；
第三种方式：C3P0数据源
们就可以保证Spring容器关闭时数据源能够成功释放。

acquireIncrement：当连接池中的连接用完时，C3P0一次性创建新连接的数目；
acquireRetryAttempts：定义在从数据库获取新连接失败后重复尝试获取的次数，默认为30；
acquireRetryDelay：两次连接中间隔时间，单位毫秒，默认为1000；
autoCommitOnClose：连接关闭时默认将所有未提交的操作回滚。

默认为false；
automaticTestTable：C3P0将建一张名为Test的空表，并使用其自带的查询语句进行测试。

如果定义了这个参数，那么属性preferredTestQuery将被忽略。

你不能在这张Test表上进行任何操作，它将中为C3P0测试所用，默认为null；
breakAfterAcquireFailure：获取连接失败将会引起所有等待获取连接的线程抛出异常。

但是数据源仍有效保留，并在下次调用getConnection()的时候继续尝试获取连接。

如果设为true，那么在尝试获取连接失败后该数据源将申明已断开并永久关闭。

默认为false；
checkoutTimeout：当连接池用完时客户端调用getConnection()后等待获取新连接的时间，超时后
将抛出SQLException，如设为0则无限期等待。

单位毫秒，默认为0；
connectionTesterClassName：通过实现ConnectionT ester或QueryConnectionT ester的类来测试连接，类名需设置为全限定名。

默认为com.mchange.v2.C3P0.impl.DefaultConnectionTester；
idleConnectionTestPeriod：隔多少秒检查所有连接池中的空闲连接，默认为0表示不检查；
initialPoolSize：初始化时创建的连接数，应在minPoolSize与maxPoolSize之间取值。

默认为3；
maxIdleTime：最大空闲时间，超过空闲时间的连接将被丢弃。

为0或负数则永不丢弃。

默认为0；
maxPoolSize：连接池中保留的最大连接数。

默认为15；
maxStatements：JDBC的标准参数，用以控制数据源内加载的PreparedStatement数量。

但由于预缓存的Statement属于单个Connection而不是整个连接池。

所以设置这个参数需要考虑到多方面的因素，如果maxStatements与maxStatementsPerConnection均为0，则缓存被关闭。

默认为0；
maxStatementsPerConnection：连接池内单个连接所拥有的最大缓存Statement数。

默认为0；
numHelperThreads：C3P0是异步操作的，缓慢的JDBC操作通过帮助进程完成。

扩展这些操作可以有效的提升性能，通过多线程实现多个操作同时被执行。

默认为3；
preferredT estQuery：定义所有连接测试都执行的测试语句。

在使用连接测试的情况下这个参数能显著提高测试速度。

测试的表必须在初始数据源的时候就存在。

默认为null；
propertyCycle：用户修改系统配置参数执行前最多等待的秒数。

默认为300；
testConnectionOnCheckout：因性能消耗大请只在需要的时候使用它。

如果设为true那么在每个connection提交的时候都将校验其有效性。

建议使用idleConnectionT estPeriod或automaticTestTable 等方法来提升连接测试的性能。

默认为false；
testConnectionOnCheckin：如果设为true那么在取得连接的同时将校验连接的有效性。

默认为false。

第四种方式：(JNDI数据源)
如果应用配置在高性能的应用服务器（如WebLogic或Websphere,tomcat等）上，我们可能更希望使用应用服务器本身提供的数据源。

应用服务器的数据源使用JNDI开放调用者使用，Spring为此专门提供引用JNDI资源的JndiObjectFactoryBean类。