`
tangyanbo
  • 浏览: 268566 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

Spring+Hibernate实现动态SessionFactory切换(改进版)

springhibernate 
阅读更多

前面写了一篇关于动态切换Hibernate SessionFactory的文章，原文地址：http://tangyanbo.iteye.com/admin/blogs/1717402

发现存在一些问题：
需要配置多个HibernateTransactionManager和多个Spring 切面
这样带来两个问题
1. 程序效率降低，因为Spring进行多次Advice的拦截
2. 如果其中一个SessionFactory连接出现问题，会导致整个系统无法工作

今天研究出一种新的方法来解决此类问题
1. 数据源及Hibernate SessionFactory配置：

 

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:p="http://www.springframework.org/schema/p"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"  
    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/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd  
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd  
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">  
    <!-- FOR SqlServer-->  
    <bean id="SqlServer_DataSource"  
        class="org.springframework.jdbc.datasource.DriverManagerDataSource">  
        <property name="driverClassName" value="com.microsoft.sqlserver.jdbc.SQLServerDriver" />  
        <property name="url"  
            value="url" />  
        <property name="username" value="username" />  
        <property name="password" value="password" />  
    </bean>  
    <bean id="SqlServer_SessionFactory"  
        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"  
        p:mappingLocations="classpath:/com/entity/*.hbm.xml">  
        <property name="dataSource" ref="SqlServer_DataSource" />       
        <property name="hibernateProperties">  
            <props>                 
                <prop key="hibernate.query.factory_class">org.hibernate.hql.ast.ASTQueryTranslatorFactory</prop>  
                <prop key="hibernate.dialect">org.hibernate.dialect.SQLServer2008Dialect</prop>               
                <prop key="hibernate.show_sql">true</prop>  
                <prop key="hibernate.format_sql">true</prop>  
            </props>  
        </property>  
    </bean>  
   
      
    <!-- FOR Oracle -->  
    <bean id="Oracle _DataSource"  
        class="org.springframework.jdbc.datasource.DriverManagerDataSource">       
        <property name="driverClassName" value="oracle.jdbc.OracleDriver" />  
        <property name="url" value="jdbc:oracle:thin:@localhost:1521/orcl" />  
        <property name="username" value="username" />  
        <property name="password" value="password" />  
    </bean>  
    <bean id="Oracle_SessionFactory"  
        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"   
        p:mappingLocations="classpath:/com/entity/*.hbm.xml">  
        <property name="dataSource" ref="Oracle_DataSource" />          
        <property name="hibernateProperties">  
            <props>  
                <prop key="hibernate.query.factory_class">org.hibernate.hql.ast.ASTQueryTranslatorFactory</prop>  
                <prop key="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop>               
                <prop key="hibernate.show_sql">true</prop>  
                <prop key="hibernate.format_sql">true</prop>  
            </props>  
        </property>  
    </bean>  
  
      
      
</beans>

 

2. 定义扩展接口DynamicSessionFactoryInf继承SessionFactory

 

 

import org.hibernate.SessionFactory;

public interface DynamicSessionFactoryInf extends SessionFactory {

	public SessionFactory getHibernateSessionFactory();
}

 

3. 定义DynamicSessionFactory实现DynamicSessionFactoryInf

 

public class DynamicSessionFactory implements DynamicSessionFactoryInf ,ApplicationContextAware{
	
	private static final long serialVersionUID = 1L;

	private ApplicationContext applicationContext;
	//动态调用SessionFactory
	private SessionFactory getHibernateSessionFactory(String name) {
		return (SessionFactory) applicationContext.getBean(name);
	}
        //实现DynamicSessionFactoryInf 接口的方法
	public SessionFactory getHibernateSessionFactory() {
		return getHibernateSessionFactory(ThreadLocalUtil.getCurrentITAsset()
				.getSessionFactoryName());
	}
	
       //以下是实现SessionFactory接口的方法，并对当前的SessionFactory实体进行代理
	public Reference getReference() throws NamingException {
		return getHibernateSessionFactory().getReference();
	}

	

	public Session openSession() throws HibernateException {
		return getHibernateSessionFactory().openSession();
	}

	public Session openSession(Interceptor interceptor)
			throws HibernateException {
		return getHibernateSessionFactory().openSession(interceptor);
	}

	public Session openSession(Connection connection) {
		return getHibernateSessionFactory().openSession(connection);
	}

	public Session openSession(Connection connection, Interceptor interceptor) {
		return getHibernateSessionFactory().openSession(connection,interceptor);
	}

	public Session getCurrentSession() throws HibernateException {
		return getHibernateSessionFactory().getCurrentSession();
	}

	public StatelessSession openStatelessSession() {
		return getHibernateSessionFactory().openStatelessSession();
	}

	public StatelessSession openStatelessSession(Connection connection) {
		return getHibernateSessionFactory().openStatelessSession(connection);
	}

	public ClassMetadata getClassMetadata(Class entityClass) {
		return getHibernateSessionFactory().getClassMetadata(entityClass);
	}

	public ClassMetadata getClassMetadata(String entityName) {
		return getHibernateSessionFactory().getClassMetadata(entityName);
	}

	public CollectionMetadata getCollectionMetadata(String roleName) {
		return getHibernateSessionFactory().getCollectionMetadata(roleName);
	}

	public Map getAllClassMetadata() {
		return getHibernateSessionFactory().getAllClassMetadata();
	}

	public Map getAllCollectionMetadata() {
		return getHibernateSessionFactory().getAllCollectionMetadata();
	}

	public Statistics getStatistics() {
		return getHibernateSessionFactory().getStatistics();
	}

	public void close() throws HibernateException {
		getHibernateSessionFactory().close();
	}

	public boolean isClosed() {
		return getHibernateSessionFactory().isClosed();
	}

	public Cache getCache() {
		return getHibernateSessionFactory().getCache();
	}

	public void evict(Class persistentClass) throws HibernateException {
		getHibernateSessionFactory().evict(persistentClass);
	}

	public void evict(Class persistentClass, Serializable id)
			throws HibernateException {
		getHibernateSessionFactory().evict(persistentClass, id);
	}

	public void evictEntity(String entityName) throws HibernateException {
		getHibernateSessionFactory().evictEntity(entityName);
	}

	public void evictEntity(String entityName, Serializable id)
			throws HibernateException {
		getHibernateSessionFactory().evictEntity(entityName, id);
	}

	public void evictCollection(String roleName) throws HibernateException {
		getHibernateSessionFactory().evictCollection(roleName);
	}

	public void evictCollection(String roleName, Serializable id)
			throws HibernateException {
		getHibernateSessionFactory().evictCollection(roleName, id);
	}

	public void evictQueries(String cacheRegion) throws HibernateException {
		getHibernateSessionFactory().evictQueries(cacheRegion);
	}

	public void evictQueries() throws HibernateException {
		getHibernateSessionFactory().evictQueries();
	}

	public Set getDefinedFilterNames() {
		return getHibernateSessionFactory().getDefinedFilterNames();
	}

	public FilterDefinition getFilterDefinition(String filterName)
			throws HibernateException {
		return getHibernateSessionFactory().getFilterDefinition(filterName);
	}

	public boolean containsFetchProfileDefinition(String name) {
		return getHibernateSessionFactory().containsFetchProfileDefinition(name);
	}

	@Override
	public void setApplicationContext(ApplicationContext applicationContext)
			throws BeansException {
		this.applicationContext = applicationContext;
	}

	

}

 

4. 配置动态SessionFactory

 

<bean id="sessionFactory" class="com.hp.it.qdpadmin.common.DynamicSessionFactory"/>
 

 

5. 定义DynamicTransactionManager继承HibernateTransactionManager

 

public class DynamicTransactionManager extends HibernateTransactionManager {

	private static final long serialVersionUID = 1047039346475978451L;
	//重写getDataSource方法，实现动态获取
	public DataSource getDataSource() {
		DataSource sfds = SessionFactoryUtils.getDataSource(getSessionFactory());
		return sfds;
	}
       //重写getSessionFactory方法，实现动态获取SessionFactory
	public SessionFactory getSessionFactory() {
		DynamicSessionFactoryInf dynamicSessionFactory = (DynamicSessionFactoryInf) super
				.getSessionFactory();
		SessionFactory hibernateSessionFactory = dynamicSessionFactory
				.getHibernateSessionFactory();
		return hibernateSessionFactory;
	}
	//重写afterPropertiesSet，跳过数据源的初始化等操作
	public void afterPropertiesSet() {
		return;
	}

}

 

6. 配置dynamicTransactionManager

 

<bean id="dynamicTransactionManager"
		class="com.hp.it.qdpadmin.common.DynamicTransactionManager">
		<property name="sessionFactory" ref="sessionFactory"/>
	</bean>
 

 

7. 为SessionFactory配置事务切面

 

<tx:advice id="dynamicTxAdvice" transaction-manager="dynamicTransactionManager">  
        <tx:attributes>  
            <tx:method name="get*" read-only="true" />  
            <tx:method name="find*" read-only="true" />  
            <tx:method name="*" propagation="REQUIRED" rollback-for="Exception" />  
        </tx:attributes>  
    </tx:advice>  
      
      
    <aop:config proxy-target-class="true">    
        <aop:pointcut id="txPointcut" expression="execution(* com.service.*.*(..))"/>          
        <aop:advisor advice-ref="dynamicTxAdvice" pointcut-ref="txPointcut" /> 
    </aop:config>
分享到：
| Spring+Hibernate实现动态SessionFactory切 ...
评论
3 楼 jiao_zg22 2015-10-26  
您好，我实现了下，发现ThreadLocalUtil这个类引入不了，请问这个类是在哪个包下的呢，是您扩展过的吗？
2 楼 zeallf 2013-02-18  
public class CustomerContextHolder {

public static final String DATA_SOURCE_UK = "dataSourceA";

public static final String DATA_SOURCE_NZ = "dataSourceB";


private static final ThreadLocal<String> contextHolder = new ThreadLocal<String>();

public static void setCustomerType(String customerType) {
contextHolder.set(customerType);
}

public static String getCustomerType() {
return contextHolder.get();
}
｝
1 楼 zeallf 2013-02-18  
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

public class DynamicDataSource extends AbstractRoutingDataSource{

@Override
protected Object determineCurrentLookupKey() {
return CustomerContextHolder.getCustomerType();
}
}

<bean id="dynamicDataSource" class="com.DynamicDataSource" >
     <!-- 通过key-value的形式来关联数据源 -->
<property name="targetDataSources">
<map key-type="java.lang.String">
<entry value-ref="dataSourceUK" key="dataSourceA"></entry>
<entry value-ref="dataSourceNZ" key="dataSourceB"></entry>
</map>
</property>
<property name="defaultTargetDataSource" ref="dataSourceA" >
</property>
</bean>

应更好
发表评论

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

相关推荐

    struts+spring+hibernate实现图书修改和删除

    此外，Spring还可以与Hibernate集成，实现数据访问层的事务管理。 **Hibernate** Hibernate是一个对象关系映射（ORM）框架，它简化了数据库操作，将Java对象和数据库记录进行映射，使得开发者可以使用面向对象的...

    springmvc+spring+hibernate

    Spring MVC、Spring 和 Hibernate 是Java Web开发中的三大主流框架，它们各司其职，共同构建了一个强大而灵活的后端架构。Spring MVC 负责处理HTTP请求并将其路由到相应的控制器，Spring 提供了依赖注入（DI）和面向...

    gwt+spring+hibernate

    标题 "gwt+spring+hibernate" 涉及的是一个使用Google Web Toolkit (GWT)、Spring框架和Hibernate ORM技术的集成示例。这是一个常见的Web应用开发组合，用于构建高效、可扩展且功能丰富的Java web应用程序。下面将...

    Struts2+Spring+hibernate中对action的单元测试环境搭建[总结].pdf

    Struts2+Spring+Hibernate 中的Action单元测试环境搭建 在软件开发中，单元测试是一种非常重要的测试方法，可以帮助我们确保代码的可靠性和稳定性。在 Struts2+Spring+Hibernate 框架中，对 Action 的单元测试环境...

    spring mvc + spring + hibernate 全注解整合开发视频教程 04

    在本视频教程“Spring MVC + Spring + Hibernate 全注解整合开发视频教程 04”中，我们将深入探讨Java企业级开发中的三大核心技术——Spring、Spring MVC和Hibernate的集成与应用，尤其是通过注解实现的简化配置。...

    JSF+Spring+Hibernate小例子

    **JSF+Spring+Hibernate整合应用详解** 在Java Web开发中，JSF（JavaServer Faces）、Spring和Hibernate是三个常用的技术栈，它们分别负责视图层、业务逻辑层和服务数据持久化层。这个"JSF+Spring+Hibernate小例子...

    spring mvc + spring + hibernate 全注解整合开发视频教程 12

    在Spring和Hibernate的整合中，Spring可以作为Hibernate的容器，管理SessionFactory和Transaction，这样我们就能够在Spring的管理下进行数据库操作。通过@PersistenceContext注解，Spring可以注入EntityManager，@...

    struts+spring+hibernate三大框架整合

    1. **SessionFactory的创建**：Spring管理SessionFactory，通常在ApplicationContext.xml中配置，通过`&lt;bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean"&gt;`指定数据源...

    现有Mysql数据库，写Spring + Hibernate的配置文件

    在本案例中，我们将探讨如何在已有的MySQL数据库环境下，配置Spring和Hibernate来实现数据访问层。 首先，我们需要在项目中引入Spring和Hibernate的相关依赖。在Maven或Gradle的构建文件中，添加对应的依赖库，如...

    纯净的spring+hibernate+mysql

    【纯净的Spring+Hibernate+MySQL】项目是一个典型的Java Web应用示例，它将Spring MVC、Hibernate ORM框架与MySQL数据库相结合，以实现用户登录、注册等基础功能。在本项目中，Spring MVC作为控制层，负责处理HTTP...

    spring+hibernate整合实现简单数据库添加记录

    在Spring中，我们可以使用DAO接口，然后通过Spring的Proxy模式动态实现这些接口。 5. **Service层**：业务逻辑层，负责处理应用程序的核心业务。这里可以注入DAO，调用其方法进行数据库操作。Service层也是事务边界...

    Spring+Hibernate整合

    总的来说，"Spring+Hibernate整合+SQL Server2008"是一个典型的Java企业级应用开发模式，它涵盖了Spring框架的管理能力、Hibernate的ORM功能以及SQL Server的数据库服务，为开发人员提供了一种高效、稳定且易于维护...

    Struts2+Spring+Hibernate和Struts2+Spring+Ibatis

    Struts2+Spring+Hibernate和Struts2+Spring+Ibatis是两种常见的Java Web应用程序集成框架，它们分别基于ORM框架Hibernate和轻量级数据访问框架Ibatis。这两种框架结合Spring，旨在提供一个强大的、可扩展的、易于...

    非注解Springmvc+spring+hibernate 入门实例

    下面我们将深入探讨"非注解SpringMVC+Spring+Hibernate入门实例"中的关键知识点。 首先，让我们从SpringMVC开始。SpringMVC是一个Model-View-Controller架构模式的实现，用于构建Web应用程序。在非注解方式下，我们...

    Spring+hibernate整合源代码

    这个“Spring+hibernate整合源代码”应该包含了实现上述整合步骤的示例代码，可以作为学习和参考的资源。通过学习和实践这些代码，你可以更好地理解和掌握 Spring 和 Hibernate 整合的细节，提升你的 Java Web 开发...

    ZK+spring+hibernate的整合

    《ZK+Spring+Hibernate整合详解》 ZK、Spring和Hibernate是Java开发中的三大重要框架，它们分别在用户界面、依赖注入与事务管理、持久层操作方面发挥着关键作用。将这三者进行整合，可以构建出高效、稳定且易于维护...

    struts+spring+hibernate

    这个"struts+spring+hibernate"示例工程是用于演示这三大框架如何协同工作，为开发者提供了一个实战性的学习平台。 Struts 是一个基于 Model-View-Controller（MVC）设计模式的Web应用框架，它主要负责处理用户请求...

    dwr+spring+hibernate模板.zip

    《DWR+Spring+Hibernate整合应用详解》 在IT领域，DWR（Direct Web Remoting）、Spring和Hibernate是三个至关重要的技术组件，它们分别在Web应用程序的远程调用、依赖注入和对象关系映射方面发挥着核心作用。将这三...

    spring+hibernate整合demo

    标题"spring+hibernate整合demo"表明这是一个示例项目，展示了如何将Spring和Hibernate这两个框架结合使用。整合Spring和Hibernate可以使应用程序更易于管理，因为Spring可以控制Hibernate的生命周期，并提供事务...

    Webwork+spring+hibernate集成实例

    在Webwork+Spring+Hibernate集成中，Spring通常作为整体架构的胶水，负责各组件的连接和协调。它可以管理Webwork的Action，通过依赖注入提供所需的Service和DAO。同时，Spring可以配置Hibernate SessionFactory，...

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