`

spring 管理多数据源

 
阅读更多

   最近开发一个数据同步的小功能，需要从A主机的Oracle数据库中把数据同步到B主机的Oracle库中。当然能够用dmp脚本或者SQL脚本是最好，但是对于两边异构的表结构来说，直接导入不可行。然后在需要实时同步的情况下用存储过程也不可行了。写一个数据同步的小程序是个不错的选择。使用框架的封装和连接池是必须的，Spring是首选，这里我们同样需要Spring的多数据源连接配置方式。 其实再进行项目开发的时候，一个项目有可能不止用到一个数据源，为了提高数据库的水平伸缩性，需要对多个数据库实例进行管理，需要配置多数据源。（4种数据库，不同的URL）

 

     1. 配置多个数据源

     这里以两个c3p0数据库连接池的数据源作为实例。在Spring框架下使用c3p0的数据库需要加入c3p0-0.9.1.2.jar(现在最新的)这个支持包。这里以数据同步项目为例：

   数据来源库的连接池数据源配置：

Xml代码  收藏代码
  1. <bean id="dataSourceFrom" class="com.mchange.v2.c3p0.ComboPooledDataSource">  
  2.     <property name="driverClass" value="${jdbc.driver}" />  
  3.     <property name="jdbcUrl" value="${jdbc.from.url}" />  
  4.     <property name="user" value="${jdbc.from.username}" />  
  5.     <property name="password" value="${jdbc.from.password}" />  
  6.     <property name="autoCommitOnClose" value="true" />  
  7.     <property name="checkoutTimeout" value="${cpool.checkoutTimeout}" />  
  8.     <property name="initialPoolSize" value="${cpool.minPoolSize}" />  
  9.     <property name="minPoolSize" value="${cpool.minPoolSize}" />  
  10.     <property name="maxPoolSize" value="${cpool.maxPoolSize}" />  
  11.     <property name="maxIdleTime" value="${cpool.maxIdleTime}" />  
  12.     <property name="acquireIncrement" value="${cpool.acquireIncrement}" />  
  13.     <property name="maxIdleTimeExcessConnections" value="${cpool.maxIdleTimeExcessConnections}" />  
  14. </bean>  

 数据插入库的连接池数据源配置：

Xml代码  收藏代码
  1. <bean id="dataSourceTo" class="com.mchange.v2.c3p0.ComboPooledDataSource">  
  2.     <property name="driverClass" value="${jdbc.driver}" />  
  3.     <property name="jdbcUrl" value="${jdbc.to.url}" />  
  4.     <property name="user" value="${jdbc.to.username}" />  
  5.     <property name="password" value="${jdbc.to.password}" />  
  6.     <property name="autoCommitOnClose" value="true" />  
  7.     <property name="checkoutTimeout" value="${cpool.checkoutTimeout}" />  
  8.     <property name="initialPoolSize" value="${cpool.minPoolSize}" />  
  9.     <property name="minPoolSize" value="${cpool.minPoolSize}" />  
  10.     <property name="maxPoolSize" value="${cpool.maxPoolSize}" />  
  11.     <property name="maxIdleTime" value="${cpool.maxIdleTime}" />  
  12.     <property name="acquireIncrement" value="${cpool.acquireIncrement}" />  
  13.     <property name="maxIdleTimeExcessConnections" value="${cpool.maxIdleTimeExcessConnections}" />  
  14. </bean>  

   注意：上面url，user，password等值是从classpath下的jdbc.properties中取得的。

   通过Spring获取属性文件中的值，以供配置文件使用：

Xml代码  收藏代码
  1. <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
  2.     <property name="locations" value="classpath:jdbc.properties" />  
  3. </bean>  

 

     2. 扩展Spring的AbstractRoutingDataSource抽象类，实现动态数据源。

    AbstractRoutingDataSource中的抽象方法determineCurrentLookupKey是实现数据源的route的核心.这里对该方法进行Override。

Java代码  收藏代码
  1. public class DynamicDataSource extends AbstractRoutingDataSource{  
  2.   
  3.     @Override  
  4.     protected Object determineCurrentLookupKey() {  
  5.         return DBContextHolder.getDBType();  
  6.     }  
  7. }  

   上下文DbContextHolder为一线程安全的ThreadLocal，具体代码如下：

Java代码  收藏代码
  1. public class DBContextHolder{  
  2.     public static final String DATA_SOURCE_FROM = "dataSourceFrom";  
  3.     public static final String DATA_SOURCE_TO = "dataSourceTo";  
  4.       
  5.     private static final ThreadLocal<String> contextHolder = new ThreadLocal<String>();  
  6.       
  7.     public static void setDBType(String dbType) {  
  8.         contextHolder.set(dbType);  
  9.     }  
  10.       
  11.     public static String getDBType() {  
  12.         return contextHolder.get();  
  13.     }  
  14.       
  15.     public static void clearDBType() {  
  16.         contextHolder.remove();  
  17.     }  
  18. }  

 

    3.配置动态数据源

 将DynamicDataSource Bean加入到Spring的上下文xml配置文件中去，同时配置DynamicDataSource的targetDataSources(多数据源目标)属性的Map映射。

Xml代码  收藏代码
  1. <bean id="dynamicDataSource" class="datasource.DynamicDataSource" >  
  2.     <!-- 通过key-value的形式来关联数据源 -->  
  3.     <property name="targetDataSources">  
  4.         <map>  
  5.             <entry value-ref="dataSourceFrom" key="dataSourceFrom"></entry>  
  6.             <entry value-ref="dataSourceTo" key="dataSourceTo"></entry>  
  7.         </map>  
  8.     </property>  
  9.     <property name="defaultTargetDataSource" ref="dataSourceFrom" />  
  10. </bean>   

 

    4.使用动态数据源

    例子中DynamicDataSource是继承与AbstractRoutingDataSource，而AbstractRoutingDataSource又是继承于org.springframework.jdbc.datasource.AbstractDataSource，AbstractDataSource实现了统一的DataSource接口，所以DynamicDataSource同样可以当一个DataSource使用。

 在Spring的JdbcTemplate使用动态数据源的配置示例：

Xml代码  收藏代码
  1. <!-- JdbcTemplate使用动态数据源的配置 -->  
  2. <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">  
  3.     <property name="dataSource">  
  4.         <ref bean="dynamicDataSource" />  
  5.     </property>  
  6. </bean>  
  7.   
  8. <!-- 对JdbcTemplate的应用封装类 -->  
  9. <bean id="sqlBaseDAO" class="com.whty.dao.BaseDAOImpl">  
  10.     <property name="jdbcTemplate">  
  11.         <ref bean="jdbcTemplate" />  
  12.     </property>  
  13. </bean>  

在ORM框架Hibernate中的使用配置示例：

Xml代码  收藏代码
  1. <bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">  
  2.     <!-- 和普通的dataSource用法一样 -->  
  3.     <property name="dataSource" ref="dynamicDataSource" />  
  4.     <property name="configLocations" value="classpath:hibernate.cfg.xml" />  
  5.     <property name="hibernateProperties">  
  6.         <props>  
  7.             <prop key="hibernate.dialect">${hibernate.dialect}</prop>     
  8.     </property>  
  9. </bean>  

   

    5.事务管理

使用动态数据源的时候，可以看出和使用单数据源的时候相比，在使用配置上几乎没有差别，在进行性事务管理配置的时候也没有差别：

使用Spring的JdbcTemplate的事务管理配置示例：

Xml代码  收藏代码
  1. <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
  2.     <property name="dataSource" ref="dynamicDataSource" />  
  3. </bean>  
  4.   
  5. <bean id="sqlBaseDAOProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">  
  6.     <property name="transactionManager" ref="transactionManager" />  
  7.     <property name="target" ref="sqlBaseDAO" />  
  8.     <property name="transactionAttributes">  
  9.         <props>  
  10.             <prop key="insert*">PROPAGATION_REQUIRED</prop>  
  11.             <prop key="*">PROPAGATION_REQUIRED,readOnly</prop>  
  12.         </props>  
  13.     </property>  
  14. </bean>  

 

 

使用Hibernate时的事务管理配置示例：

Xml代码  收藏代码
  1. <tx:annotation-driven transaction-manager="transactionManager"/>  
  2.   
  3. <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
  4.     <property name="sessionFactory" ref="sessionFactory" />  
  5. </bean>  

 

 

    6.动态数据源的管理控制

如何选择控制每个业务中需要的具体数据源，可是使用手动控制：

Java代码  收藏代码
  1. ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");  
  2. BaseDAO dao = (BaseDAO) context.getBean("sqlBaseDAO", BaseDAOImpl.class);  
  3.   
  4. try {  
  5.     DBContextHolder.setCustomerType(DBContextHolder.DATA_SOURCE_FROM);  
  6.     System.err.println(dao.select("select count(*) sum from TEST t ").get(0).get("SUM"));  
  7.     DBContextHolder.setCustomerType(DBContextHolder.DATA_SOURCE_TO);  
  8.     System.err.println(dao.select("select count(*) sum from TEST t ").get(0).get("SUM"));  
  9.       
  10. } catch (Exception e) {  
  11.     e.printStackTrace();  
  12. }  

也可以采用AOP的控制方式：

Java代码  收藏代码
  1. @Aspect  
  2. public class DynamicDataSourceAspect {  
  3.     @Pointcut("execution (public service.impl..*.*(..))")  
  4.     public void serviceExecution(){}  
  5.       
  6.     @Before("serviceExecution()")  
  7.     public void setDynamicDataSource(JoinPoint jp) {  
  8.         for(Object o : jp.getArgs()) {  
  9.             //处理具体的逻辑 ，根据具体的境况CustomerContextHolder.setCustomerType()选取DataSource  
  10.         }  
  11.     }  
  12. }  

 

  7.总结

   通过扩展Spring的AbstractRoutingDataSource可以很好的实现多数据源的rout效果，而且对扩展更多的数据源有良好的伸缩性，只要增加数据源和修改DynamicDataSource的targetDataSources属性配置就好。在数据源选择控制上，可以采用手动控制(业务逻辑并不多的时候)，也可以很好的用AOP的@Aspect在Service的入口加入一个切面@Pointcut，在@Before里判断JoinPoint的类容选定特定的数据源。

 

 

 

 

以上是参考别人的。下面贴自己的代码（主要是INSERT 后面VALUES值是动态的拼接，表名和字段都是动态的，网上没搜到，自己写的，还没试，逻辑上是这样的）

 

/**
	 * @author wj
	 * @date 2016-8-19
	 * 切换不同的数据源，同步远程最新数据到本地
	 * @param tableName 表名
	 * @param stcd 字段
	 * @param dbType 数据库类型
	 */
	private void syncOne(String tableName,String stcd,String dbType){
		
		
		if("oracle".equals(dbType)){ //如果远程数据库是ORACLE
			 DBContextHolder.setDBType(DBContextHolder.dataSourceTo);  
			
			String hql = "select MAX( TM ) from "+ tableName +" WHERE STCD = '"+stcd+"'";
			List r = dao.find(hql);
			Date latestTime = (Date)r.get(0);
			
			
			
		   DBContextHolder.setDBType(DBContextHolder.dataSourceOracle);  //切换到远程ORACLE数据库，查询远程最新数据
		   
		   String remoteTableName = tableName.replace("YZSQ", "ST");
		   String gtTimeResultSql = "select * from "+remoteTableName+" where STCD= '"+ stcd +"' and tm> :tm"  ;
		   Map<String,Object> params = Maps.newHashMap();
		   params.put("tm", latestTime);
		  List<Map> gtTimeResult = dao.findBySql(gtTimeResultSql, params);
		   
		  DBContextHolder.setDBType(DBContextHolder.dataSourceTo);   //切换到本地目标数据库，插入数据到本地
		   for(Map map: gtTimeResult){
			 StringBuilder inserSql = 	new StringBuilder(" insert into "+tableName+" values (");
			 int i=0;
			   for (Object key : map.keySet()) {
				   i++;
				   System.out.println("key= "+ String.valueOf(key) + " and value= " + map.get(key));
				   Object value = map.get(key);
				   if(i< map.keySet().size()){
					   if(value instanceof String){
						   inserSql.append("'"+(String)value+"',");
					   }else if(value instanceof Date){
						   String pattern = "yyyy-MM-dd HH24:mi:ss";
						   Date converted = (Date)value;
						   inserSql.append("to_date('"+DateUtil.dateToString(converted, pattern)  +"', '"+pattern+"'),");
					   }else if(value instanceof Integer){
						   inserSql.append((Integer)value+",");
					   }else {
						   inserSql.append(value+",");
					   }
				   }else{
					   
					   if(value instanceof String){
						   inserSql.append("'"+(String)value+"')");
					   }else if(value instanceof Date){
						   String pattern = "yyyy-MM-dd HH24:mi:ss";
						   Date converted = (Date)value;
						   inserSql.append("to_date('"+DateUtil.dateToString(converted, pattern)  +"', '"+pattern+"') )");
					   }else if(value instanceof Integer){
						   inserSql.append((Integer)value+")");
					   }else {
						   inserSql.append(value+")");
					   }
				   }
				   
				   dao.executeSql(inserSql.toString());
				   
				  }
		   }
		   
			//String inserSql = 	" insert into "+tableName+" values "+
				
			
		}else if("mysql".equals(dbType)){//如果远程数据库是mysql
			
			
			
		}
		
	}

 （或者，用存储过程代替，但是sqlserver的openquery只能返回一条记录，好像ODBC换成OLEDB可行，没试）

 

USE [SQB]
GO
/****** Object:  StoredProcedure [dbo].[PROC_SYNC_ONE_LATEST_DATA]    Script Date: 08/19/2016 18:06:32 ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO


-- =============================================
-- Author:		<Author,,Name>
-- Create date: <Create Date,,>
-- Description:	查询各个表的某闸的最大时间。远程表里，大于这个时间的结果返回过来。在本地表插入返回记录。-插入完成。视图再查就行
-- =============================================
ALTER PROCEDURE [dbo].[PROC_SYNC_ONE_LATEST_DATA] ---单表单闸的
	 @tableName varchar(50),
	 @STCD varchar(50),
	 @dbType varchar(50)
 AS
      BEGIN
          DECLARE @latestTime datetime
          DECLARE @remoteTableName varchar(50)
          DECLARE @sql nvarchar(1000);
          DECLARE @insertSql nvarchar(1000); --远程表copy到本地
          
        IF (@dbType='oracle')
			BEGIN
			 
				
					SET @sql='select @latestTime=MAX( TM ) from '+ @tableName +' WHERE STCD = '''+@STCD+'''';
				
				exec sp_executesql @sql,N'@latestTime datetime output',@latestTime out --本表最近时间
				
				SET @remoteTableName = REPLACE (@tableName,'YZSQ','ST')
		  
				
				SET @insertSql=' insert into '+@tableName+' select * from '+
				'  openquery(yzsq,''select * from  '+@remoteTableName+' where STCD= '''+ @STCD +'''  and tm>'+@latestTime+''')'
				
				exec(@insertSql)
				
		  
			END
		ELSE IF(@dbType='mysql')
			BEGIN
			
			
				SET @sql='select @latestTime=MAX( time ) from '+ @tableName ;
				
				exec sp_executesql @sql,N'@latestTime datetime output',@latestTime out --本表最近时间
				
				SET @insertSql=' insert into '+@tableName +'select * from '+
				'  openquery(mysql,select * from  '+@tableName+' where  time>'+@latestTime
			
				exec(@insertSql)
				
			END
		ELSE --sqlserver
			BEGIN
			
				SET @sql='select @latestTime=MAX( time ) from '+ @tableName ;
				
				exec sp_executesql @sql,N'@latestTime datetime output',@latestTime out --本表最近时间
				
				SET @insertSql=' insert into '+@tableName +'select * from '+
				'  openquery(192.168.100.101,select * from  '+@tableName+' where  datetime>'+@latestTime
			
				exec(@insertSql)
			END   
		
	 END

 

分享到：
| java的缺点，深有体会 现在
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    spring boot多数据源配置

    在Spring Boot应用中，多数据源配置是一项关键的技术，它允许我们同时管理多个数据库，比如主库和从库，或者不同类型的数据库。本教程将详细阐述如何在Spring Boot项目中实现这一功能，从数据源配置、实体管理到...

    Spring Boot多数据源(支持Spring声明式事务切换和回滚).pdf

    在本文中，我们将深入探讨如何实现动态数据源切换，支持Spring声明式事务管理，并讨论多数据源回滚策略。以下是对这些知识点的详细说明： 1. **动态数据源切换**： - 通过AspectJ实现数据源的动态切换，可以设置在...

    spring整合多数据源完整实例

    总结来说，Spring整合多数据源是一个涉及到配置、事务管理和代码逻辑设计的过程。通过正确配置数据源，动态选择数据源，以及妥善处理事务，我们可以构建起一个高效、灵活的多数据源系统。这个实例提供了一个基础的...

    Springcloud 多数库 多数据源整合,查询动态切换数据库

    3. **Spring Cloud Config Server**：为了更好地管理和维护多数据源的配置，我们可以结合Spring Cloud Config Server，将配置集中存储并管理。这样，当需要更新数据库配置时，只需更改Config Server上的配置，服务端...

    spring boot 2多数据源，里面有hibernate和mybatis的多数据源代码

    在Spring Boot 2框架中，实现多数据源的配置是一项重要的任务，特别是在大型企业级应用中，可能需要连接到不同的数据库来满足不同业务的需求。在这个项目中，我们有两个主要的数据访问技术：Hibernate和MyBatis，...

    spring 动态多数据源配置代码

    下面将详细介绍Spring动态多数据源配置的相关知识点。 1. **为什么要使用多数据源**： 在实际项目中，可能需要连接到不同的数据库，例如，一个用于存储主业务数据，另一个用于日志记录或数据分析。通过多数据源...

    spring多数据源

    Spring多数据源允许我们在一个应用中同时管理多个数据库连接，通过切换不同的数据源来满足不同业务的需求。实现这一功能的关键在于Spring的DataSourceTransactionManager和AbstractRoutingDataSource。 1. **...

    spring整合mybatis多数据源

    当我们需要处理多个数据源时，例如在分布式系统或读写分离的场景下，Spring整合MyBatis的多数据源切换就显得尤为重要。这个"spring整合mybatis多数据源"的示例提供了可运行的代码，帮助开发者理解和实践这一功能。 ...

    Spring多数据源分布式事务管理

    在大型分布式系统中，往往需要处理多个数据源，这就涉及到了Spring多数据源的配置和管理。同时，为了保证数据的一致性，分布式事务的管理也是必不可少的。在这个场景下，Atomikos作为一款开源的JTA（Java ...

    java spring 多数据源

    本教程将深入探讨如何在Spring中配置和管理多个数据源，并以MySQL为例进行实战演示。 首先，我们需要理解Spring Boot对数据源的默认支持。Spring Boot通过`spring.datasource.*`的配置属性简化了数据库连接的设置，...

    springAop多数据源

    在这个场景中，我们将关注Spring的两个重要概念：多数据源和AOP，以及如何利用Spring JdbcTemplate进行数据库操作，并通过JUnit进行测试。 首先，"SpringAop多数据源"指的是在同一个应用程序中同时处理多个不同的...

    SpringBoot-SpringData-多数据源

    Spring Boot 和 Spring Data 联合使用，使得多数据源的配置和管理变得简单易行。通过合理的配置和编程，可以有效地管理和切换不同数据源，满足复杂的企业级应用需求。同时，多数据源策略还有助于数据库的扩展和维护...

    spring3+springmvc+jpa+hibernate多数据源

    总之，"spring3+springmvc+jpa+hibernate多数据源"项目展示了如何在一个复杂的Java Web应用中，利用Spring框架的灵活性和JPA的便利性，高效地管理多个数据库。这样的设置对于处理多样化数据存储需求的企业级应用来说...

    基于Spring多数据源实例

    总之，实现基于Spring的多数据源动态切换是一项复杂但必要的任务，它涉及到数据库连接管理、事务控制、AOP编程等多个方面。通过理解上述步骤和原理，开发者可以更好地设计和实施适用于各种业务场景的多数据源解决...

    spring boot多数据源(AOP注解动态切换）

    在Spring Boot应用中，多数据源的配置与管理是一项重要的任务，特别是在大型系统中，可能需要连接到不同的数据库以满足不同业务的需求。本教程将详细讲解如何在Spring Boot项目中集成Druid连接池，并利用AOP注解实现...

    Spring配置多个数据源

    Spring框架提供了一种灵活的方式来配置和管理多个数据源，使得这种需求变得简单易行。本文将详细介绍如何在Spring应用中配置多个数据源。 首先，我们来理解数据源（DataSource）的概念。数据源是Java中用于存储...

    Spring Boot+Jpa多数据源配置Demo（支持不同数据库）

    在现代企业级应用程序开发中，数据源管理是一个关键部分，特别是在需要处理来自多个数据库的数据时。Spring Boot结合JPA（Java Persistence API）和JdbcTemplate，为开发者提供了灵活且强大的多数据源配置能力。本...

    spring,mybatis 对数据源配置与管理

    在企业级应用开发中，经常需要访问和操作多个数据库，这种需求促使了多数据源配置与管理在Spring框架和MyBatis持久层框架中的重要性。下面对这个主题的知识点进行详细说明。 1. **多数据源场景介绍** 在处理多数据...

    spring动态选择数据源

    6. **事务管理**: 需要注意的是，动态数据源与Spring的事务管理器配合使用时，需要确保事务管理器能够识别并正确处理多个数据源的情况。 7. **性能优化**: 选择高性能的数据源实现（如HikariCP）可以提高连接池的...

    SSM（Spring+SpringMVC+MyBatis）多数据源配置框架

    在多数据源配置中，Spring能够帮助管理不同的数据源，通过配置bean来切换和控制数据源的使用。 **SpringMVC** 是Spring框架的一部分，专为Web开发设计。它简化了模型-视图-控制器（Model-View-Controller，MVC）的...

Magicbox
Global site tag (gtag.js) - Google Analytics