spring动态创建，加载，使用多数据源

最新推荐文章于 2024-05-10 10:01:47 发布

置顶 qilin18

最新推荐文章于 2024-05-10 10:01:47 发布

阅读量1.7w

点赞数 8

文章标签：多数据源动态创建切换数据源

本文链接：https://blog.csdn.net/qilin18/article/details/17614005

版权

项目中我们经常会遇到多数据源的问题，尤其是数据同步或定时任务等项目更是如此。多数据源让人最头痛的，不是配置多个数据源，而是如何能灵活动态的切换数据源。例如在一个spring和hibernate的框架的项目中，我们在spring配置中往往是配置一个dataSource来连接数据库，然后绑定给sessionFactory，在dao层代码中再指定sessionFactory来进行数据库操作。

正如上图所示，每一块都是指定绑死的，如果是多个数据源，也只能是下图中那种方式。

可看出在Dao层代码中写死了两个SessionFactory，这样日后如果再多一个数据源，还要改代码添加一个SessionFactory，显然这并不符合开闭原则。

那么正确的做法应该是

先说一下我的思路：

首先做一个创建数据源配置文件的类，专门用于创建数据源xml配置，叫ConfigFileCreator.java

其次，编写一个动态加载刚才创建的配置文件的类，叫 DynamicLoadBean.java。至此，创建的数据源到内存中已经完成。

第三，重点编写这个DynamicDataSource.java，该类主要是用来实现动态切换数据源，并通知容器。在这一块我选择了修改，AbstractRoutingDataSource.java，编写一个支持添加数据源对象的方法public void addDataSource(Object key,Object dataSource)

第四，写例子来测试

实现过程如下：

1.bean.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
				http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
				http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
	<!-- 自动扫描与装配bean -->
	<context:component-scan base-package="qilin"></context:component-scan>
	<!-- 使用外部的配置文件 -->
	<context:property-placeholder location="classpath:jdbc.properties" />
	<bean id="defaultDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
				<!-- 数据库连接信息 -->
				<property name="jdbcUrl" value="${jdbcUrl}"></property>
				<property name="driverClass" value="${driverClass}"></property>
				<property name="user" value="${username}"></property>
				<property name="password" value="${password}"></property>
	</bean>
	
	<bean id="dataSourceA" class="com.mchange.v2.c3p0.ComboPooledDataSource">
				<!-- 数据库连接信息 -->
				<property name="jdbcUrl" value="jdbc:mysql:///dynamictest"></property>
				<property name="driverClass" value="${driverClass}"></property>
				<property name="user" value="${username}"></property>
				<property name="password" value="${password}"></property>
	</bean>
	<bean id="dynamicdatasource" class="qilin.utils.DynamicDataSource">
		<property name="targetDataSources">
			<map key-type="java.lang.String">
				 <entry key="defaultDataSource" value-ref="defaultDataSource" /> 
				 <entry key="dataSourceA" value-ref="dataSourceA" /> 
			</map>
		</property>
		<property name="defaultTargetDataSource" ref="defaultDataSource" />
	</bean>

	<!-- 配置SessionFactory -->
	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
		<property name="dataSource" ref="dynamicdatasource" />
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
				<prop key="hibernate.hbm2ddl.auto">none</prop>
				<prop key="hibernate.show_sql">true</prop>
				<prop key="hibernate.format_sql">false</prop>
				<prop key="hibernate.temp.use_jdbc_metadata_defaults">false</prop>
			</props>
		</property>
		<!-- 注解方式配置 -->
		<property name="annotatedClasses">
			<list>
				<value>qilin.entity.Student</value>
			</list>
		</property>
	</bean>


	<!-- 配置声明式事务管理，采用基于注解的方式 -->
	<bean id="transactionManager"
		class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory"></property>
	</bean>
	<tx:annotation-driven transaction-manager="transactionManager" />
	<bean id="dynamicLoadBean" class="qilin.utils.DynamicLoadBean"></bean>
</beans>

2.AbstractRoutingDataSource.class 修改的部分

/**@author qilin**/
	public void addDataSource(Object key,Object dataSource){
		
		this.targetDataSources.put(key, dataSource);
		
		setTargetDataSources(this.targetDataSources);
	}

3.DynamicDataSource.class 这个类中有一个地方需要注意，当我们添加数据，切换了数据源，要通知当前spring容器，需要调用父类的super.afterPropertiesSet();方法

package qilin.utils;

import java.util.Map;

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import org.springframework.jdbc.datasource.lookup.DataSourceLookup;

public class DynamicDataSource extends AbstractRoutingDataSource {

	/* 
	 * 该方法必须要重写  方法是为了根据数据库标示符取得当前的数据库
	 */
	@Override
	public Object determineCurrentLookupKey() {
		return DataSourceContextHolder.getDataSourceName();
	}

	@Override
	public void setDataSourceLookup(DataSourceLookup dataSourceLookup) {
		super.setDataSourceLookup(dataSourceLookup);
	}

	@Override
	public void setDefaultTargetDataSource(Object defaultTargetDataSource) {
		super.setDefaultTargetDataSource(defaultTargetDataSource);
	}

