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！。

springboot配置双数据源

1、主从库分离（数据库读写分离）
2、数据迁移
3、系统版本升级，数据库升级到另外一款
二、 application.properties中配置
#mysql数据源 spring.datasource.one.type= com.alibaba.druid.pool.DruidDataSource spring.datasource.one.jdbc-url= jdbc:mysql://localhost:3306/hongtianyu_sync?useSSL=false&serverTimezone=Asia/Shanghai ername= root spring.datasource.one.password= root spring.datasource.one.driver-class-name= com.mysql.cj.jdbc.Driver #spring.datasource.one.database:mysql #sqlserver数据源 #spring.datasource.two.type=com.alibaba.druid.pool.DruidDataSource spring.datasource.two.jdbc-url = jdbc:mariadb://192.168.7.22:3309/power?useSSL=false&serverTimezone=Asia/Shanghai ername = zhongfu spring.datasource.two.password = zhongfu spring.datasource.two.driver-class-name = org.mariadb.jdbc.Driver
return new JpaTransactionManager(entityManagerFactoryOne(builder).getObject()); } }

SpringBoot项目添加外部Jar包以及配置多数据源的完整步骤

SpringBoot项⽬添加外部Jar包以及配置多数据源的完整步骤前⾔最近项⽬需要和Oracle数据库进⾏交互，然后我从Maven中央仓库下载数据库驱动jar包，但怎么都下不下来，我到Oracle官⽹上⼀看，我去，居然不让⽤Maven直接下（⼤学时候⽤过Oracle，很久远的事情了0rz），没办法我还是直接下载jar包放到我的项⽬⾥⾯吧。

SpringBoot项⽬引⼊外部jar包是⾮常⽅便的，包含打引⼊外部jar等操作。

我的做法如下：⾸先在src同级⽬录建⼀个lib⽂件夹，将第三⽅jar包放到这个⽂件内，⽐如我将ojdbc6.jar 这个jar包放到这个地⽅。

接着我们需要在pom.xml⽂件⾥配置jar的maven坐标，不过这个坐标⽐较特殊，我们需要直接定位到我们上⼀步添加的⽂件，⽽不是从Maven仓库⾥⾯去下载，以ojdbc6.jar为例，配置依赖如下：<dependency><groupId>com.oracle</groupId><artifactId>ojdbc6</artifactId><version>12.1.0.2.0</version><scope>system</scope><systemPath>${project.basedir}/lib/ojdbc6.jar</systemPath></dependency>这⾥⽐较特殊的是systemPath，常见的Maven坐标是没有这个的，这⾥⾯直接指定该jar的相对路径（相对项⽬的根⽬录），这样Maven在编译的时候就不会从中央仓库⾥⾯去下载该jar包了。

但只配置这个还不⾏，还需要配置SpringBoot编译时插件属性includeSystemScope，具体如下：<plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId><configuration><includeSystemScope>true</includeSystemScope></configuration></plugin>上⾯配置完毕，我们就可以直接执⾏mvn clean install进⾏打包，然后我们查看打好的jar包⾥⾯包含的jar包，会发现ojdbc6.jar这个包已经正确被包含进去了。

SpringBoot使用编程方式配置DataSource的方法

SpringBoot使⽤编程⽅式配置DataSource的⽅法Spring Boot使⽤固定算法来扫描和配置。

这使我们可以在默认情况下轻松获得完全配置的DataSource实现。

Spring Boot还会按顺序快速的⾃动配置连接池（HikariCP， Apache Tomcat或Commons DBCP），具体取决于路径中的哪些类。

虽然Spring Boot的DataSource⾃动配置在⼤多数情况下运⾏良好，但有时我们需要更⾼级别的控制，因此我们必须设置⾃⼰的DataSource实现，因此忽略⾃动配置过程。

Maven依赖总体⽽⾔，以编程⽅式创建DataSource实现⾮常简单。

为了学习如何实现这⼀⽬标，我们将实现⼀个简单的存储库层，它将对某些JPA实体执⾏CRUD操作。

我们来看看我们的演⽰项⽬的依赖项：<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jpa</artifactId></dependency><dependency><groupId>com.h2database</groupId><artifactId>h2</artifactId><version>2.4.1</version><scope>runtime</scope></dependency>我们将使⽤内存中的实例来运⾏存储库层。

通过这样做，我们将能够测试以编程⽅式配置的DataSource，⽽⽆需执⾏昂贵的数据库操作。

让我们确保在Maven Central上查看最新版本的spring-boot-starter-data-jpa。

spring的5中事务配置方式

Spring事务配置的五种方式这三部分，无论哪种配置方式，一般变化的只是代理机制这部分。

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

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

具体如下图：Spring事务配置根据代理机制的不同，总结了五种Spring事务的配置方式，配置文件如下：第一种方式：每个Bean都有一个代理1.<?xml version="1.0"encoding="UTF-8"?>2.<beans xmlns="/schema/beans"3.xmlns:xsi="/2001/XMLSchema-instance"4.xmlns:context="/schema/context"5.xmlns:aop="/schema/aop"6.xsi:schemaLocation="/schema/beans7. /schema/beans/spring-beans-2.5.xsd8. /schema/context9. /schema/context/spring-context-2.5.xsd10. /schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">11.12.<bean id="sessionFactory"13.class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">14.<property name="configLocation"value="classpath:hibernate.cfg.xml"/>15.<property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/>16.</bean>17.18.19.<bean id="transactionManager"20.class="org.springframework.orm.hibernate3.HibernateTransactionManager">21.<property name="sessionFactory"ref="sessionFactory"/>22.</bean>23.24.25.<bean id="userDaoTarget"class="erDaoImpl">26.<property name="sessionFactory"ref="sessionFactory"/>27.</bean>28.29.<bean id="userDao"30.class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">31.32.<property name="transactionManager"ref="transactionManager"/>33.<property name="target"ref="userDaoTarget"/>34.<property name="proxyInterfaces"value="com.bluesky.spring.dao.GeneratorDao"/>35.36.<property name="transactionAttributes">37.<props>38.<prop key="*">PROPAGATION_REQUIRED</prop>39.</props>40.</property>41.</bean>42.</beans>第二种方式：所有Bean共享一个代理基类1.<?xml version="1.0"encoding="UTF-8"?>2.<beans xmlns="/schema/beans"3.xmlns:xsi="/2001/XMLSchema-instance"4.xmlns:context="/schema/context"5.xmlns:aop="/schema/aop"6.xsi:schemaLocation="/schema/beans7. /schema/beans/spring-beans-2.5.xsd8. /schema/context9. /schema/context/spring-context-2.5.xsd10. /schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">11.12.<bean id="sessionFactory"13.class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">14.<property name="configLocation"value="classpath:hibernate.cfg.xml"/>15.<property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/>16.</bean>17.18.19.<bean id="transactionManager"20.class="org.springframework.orm.hibernate3.HibernateTransactionManager">21.<property name="sessionFactory"ref="sessionFactory"/>22.</bean>23.24.<bean id="transactionBase"25.class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"zy-init="true"abstract="true">27.28.<property name="transactionManager"ref="transactionManager"/>29.30.<property name="transactionAttributes">31.<props>32.<prop key="*">PROPAGATION_REQUIRED</prop>33.</props>34.</property>35.</bean>36.37.38.<bean id="userDaoTarget"class="erDaoImpl">39.<property name="sessionFactory"ref="sessionFactory"/>40.</bean>41.42.<bean id="userDao"parent="transactionBase">43.<property name="target"ref="userDaoTarget"/>44.</bean>45.</beans>第三种方式：使用拦截器1.<?xml version="1.0"encoding="UTF-8"?>2.<beans xmlns="/schema/beans"3.xmlns:xsi="/2001/XMLSchema-instance"4.xmlns:context="/schema/context"5.xmlns:aop="/schema/aop"6.xsi:schemaLocation="/schema/beans7. /schema/beans/spring-beans-2.5.xsd8. /schema/context9. /schema/context/spring-context-2.5.xsd10. /schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">11.12.<bean id="sessionFactory"13.class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">14.<property name="configLocation"value="classpath:hibernate.cfg.xml"/>15.<property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/>16.</bean>17.18.19.<bean id="transactionManager"20.class="org.springframework.orm.hibernate3.HibernateTransactionManager">21.<property name="sessionFactory"ref="sessionFactory"/>22.</bean>23.24.<bean id="transactionInterceptor"25.class="org.springframework.transaction.interceptor.TransactionInterceptor">26.<property name="transactionManager"ref="transactionManager"/>27.28.<property name="transactionAttributes">29.<props>30.<prop key="*">PROPAGATION_REQUIRED</prop>31.</props>32.</property>33.</bean>34.35.<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">36.<property name="beanNames">37.<list>38.<value>*Dao</value>39.</list>40.</property>41.<property name="interceptorNames">42.<list>43.<value>transactionInterceptor</value>44.</list>45.</property>46.</bean>47.48.49.<bean id="userDao"class="erDaoImpl">50.<property name="sessionFactory"ref="sessionFactory"/>51.</bean>52.</beans>第四种方式：使用tx标签配置的拦截器1.<?xml version="1.0"encoding="UTF-8"?>2.<beans xmlns="/schema/beans"3.xmlns:xsi="/2001/XMLSchema-instance"4.xmlns:context="/schema/context"5.xmlns:aop="/schema/aop"6.xmlns:tx="/schema/tx"7.xsi:schemaLocation="/schema/beans8. /schema/beans/spring-beans-2.5.xsd9. /schema/context10. /schema/context/spring-context-2.5.xsd11. /schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd12. /schema/tx /schema/tx/spring-tx-2.5.xsd">13.14.<context:annotation-config/>15.<context:component-scan base-package="com.bluesky"/>16.17.<bean id="sessionFactory"18.class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">19.<property name="configLocation"value="classpath:hibernate.cfg.xml"/>20.<property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/>21.</bean>22.23.24.<bean id="transactionManager"25.class="org.springframework.orm.hibernate3.HibernateTransactionManager">26.<property name="sessionFactory"ref="sessionFactory"/>27.</bean>28.29.<tx:advice id="txAdvice"transaction-manager="transactionManager">30.<tx:attributes>31.<tx:method name="*"propagation="REQUIRED"/>32.</tx:attributes>33.</tx:advice>34.35.<aop:config>36.<aop:pointcut id="interceptorPointCuts"37.expression="execution(* com.bluesky.spring.dao.*.*(..))"/>38.<aop:advisor advice-ref="txAdvice"39.pointcut-ref="interceptorPointCuts"/>40.</aop:config>41.</beans>第五种方式：全注解1.<?xml version="1.0"encoding="UTF-8"?>2.<beans xmlns="/schema/beans"3.xmlns:xsi="/2001/XMLSchema-instance"4.xmlns:context="/schema/context"5.xmlns:aop="/schema/aop"6.xmlns:tx="/schema/tx"7.xsi:schemaLocation="/schema/beans8. /schema/beans/spring-beans-2.5.xsd9. /schema/context10. /schema/context/spring-context-2.5.xsd11. /schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd12. /schema/tx /schema/tx/spring-tx-2.5.xsd">13.14.<context:annotation-config/>15.<context:component-scan base-package="com.bluesky"/>16.17.<tx:annotation-driven transaction-manager="transactionManager"/>18.19.<bean id="sessionFactory"20.class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">21.<property name="configLocation"value="classpath:hibernate.cfg.xml"/>22.<property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/>23.</bean>24.25.26.<bean id="transactionManager"27.class="org.springframework.orm.hibernate3.HibernateTransactionManager">28.<property name="sessionFactory"ref="sessionFactory"/>29.</bean>30.31.</beans>此时在DAO上需加上@Transactional注解，如下：1.package com.dawnsky.spring.dao;2.3.import java.util.List;4.5.import org.hibernate.SessionFactory;6.import org.springframework.beans.factory.annotation.Autowired;7.import org.springframework.orm.hibernate3.support.HibernateDaoSupport;8.import ponent;9.10.import er;11.12.@Transactional13.@Component("userDao")14.public class UserDaoImpl extends HibernateDaoSupport implements UserDao {15.16.public List<User> listUsers() {17.return this.getSession().createQuery("from User").list();18. }19.}。