	@Override
	public void setTargetDataSources(Map targetDataSources) {
		super.setTargetDataSources(targetDataSources);
		//重点
		super.afterPropertiesSet();
	}

}

4.动态加载数据源配置文件DynamicLoadBean.class

package qilin.utils;

import java.io.IOException;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.ChildBeanDefinition;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.xml.ResourceEntityResolver;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ConfigurableApplicationContext;

/**
 * 动�?�加载数据源
 * @author qilin
 *
 */
public class DynamicLoadBean implements ApplicationContextAware {

	private ConfigurableApplicationContext applicationContext = null;
	public void setApplicationContext(ApplicationContext applicationContext)
			throws BeansException {

			this.applicationContext = (ConfigurableApplicationContext) applicationContext;
	}

	public ConfigurableApplicationContext getApplicationContext() {  
        return applicationContext;  
    }
	
	/**
	 * 1.配置文件的位置固�?
	 * 2.配置文件中bean的名字已�?
	 * @param configLocationString
	 */
	 public void loadBean(String fileName)
	    {  
	        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader((BeanDefinitionRegistry)getApplicationContext().getBeanFactory());  
	        beanDefinitionReader.setResourceLoader(getApplicationContext());  
	        beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(getApplicationContext()));  
	        try
	        {  
	        	beanDefinitionReader.loadBeanDefinitions(getApplicationContext().getResources(fileName));  
	        } catch (BeansException e) {  
	            e.printStackTrace();  
	        } catch (IOException e) {  
	            e.printStackTrace();  
	        }  
	    }  

	 public void registBean(String beanName, String parentName) {
		 DefaultListableBeanFactory  fcy = (DefaultListableBeanFactory)applicationContext.getAutowireCapableBeanFactory();
		 BeanDefinition beanDefinition  = new ChildBeanDefinition(parentName);
		 fcy.registerBeanDefinition(beanName, beanDefinition);
	 }
}

5.DataSourceContextHolder.class

package qilin.utils;


public class DataSourceContextHolder {

	private static final ThreadLocal contextHolder=new ThreadLocal();
	
	public static void setDataSourceType(String dataSourceName){
		contextHolder.set(dataSourceName);
	}
	
	public static String getDataSourceName(){
		return (String) contextHolder.get();
	}
	
	public static void clearDataSourceType(){
		contextHolder.remove();
	}
	
}

5.测试代码

package junit;

import java.util.HashMap;
import java.util.Map;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.mchange.v2.c3p0.ComboPooledDataSource;

import qilin.entity.Student;
import qilin.service.StuService;
import qilin.utils.DataSourceContextHolder;
import qilin.utils.DynamicDataSource;
import qilin.utils.DynamicLoadBean;

public class Test {
	public static void main(String[] args) {
		ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
		
		StuService stuService = (StuService) ac.getBean("stuServiceImpl");
		
		Student stu = new Student();
		
		stu.setStuName("qilin");
		
		stuService.save(stu);
		
		DataSourceContextHolder.setDataSourceType("dataSourceA");
		
		
		Student _stu = new Student();
		
		_stu.setStuName("_qilin1");
		
		stuService.save(_stu);
		
		//创建一个数据源
		DynamicLoadBean dynamicBeanLoad =(DynamicLoadBean)ac.getBean("dynamicLoadBean");   
        dynamicBeanLoad.loadBean("classpath:mos/qqq.xml"); 
        ComboPooledDataSource dataSource = (ComboPooledDataSource) ac.getBean("qqq");
        System.err.println(dataSource.getDriverClass());
        
        
        
        DynamicDataSource dynamicDataSource = (DynamicDataSource) ac.getBean("dynamicdatasource");
       
//        Map<String, ComboPooledDataSource> targetDataSources = new HashMap<String, ComboPooledDataSource>();
        
//        targetDataSources.put("qqq", dataSource);
        
//        Map<Object, Object> targetDataSources = dynamicDataSource.getTargetDataSources();
        
//        targetDataSources.put("qqq", dataSource);
        
//        dynamicDataSource.setTargetDataSources(targetDataSources);
        
//        dynamicDataSource.setDefaultTargetDataSource(dataSource);
        
        dynamicDataSource.addDataSource("qqq", dataSource);
        
        DataSourceContextHolder.setDataSourceType("qqq");
		
        Student __stu = new Student();
		
		__stu.setStuName("qilin2");
		
		stuService.save(__stu);
		
	}
}

切换数据源就一句话搞定 DataSourceContextHolder.setDataSourceType("qqq");

下载链接http://download.csdn.net/detail/qi_lin70/6778247

有什么不妥之处，还望指教。共同学习，共同进步！

qilin18

关注

8
点赞
踩
21

收藏

觉得还不错? 一键收藏
17
评论
spring动态创建，加载，使用多数据源

项目中我们经常会遇到多数据源的问题，尤其是数据同步或定时任务等项目更是如此。多数据源让人最头痛的，不是配置多个数据源，而是如何能灵活动态的切换数据源。例如在一个spring和hibernate的框架的项目中，我们在spring配置中往往是配置一个dataSource来连接数据库，然后绑定给sessionFactory，在dao层代码中再指定sessionFactory来进行数据库操作。
复制链接

扫一扫