Spring配置多个数据源

配置多个数据源在开发当中，有时候需要的数据源不止一个，所以就需要配置数据源，也就是说需要不同数据库里的数据。

废话少说，转入正题！一框架SSI (Struts+Spring+Ibatis )二、主要的就是Spring的配置文件，其他的都是次要的三、我是将Spring的配置文件分开了，你只要参考我的改一下就行了四、spring的配置文件1、applicationContext_bean.xml<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance”xmlns:aop="/schema/aop”xmlns:tx="/schema/tx”xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.0.xsd/schema/tx/schema/tx/spring-tx-3.0.xsdhttp://www.springframework.o rg/schema/aop/schema/aop/spring-aop-3.0.xsd"><!——>//.红色部分为重点，这里是核心，配置两个dateSource<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean"> <property name="jndiName"><value>vspn53JNDI</value></property></bean><bean id="dataSource2" class="org.springframework.jndi.JndiObjectFactoryBean"> <property name="jndiName"><value>sxJNDI</value></property></bean><bean id="sqlMapClient”class="org.springframework.orm.ibatis.SqlMapClientFactoryBean"><property name="configLocation"><value>classpath:sqlmap/sqlmap_base.xml</value></property><property name="dataSource"><ref local="dataSource" /></property></bean><beanid="sqlMapClient2”class="org.springframework.orm.ibatis.SqlMapClientFactoryBean"><property name="configLocation"><value>classpath:sqlmap/sqlmap_base.xml</value></property><property name="dataSource"><ref local="dataSource2” /></property></bean><bean id="transactionManager”class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource" ref="dataSource"></property></bean><tx:annotation-driven transaction-manager="transactionManager" /><bean id="baseTransactionProxy"class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" abstract="true"><property name="transactionManager" ref="transactionManager"></property><property name="transactionAttributes"><props><prop key="insert*">PROPAGA TION_REQUIRED</prop><prop key="update*">PROPAGATION_REQUIRED</prop><prop key="delete*">PROPAGATION_REQUIRED</prop><prop key="get*">PROPAGATION_REQUIRED,readOnly</prop> </props></property></bean></beans>2、applicationContext_dao.xml<?xml version="1.0" encoding="UTF-8”?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance”xmlns:aop="/schema/aop”xmlns:tx="/schema/tx”xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.0.xsd/schema/tx/schema/tx/spring-tx-3.0.xsd/schema/aop/schema/aop/spring-aop-3.0.xsd"> <bean id="loginDao" class="com.vstsoft.da.system.dao.imp.LoginDaoImpl"> <property name="sqlMapClient" ref="sqlMapClient" /></bean><bean id="ans01Dao" class="com.vstsoft.da.system.dao.imp.Ans01DaoImpl"> <property name="sqlMapClient" ref="sqlMapClient" /></bean><bean id="ans03Dao" class="com.vstsoft.da.system.dao.imp.Ans03DaoImpl"> <property name="sqlMapClient" ref="sqlMapClient" /></bean><bean id="jianDao" class="com.vstsoft.da.jian.dao.impl.JianDaoImpl"><property name="sqlMapClient" ref="sqlMapClient"/></bean>〃这里调用的是dateSource2的数据<bean id="zujianDao" class="com.vstsoft.da.jian.dao.impl.ZuJianDaoImpl"> <property name="sqlMapClient" ref="sqlMapClient2”/></bean><bean id="juanDao" class="com.vstsoft.da.juan.dao.impl.JuanDaoImpl"><property name="sqlMapClient" ref="sqlMapClient"/></bean><bean id="heDao" class="com.vstsoft.da.he.dao.impl.HeDaoImpl"><property name="sqlMapClient" ref="sqlMapClient"/></bean><bean id="jianSuoDao" class="com.vstsoft.da.jiansuo.dao.impl.JianSuoDaoImpl"> <property name="sqlMapClient" ref="sqlMapClient"/></bean></beans>〃这里意思很明显，调用base中声明的dateSource在这里区分那个dao需要调用那个数据源，在这里注意看黄色标记的部分3、applicationContext_manage.xml<?xml version="1.0" encoding="UTF-8”?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance”xmlns:aop="/schema/aop”xmlns:tx="/schema/tx”xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.0.xsd/schema/tx/schema/tx/spring-tx-3.0.xsd/schema/aop/schema/aop/spring-aop-3.0.xsd"><bean id="loginManage" class="com.vstsoft.da.system.manage.imp.LoginManageImpl"> <property name="loginDao"><ref bean="loginDao" /></property></bean><bean id="ans01Manage" class="com.vstsoft.da.system.manage.imp.Ans01ManageImpl"><property name="ans01Dao"><ref bean="ans01Dao" /></property></bean><bean id="ans03Manage" class="com.vstsoft.da.system.manage.imp.Ans03ManageImpl"> <property name="ans03Dao"><ref bean="ans03Dao" /></property></bean><bean id="jianManage" parent="baseTransactionProxy"><property name="target"><bean class="com.vstsoft.da.jian.manage.impl.JianManageImpl"><property name="jianDao"><ref bean="jianDao" /></property><property name="zujianDao"><ref bean="zujianDao" /></property><property name="ans03Dao"><ref bean="ans03Dao"/></property><property name="juanDao"><ref bean="juanDao" /></property><property name="heDao"><ref bean="heDao" /></property></bean></property></bean><bean id="juanManage" parent="baseTransactionProxy"><property name="target"><bean class="com.vstsoft.da.juan.manage.impl.JuanManageImpl"><property name="jianDao"><ref bean="jianDao" /></property><property name="juanDao"><ref bean="juanDao" /></property><property name="heDao"><ref bean="heDao" /> </property><property name="ans03Dao"><ref bean="ans03Dao"/> </property> </bean> </property> </bean> <bean id="heManage" parent="baseTransactionProxy"><property name="target"><bean class="com.vstsoft.da.he.manage.impl.HeManageImpl"><property name="heDao"> <ref bean="heDao" /> </property><property name="juanDao"><ref bean="juanDao" /> </property><property name="jianDao"><ref bean="jianDao" /> </property> </bean> </property> </bean> <beanid="jianSuoManageclass="com.vstsoft.da.jiansuo.manage.impl.JianSuoManageImpl"><property name="jianSuoDao"><ref bean="jianSuoDao"/> </property> </bean></beans>调用的dao 五、sqlMap 的配置文件1、sqlmap_base.xml<?xml version ="1.0" encoding ="UTF-8" ?><! DOCTYPE sqlMapConfig PUBLIC "-////DTD〃这个配置文件没有什么特别需要介绍的，就是给manage 配置需要SQL Map Config2.0//EN""/dtd/sql-map-config-2.dtd" <sqlMapConfig >2、其他的sqlmap 都没什么特别，重点说一下最后一个 sqlmap_jian_zujian.xml<? xml version ="1.0" encoding ="UTF-8" ?> <! DOCTYPE sqlMap PUBLIC"-////DTD SQL Map 2.0//EN""/dtd/sql-map-2.dtd < sqlMap >//这里的resultMap 是指，将对方的库里的数据转换成我们库里对应的表，意思也就是说比如对方有个表将and00，我们需要将对方的数据转换成我们的数据，我们用 and01接收查出的数据 <resultMap id ="and01Result" class ="and01" >//这下面的操作就是将对方数据库表中的字段，转换成我们库里对应表的字段，这个你懂得！<result column ="QXBM"property="cnd112"jdbcType= "VARCHAR" /><result column ="DWDM"property="cnd102"jdbcType= "VARCHAR" />< result column = "DWMC"property="cnd103"jdbcType= "VARCHAR" /> < result column = "DWJC"property="cnd104" jdbcType = "VARCHAR" /><result column ="DJZH" property ="cnd105" jdbcType = "VARCHAR" /><result column ="BZHM" property="cnd106"jdbcType= "VARCHAR" /><result column ="BXH" property="cnd116" jdbcType ="VARCHAR" /> <sqlMap resource ="sqlmap/sqlmap_bean.xml" /><sqlMap resource ="sqlmap/sqlmap_system.xml"/> <sqlMap resource ="sqlmap/sqlmap_jian.xml" /> <sqlMap resource = "sqlmap/sqlmap_juan.xml" /><sqlMap resource ="sqlmap/sqlmap_he.xml" /><sqlMapresource="sqlmap/sqlmap_jiansuo.xml"/><sqlMap resource = "sqlmap/sqlmap_jian_zujian.xml"</ sqlMapConfig >//这里没什么特别，就是加载一些需要用的sqlmap/><result column ="XM" property ="cnd107" jdbcType = "VARCHAR" /><result column ="USERNAME" property ="cnd113" jdbcType ="VARCHAR"/> <result column ="BLRQ" property ="cnd114" jdbcType ="DATE" /> </ resultMap ><select id ="sx" resultMap ="and01Result" > select * from sysdalog</ select ></ sqlMap >六、将这些东西配置好，这个加载多个数据源的操作就完成了，Action 中的代码就不贴了，很简单，用dao直接调用就行了，在配置文件中都已经配置好了，所以不需要费多大劲！七、好了，这就是整个配置过程，希望对你有所帮助，谢谢！制里①簇。

Spring多数据源配置（转）

Spring多数据源配置（转）同⼀个项⽬有时会涉及到多个数据库，也就是多数据源。

多数据源⼜可以分为两种情况：1）两个或多个数据库没有相关性，各⾃独⽴，其实这种可以作为两个项⽬来开发。

⽐如在游戏开发中⼀个数据库是平台数据库，其它还有平台下的游戏对应的数据库；2）两个或多个数据库是master-slave的关系，⽐如有mysql搭建⼀个 master-master，其后⼜带有多个slave；或者采⽤MHA搭建的master-slave复制；⽬前我所知道的 Spring 多数据源的搭建⼤概有两种⽅式，可以根据多数据源的情况进⾏选择。

1. 采⽤spring配置⽂件直接配置多个数据源⽐如针对两个数据库没有相关性的情况，可以采⽤直接在spring的配置⽂件中配置多个数据源，然后分别进⾏事务的配置，如下所⽰：<context:component-scan base-package="net.aazj.service,net.aazj.aop" /><context:component-scan base-package="net.aazj.aop" /><context:property-placeholder location="classpath:config/db.properties" /><bean name="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close"><property name="url" value="${jdbc_url}" /><property name="username" value="${jdbc_username}" /><property name="password" value="${jdbc_password}" /><property name="initialSize" value="0" /><property name="maxActive" value="20" /><property name="maxIdle" value="20" /><property name="minIdle" value="0" /><property name="maxWait" value="60000" /></bean><bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"><property name="dataSource" ref="dataSource" /><property name="configLocation" value="classpath:config/mybatis-config.xml" /><property name="mapperLocations" value="classpath*:config/mappers/**/*.xml" /></bean><bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource" ref="dataSource" /></bean><tx:annotation-driven transaction-manager="transactionManager" /><bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"><property name="basePackage" value="net.aazj.mapper" /><property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/></bean><aop:aspectj-autoproxy/><bean name="dataSource_2" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close"><property name="url" value="${jdbc_url_2}" /><property name="username" value="${jdbc_username_2}" /><property name="password" value="${jdbc_password_2}" /><property name="initialSize" value="0" /><property name="maxActive" value="20" /><property name="maxIdle" value="20" /><property name="minIdle" value="0" /><property name="maxWait" value="60000" /></bean><bean id="sqlSessionFactory_slave" class="org.mybatis.spring.SqlSessionFactoryBean"><property name="dataSource" ref="dataSource_2" /><property name="configLocation" value="classpath:config/mybatis-config-2.xml" /><property name="mapperLocations" value="classpath*:config/mappers2/**/*.xml" /></bean><bean id="transactionManager_2" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource" ref="dataSource_2" /></bean><tx:annotation-driven transaction-manager="transactionManager_2" /><bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"><property name="basePackage" value="net.aazj.mapper2" /><property name="sqlSessionFactoryBeanName" value="sqlSessionFactory_2"/></bean>如上所⽰，我们分别配置了两个 dataSource，两个sqlSessionFactory，两个transactionManager，以及关键的地⽅在于MapperScannerConfigurer 的配置——使⽤sqlSessionFactoryBeanName属性，注⼊不同的sqlSessionFactory的名称，这样的话，就为不同的数据库对应的 mapper 接⼝注⼊了对应的 sqlSessionFactory。

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配置数据源和注解开发

Spring配置数据源和注解开发Spring配置数据源数据源（连接池）的作⽤数据源(连接池)是提⾼程序性能如出现的事先实例化数据源，初始化部分连接资源使⽤连接资源时从数据源中获取使⽤完毕后将连接资源归还给数据源常见的数据源(连接池)：DBCP、C3P0、BoneCP、Druid等开发步骤①导⼊数据源的坐标和数据库驱动坐标②创建数据源对象③设置数据源的基本连接数据④使⽤数据源获取连接资源和归还连接资源现在spring项⽬中的pom中导⼊jar包坐标<dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.0.3.RELEASE</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.32</version></dependency><dependency><groupId>c3p0</groupId><artifactId>c3p0</artifactId><version>0.9.1.2</version></dependency><dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.0.9</version></dependency></dependencies>第三⽅jar包坐标导⼊⼿动创建c3p0的数据源@Test//⼿动创建c3p0的数据源public void testTwo() throws Exception {ComboPooledDataSource dataSource = new ComboPooledDataSource();dataSource.setDriverClass("com.mysql.jdbc.Driver");dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/book");dataSource.setUser("zhao");dataSource.setPassword("123456");Connection conn = dataSource.getConnection();System.out.println(conn);conn.close();}⼿动创建c3p0的数据源⼿动创建Driver数据源@Test//⼿动创建Driver数据源public void TestOne() throws Exception{DruidDataSource dataSource = new DruidDataSource();dataSource.setDriverClassName("com.mysql.jdbc.Driver");dataSource.setUrl("jdbc:mysql://localhost:3306/book");dataSource.setUsername("zhao");dataSource.setPassword("123456");Connection conn = dataSource.getConnection();System.out.println(conn);conn.close();}⼿动创建Driver数据源提取数据库信息放到配置⽂件中读取上⾯都是我们⼿动创建然后配置信息都在java源代码中这样会导致以后如果修改数据库的链接信息不⽅便后期更改数据库的要找到源码修改太⿇烦提取jdbc.properties配置⽂件jdbc.driver=com.mysql.jdbc.Driverjdbc.url=jdbc:mysql://localhost:3306/bookername=zhaojdbc.password=123456在设置properties的时候,⾥⾯的内容不可以加上分号读取jdbc.properties配置⽂件创建连接池//读取jdbc.properties配置⽂件创建连接池@Testpublic void TestThree() throws Exception {ResourceBundle rb = ResourceBundle.getBundle("jdbc"); // 指定连接的驱动⽅式ComboPooledDataSource dataSource = new ComboPooledDataSource();dataSource.setDriverClass(rb.getString("jdbc.driver"));dataSource.setJdbcUrl(rb.getString("jdbc.url"));dataSource.setUser(rb.getString("ername"));dataSource.setPassword(rb.getString("jdbc.password"));Connection conn = dataSource.getConnection();System.out.println(conn);}上⾯都不是Spring的容器来配置数据源的下⾯我们使⽤spring容器创建数据源Spring配置数据源可以将DataSource的创建权交由Spring容器去完成DataSource有⽆参构造⽅法，⽽Spring默认就是通过⽆参构造⽅法实例化对象的DataSource要想使⽤需要通过set⽅法设置数据库连接信息，⽽Spring可以通过set⽅法进⾏字符串注⼊applicationContext.xml<bean id="dataSource"class="boPooledDataSource"><property name="driverClass" value="com.mysql.jdbc.Driver"/><property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"/><property name="user" value="root"/><property name="password" value="root"/></bean>测试从容器当中获取数据源ApplicationContext applicationContext = newClassPathXmlApplicationContext("applicationContext.xml");DataSource dataSource = (DataSource)applicationContext.getBean("dataSource");Connection connection = dataSource.getConnection();System.out.println(connection);上⾯的⽅法是没有抽取jdbc的配置⽂件,我们将配置⽂件抽取到properties⽂件中将数据源的配置抽取到properties中,抽取到xml解析⽐较费劲,properties是键值对的⽅式,Spring容器提取配置⽂件到Properties中然后抽取jdbc配置⽂件applicationContext.xml加载jdbc.properties配置⽂件获得连接信息。

spring动态配置多数据源

起因：在当前我手上的一个项目中需要多个数据源,并且来自于不同类型的数据库... 因为很多历史原因.这个项目的住数据源是MySQL,整个系统的CURD都是操作的这个数据库.但是还有另外两个用于数据采集的数据库: MSSQL,ACCESS.还好只是用于数据采集，在事务上可以不要跨数据库了，这一点节省了好多的工作量.环境：我搭建的测试环境是spring2.5.6+hibernate3.2思路：动态切换数据源确切的来说是在同一类型数据库的情况下的。

意思就是说, 在系统中的使用的数据库分布在多台数据库服务器或者在同台服务器上的多个数据库. 在运行时期间根据某种标识符来动态的选择当前操作的数据库.1.数据源是相同类型的数据库: 一个SessionFactory+动态数据源+一个事务管理器2.数据源是不同类型的数据库: 根据类型配置多套SessionFactory模拟：两个mysql数据源+一个Access数据源实现：1.切换数据源需要标识符,标识符是Object类型package lhp.example.context;public enum DBType {dataSource1, dataSource2;}2.然后创建一个用于切换数据源(设置或者获得上下文)的工具类复制代码package lhp.example.context;public class ContextHolder {private static final ThreadLocal<Object> holder = new ThreadLocal<Object>();public static void setDbType(DBType dbType) {holder.set(dbType);}public static DBType getDbType() {return (DBType) holder.get();}public static void clearDbType() {holder.remove();}}复制代码3.创建动态数据源类,继承org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource这个类. 复制代码package lhp.example.context;import java.util.logging.Logger;import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;public class DynamicDataSource extends AbstractRoutingDataSource {public static final Logger logger =Logger.getLogger(DynamicDataSource.class.toString());@Overrideprotected Object determineCurrentLookupKey() {DBType key = ContextHolder.getDbType();//获得当前数据源标识符//("当前数据源:" + key);return key;}}复制代码4.然后配置多个数据源复制代码<bean id="dataSource1" class="boPooledDataSource"> <property name="driverClass" value="com.mysql.jdbc.Driver"/><property name="jdbcUrl" value="jdbc:mysql://127.0.0.1:3306/dec"/><property name="user" value="root"/><property name="password" value=""/></bean><bean id="dataSource2" class="boPooledDataSource"> <property name="driverClass" value="com.mysql.jdbc.Driver"/><property name="jdbcUrl" value="jdbc:mysql://127.0.0.1:3306/lms"/><property name="user" value="root"/><property name="password" value=""/></bean><bean id="dataSource3" class="boPooledDataSource"> <property name="driverClass" value="sun.jdbc.odbc.JdbcOdbcDriver"/><property name="jdbcUrl" value="jdbc:odbc:accessTest"/><property name="user" value="administrator"/><property name="password" value="XLZX0309"/></bean><bean id="mysqlDynamicDataSource"class="lhp.example.context.DynamicDataSource"><property name="targetDataSources"><map key-type="lhp.example.context.DBType"><entry key="dataSource1" value-ref="dataSource1"/><entry key="dataSource2" value-ref="dataSource2"/></map></property><property name="defaultTargetDataSource" ref="dataSource1"/></bean>复制代码5.配置sessionFactory复制代码<bean id="mysqlSessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"><property name="dataSource" ref="mysqlDynamicDataSource"/><property name="hibernateProperties"><props><prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop><prop key="hibernate.show_sql">true</prop><prop key="hibernate.hbm2ddl.auto">update</prop><prop key="hibernate.query.substitutions">true 1, false 0</prop></props></property></bean><bean id="aceessSessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"><property name="dataSource" ref="dataSource3"/><property name="hibernateProperties"><props> <prop key="hibernate.dialect">org.hibernate.dialect.SQLServerDialect</prop><prop key="hibernate.jdbc.batch_size">30</prop><prop key="hibernate.jdbc.fetch_size">50</prop><prop key="hibernate.show_sql">true</prop><prop key="hibernate.format_sql">false</prop><prop key="hibernate.hbm2ddl.auto">update</prop><prop key="hibernate.query.substitutions">true 1, false 0</prop><prop key="e_reflection_optimizer">true</prop> </props></property></bean>复制代码6.测试用例复制代码package lhp.example.junit;import static org.junit.Assert.*;import java.sql.DatabaseMetaData;import lhp.example.context.ContextHolder;import lhp.example.context.DBType;import org.hibernate.Session;import org.hibernate.SessionFactory;import org.junit.Before;import org.junit.Test;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;public class ServiceTest {private ApplicationContext context;//三个数据源的URLprivate String dataSource1_URL = "jdbc:mysql://127.0.0.1:3306/dec";private String dataSource2_URL = "jdbc:mysql://127.0.0.1:3306/lms";private String dataSource3_URL = "jdbc:odbc:accessTest";private SessionFactory mysqlSessionFactory;private SessionFactory aceessSessionFactory;@Beforepublic void setUp() throws Exception {// 选择数据源初始化springContextHolder.setDbType(DBType.dataSource1);//String[] xmlFiles = new String[] {"applicationContext-dataSource.xml","applicationContext-hibernate.xml","applicationContext-spring.xml" };//context = new ClassPathXmlApplicationContext(xmlFiles);//mysqlSessionFactory = (SessionFactory) context.getBean("mysqlSessionFactory"); aceessSessionFactory = (SessionFactory) context.getBean("aceessSessionFactory");}@SuppressWarnings("deprecation")@Testpublic void mysqlDataSourceTest() {try {Session mysqlSession = mysqlSessionFactory.openSession();// 获得数据库元数据DatabaseMetaData meatData = mysqlSession.connection().getMetaData();// 默认启动数据源dataSource1//断言当前数据源URL是否是dataSource1的URLassertEquals(dataSource1_URL, meatData.getURL());// 切换到数据源dataSource2ContextHolder.setDbType(DBType.dataSource2);mysqlSession = mysqlSessionFactory.openSession();meatData = mysqlSession.connection().getMetaData();//断言当前数据源URL是否是dataSource2的URLassertEquals(dataSource2_URL, meatData.getURL());} catch (Exception e) {e.printStackTrace();}}@SuppressWarnings("deprecation")@Testpublic void accessDataSourceTest() {try {Session accessSession = aceessSessionFactory.openSession();// 获得数据库元数据DatabaseMetaData meatData =accessSession.connection().getMetaData();//断言当前数据源URL是否是dataSource3的URL assertEquals(dataSource3_URL, meatData.getURL());} catch (Exception e) {e.printStackTrace();}}}复制代码7.测试结果spring动态配置多数据源，即在大型应用中对数据进行切分，并且采用多个数据库实例进行管理，这样可以有效提高系统的水平伸缩性。

spring配置多数据源

spring配置多数据源没有必要在Spring的XML配置文件中注册所有的映射器。

相反，你可以使用一个MapperScannerConfigurer,它将会查找类路径下的映射器并自动将它们创建成MapperFactoryBeans。

要创建MapperScannerConfigurer，可以在Spring的配置中添加如下代码：Xml代码<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"& gt; <propery name="basePackage"value="org.mybatis.spring.sample.mapper"/> </bean> basePackage属性是让你为映射器接口文件设置基本的包路径。

你可以使用分号或逗号作为分隔符设置多于一个的包路径。

每个映射器将会在指定的包路径中递归地被搜索到。

注意，没有必要去指定SqlSessionFactory或SqlSessionTemplate，因为MapperScannerConfigurer将会创建MapperFactoryBean，之后自动装配。

但是，如果你使用了一个以上的DataSource(因此，也是多个的SqlSessionFactory),那么自动装配可能会失效。

这种情况下，你可以使用sqlSessionFactory 或sqlSessionTemplate属性来设置正确的工厂/模板(例子在下面)。

MapperScannerConfigurer支持过滤由指定的创建接口或注解创建映射器。

annotationClass属性指定了要寻找的注解名称。

markerInterface属性指定了要寻找的父接口。

如果两者都被指定了，加入到接口中的映射器会匹配两种标准。

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类。