现在公司在做一个互联网应用的项目,前端是手机APP和PC,后端处理是WEB和WEBSERVICE(spring3.2.0+hibernate4.1.6.FINAL+c3p0 based maven),由于此项目中牵扯到资金交易,故事务处理必不可少,同时手机APP与Web Service通信,最终和数据库交互,WebService服务器和数据库压力较大,此系统的设计使用Nginx实现WebService的负载均衡,数据库使用MySQL集群,数据库中间件经过甄选使用atlas。
在开发阶段,hibernate通过JDBC连接atlas,但是遇到了以下问题:
连接能成功,也可以进行正常的操作,但是hibernate请求的任何数据交互(即使只有select),也是带有事务的处理(原因貌似是这么解释的,在service层进行query查询,可能包含多个查询语句,只有同时都查询成功了才是请求成功,否则就是失败)。但事务的处理都会放到atlas的master主机执行,导致matster压力过大,不能有效的实现读写分离。
注:atlas主机读写分离规范: 所有事务处理都在master进行,所有写操作都在master进行,非事务的只读操作才在slave进行读取,即
master | rw |
slave1 | ro |
slave2 | ro |
rw: read, write
ro: read only
现在要解决的问题是实现读写分离,实现数据库的负载均衡(即在WebService的service层实现事务的开启或关闭),看到这里好多人肯定会回答,这个很简单,只要配置一下spring事务拦截器就可以了。我们也是用这种方法尝试解决问题,但未果,在如下情况下:
<bean id="BaseDao" class="com.base.BaseDao">
<property name="sessionFactory" >
<ref bean="sessionFactory" />
</property>
</bean>
public Session getSession(){
try{
session=sessionFactory.getCurrentSession();
}catch (Exception e) {
e.printStackTrace();
}
return session;
}
hibernate4无论如何都关不掉事务处理,换成hibernate3再试试,要么全都开启事务,要么全都关闭事务,貌似配置的transactionAttributes(<prop key="query*">PROPAGATION_NOT_SUPPORTED,readOnly</prop>)不起作用。你若不信,可以动手试试。
1. 尝试修改atlas源码
将hibernate操作数据库的hql全部修改成createSQLQuery(sql).addEntiry(TargetClass); 其中需要进行读取的操作sql前加入 /*slave*/ ,如
/*slave*/select * from userinfo;
然后修改atlas源码,在rw_split函数中进行拦截和根据获取的token进行读写分发。此方法解决了问题。
2. 编写自己的spring拦截器
方法1虽然解决了问题,但是没能从更不上解决问题,还需要修改大量的源码,方法2是自己编写事务拦截器,然后实现事务处理操作。
applicationContext.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:mvc="http://www.springframework.org/schema/mvc"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-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/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
<bean id="ConfigBean"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<list>
<!-- for development -->
<value>classpath:jdbc.properties</value>
<!-- deploy1 <value>file:/data/webconfig/ipark/jdbc.properties </value> -->
<!-- deploy: file:/data/webconfig/ipark/jdbc.properties -->
<!-- deploy2 <value>file:${catalina.base}/config/ipark/jdbc.properties</value> -->
</list>
</property>
</bean>
<!--
<bean id="dataSourceHibernate"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
-->
<bean id="dataSourceC3P0" class="com.mchange.v2.c3p0.ComboPooledDataSource"
destroy-method="close">
<property name="driverClass" value="${jdbc.driverClassName}" />
<property name="jdbcUrl" value="${jdbc.url}" />
<property name="user" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
<property name="acquireIncrement" value="1"></property>
<property name="idleConnectionTestPeriod" value="6000"></property>
<property name="initialPoolSize" value="10"></property>
<property name="autoCommitOnClose" value="true"></property>
<property name="maxIdleTime" value="10" ></property>
<property name="minPoolSize" value="5" ></property>
<property name="maxPoolSize" value="30" ></property>
<property name="maxStatements" value="100" ></property>
</bean>
<!-- 数据源切换使用下面的配置 masterDataSource & slaveDataSource
<bean id="masterDataSource" parent="dataSourceC3P0">
<property name="driverClass" value="${jdbc.driverClassName}" />
<property name="jdbcUrl" value="${jdbc.url}" />
<property name="user" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>
<bean id="slaveDataSource" parent="dataSourceC3P0">
<property name="driverClass" value="${slave.jdbc.driverClassName}" />
<property name="jdbcUrl" value="${slave.jdbc.url}" />
<property name="user" value="${slave.jdbc.username}" />
<property name="password" value="${slave.jdbc.password}" />
</bean>
<bean id="dataSource" class="com.base.DynamicDataSource">
<property name="targetDataSources">
<map key-type="java.lang.String">
<entry key="slave" value-ref="slaveDataSource" />
</map>
</property>
<property name="defaultTargetDataSource" ref="masterDataSource" />
</bean>
-->
<bean id="hibermateInterceptor" class="com.base.HibermateInterceptor"/>
<bean id="sessionFactory"
class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
<!-- connection -->
<property name="dataSource">
<ref local="dataSourceC3P0" />
</property>
<property name="entityInterceptor" ref="hibermateInterceptor"/>
<!-- hibernate自身属性 -->
<property name="hibernateProperties">
<props>
<prop key="hibernate.autoReconnect">false</prop>
<prop key="hibernate.defaultAutoCommit">true</prop>
<prop key="hibernate.connection.autocommit">true</prop>
<prop key="hibernate.connection.defaultAutoCommit">true</prop>
<prop key="hibernate.show_sql">false</prop>
<prop key="hibernate.format_sql">false</prop>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>
<prop key="hibernate.cache.use_second_level_cache">false</prop>
<!-- Disable the second-level cache -->
<prop key="hibernate.cache.provider_class">org.hibernate.cache.internal.NoCacheProvider</prop>
<!--
<prop key="hibernate.current_session_context_class">org.springframework.orm.hibernate4.SpringSessionContext</prop>
<prop key="hibernate.current_session_context_class">thread</prop>
-->
<!-- c3p0 -->
<!-- 连接池hibernate配置 <prop key="hibernate.connection.provider_class">org.hibernate.connection.ProxoolConnectionProvider</prop> -->
<!-- 需要再次配置数据源,c3p0才起作用 -->
<prop key="hibernate.connection.provider_class">org.hibernate.service.jdbc.connections.internal.C3P0ConnectionProvider </prop>
<prop key="hibernate.connection.driver_class">${jdbc.driverClassName}</prop>
<prop key="hibernate.connection.url">${jdbc.url}</prop>
<prop key="hibernate.connection.username">${jdbc.username}</prop>
<prop key="hibernate.connection.password">${jdbc.password}</prop> <!-- -->
<!-- <prop key="hibernate.connection.autoCommit">false</prop> <prop key="hibernate.connection.defaultAutoCommit">true</prop> -->
<prop key="hibernate.transaction.auto_close_session">true</prop>
<!-- 连接池中JDBC连接的最小数量。Hibernate默认为1 -->
<prop key="hibernate.c3p0.min_size">3</prop>
<!-- 连接池中JDBC连接的最大数量。Hibernate默认为100 -->
<prop key="hibernate.c3p0.max_size">56</prop>
<!-- 何时从连接池中移除一个空闲的连接(以秒为单位)时。Hibernate默认为0,永不过期 -->
<prop key="hibernate.c3p0.timeout">600</prop>
<!-- 被缓存的预编译语句数量。用来提高性能。Hibernate默认为0,缓存不可用 -->
<prop key="c3p0.max_statements">255</prop>
<!-- 一个连接被自动验证前的闲置时间(以秒为单位)。Hibernate默认为0 -->
<prop key="hibernate.c3p0.idle_test_period">600</prop>
<!-- 当连接池里面的连接用完的时候,C3P0一下获取的新的连接数 -->
<prop key="hibernate.c3p0.acquire_increment">2</prop>
<!-- 每次都验证连接是否可用 -->
<prop key="hibernate.c3p0.validate">true</prop>
<!--因性能消耗大请只在需要的时候使用它。如果设为true那么在每个connection提交的 时候都将校验其有效性。 建议使用idleConnectionTestPeriod或automaticTestTable
等方法来提升连接测试的性能。Default: false -->
<prop key="idleConnectionTestPeriod">6000</prop>
<prop key="automaticTestTable">c3p0Test</prop>
<prop key="preferredTestQuery">select * from c3p0Test</prop>
</props>
</property>
<!-- 映射文件 -->
<property name="mappingDirectoryLocations">
<list>
<value>classpath:/com/hbm</value>
</list>
</property>
</bean>
<!-- 自动切换主从, 一定要配置在事务AOP之上 -->
<!--
<bean id="dataSourceAdvice" class="com.base.DataSourceAdvice" />
<aop:config>
<aop:advisor pointcut="execution(* com.dao..*.*(..))" advice-ref="dataSourceAdvice" />
</aop:config>
-->
<!-- 自定义事务拦截器 -->
<bean id="transactionInterceptor" class="com.base.TransactionInterceptor">
<property name="transactionManager" ref="transactionManager"></property>
<property name="transactionAttributes">
<props>
<prop key="delete*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="update*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="add*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="save*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="create*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="log*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="login*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="query*">PROPAGATION_NOT_SUPPORTED,readOnly</prop>
<prop key="get*">PROPAGATION_NOT_SUPPORTED,readOnly</prop>
</props>
</property>
</bean>
<!-- 注册事务拦截器 -->
<bean id="autoproxy"
class="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="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"></property>
<property name="transactionSynchronization" value="1"></property>
</bean>
<!-- 配置事务传播特性 -->
<!-- Spring中Propagation类的事务属性详解: PROPAGATION_REQUIRED:支持当前事务,如果当前没有事务,就新建一个事务。这是最常见的选择。
PROPAGATION_SUPPORTS:支持当前事务,如果当前没有事务,就以非事务方式执行。 PROPAGATION_MANDATORY:支持当前事务,如果当前没有事务,就抛出异常。
PROPAGATION_REQUIRES_NEW:新建事务,如果当前存在事务,把当前事务挂起。 PROPAGATION_NOT_SUPPORTED:以非事务方式执行操作,如果当前存在事务,就把当前事务挂起。
PROPAGATION_NEVER:以非事务方式执行,如果当前存在事务,则抛出异常。 PROPAGATION_NESTED:支持当前事务,如果当前事务存在,则执行一个嵌套事务,如果当前没有事务,就新建一个事务。 -->
<!--
<tx:advice id="TransAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="save*" propagation="REQUIRED" />
<tx:method name="add*" propagation="REQUIRED" />
<tx:method name="create*" propagation="REQUIRED" />
<tx:method name="insert*" propagation="REQUIRED" />
<tx:method name="update*" propagation="REQUIRED" />
<tx:method name="merge*" propagation="REQUIRED" />
<tx:method name="del*" propagation="REQUIRED" />
<tx:method name="remove*" propagation="REQUIRED" />
<tx:method name="put*" propagation="REQUIRED" />
<tx:method name="get*" propagation="NOT_SUPPORTED" read-only="true" />
<tx:method name="query*" propagation="NOT_SUPPORTED" read-only="true" />
<tx:method name="login*" propagation="NOT_SUPPORTED" read-only="true" />
<tx:method name="*" read-only="true" />
<tx:method name="*" timeout="30" />
</tx:attributes>
</tx:advice>
-->
<!-- 配置参与事务的类
<aop:config>
<aop:pointcut id="allTransServiceMethod" expression="execution(* com.dao..*.*(..))" />
<aop:advisor pointcut-ref="allTransServiceMethod" advice-ref="TransAdvice" />
</aop:config>
-->
<!--=============================导入DAO bean配置文件==================================== -->
<import resource="classpath:spring/*-spring.xml" />
</beans>
com.base.TransactionInterceptor
package com.base;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.transaction.TransactionManager;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.apache.log4j.Logger;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.interceptor.MethodMapTransactionAttributeSource;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.transaction.interceptor.TransactionAttribute;
import org.springframework.transaction.interceptor.TransactionAttributeSource;
import org.springframework.transaction.support.DefaultTransactionDefinition;
public class TransactionInterceptor extends TransactionAspectSupport implements MethodInterceptor {
private Logger log = Logger.getLogger(HibermateInterceptor.class);
private PlatformTransactionManager transactionManager;
private ThreadLocal<Integer> lockDeep = new ThreadLocal<Integer>();
private List<String> methodsList = new ArrayList<String>();//开始事务
private TransactionAttributeSource transactionAttributeSource=null;
// private Map<String, String> transactionAttributes = new HashMap<String, String>();
public TransactionInterceptor(){
methodsList.add("add");
methodsList.add("save");
methodsList.add("update");
methodsList.add("delete");
methodsList.add("log");
// log.info("事务 拦截器");
}
public boolean ChekcMethods(String methodName){
for(String str:methodsList){
if(methodName.startsWith(str))
return true;
}
return false;
}
public Object invoke(MethodInvocation invocation) throws Throwable {
Object result = null;
String methodName = invocation.getMethod().getName();
transactionAttributeSource = this.getTransactionAttributeSource();
TransactionAttribute ta = transactionAttributeSource.getTransactionAttribute(invocation.getMethod(), invocation.getMethod().getClass());
log.info("事务 拦截器");
boolean isBeginTransaction = false;//是否需要开事务
log.info("TransactionInterceptor invoke()");
try {
log.info(TransactionInterceptor.class + " methodName="+methodName );
TransactionStatus status = null;
DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
//判断是否需要事务
if ( ta!=null &&
( ta.getPropagationBehavior()==DefaultTransactionDefinition.PROPAGATION_REQUIRED ||
ta.getPropagationBehavior()==DefaultTransactionDefinition.PROPAGATION_NESTED ||
ta.getPropagationBehavior()==DefaultTransactionDefinition.PROPAGATION_REQUIRES_NEW
) ) {
//线程变量中事务数加1
Integer deep = lockDeep.get();
if (deep == null || deep.intValue() == 0) {
deep = new Integer(1);
} else {
deep = new Integer(deep.intValue() + 1);
}
lockDeep.set(deep);
definition.setPropagationBehavior( ta.getPropagationBehavior() );
status = transactionManager.getTransaction(definition);
// HibernateUtil.beginTransaction();//开始事务
isBeginTransaction = true;//标志事务已打开
log.info("开启事务 @ methodName="+methodName);
}
//执行业务逻辑方法
result = invocation.proceed();
if (isBeginTransaction && status!=null) {
//线程变量
int deep = lockDeep.get().intValue();
deep = deep - 1;
if (deep == 0) {
transactionManager.commit(status);
// HibernateUtil.commitTransaction();//提交事务
}
//若正常提交事务,线程变量中事务数减1
lockDeep.set(new Integer(deep));
}
} catch(Exception e) {
if (isBeginTransaction) {
//线程变量
int deep = lockDeep.get().intValue();
deep = deep - 1;
//线程变量中事务数减1
lockDeep.set(new Integer(deep));
HibernateUtil.rollbackTransaction();//异常则回滚DB事务
}
throw e;
} finally {
Integer deep = lockDeep.get();
if (deep == null || deep.intValue() == 0) {
HibernateUtil.closeSession();//如果上下文有开启的session,关闭session
}
}
return result;
}
public void setTransactionManager(PlatformTransactionManager transactionManager) {
this.transactionManager = transactionManager;
log.info("setTransactionManager with "+transactionManager);
}
public PlatformTransactionManager getTransactionManager() {
return transactionManager;
}
}
方3:修改session的获取
applicationConetext.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:mvc="http://www.springframework.org/schema/mvc"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-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/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
<bean id="ConfigBean"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<list>
<!-- for development -->
<value>classpath:jdbc.properties</value>
<!-- deploy1 <value>file:/data/webconfig/ipark/jdbc.properties </value> -->
<!-- deploy: file:/data/webconfig/ipark/jdbc.properties -->
<!-- deploy2 <value>file:${catalina.base}/config/ipark/jdbc.properties</value> -->
</list>
</property>
</bean>
<!--
<bean id="dataSourceHibernate"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
-->
<bean id="dataSourceC3P0" class="com.mchange.v2.c3p0.ComboPooledDataSource"
destroy-method="close">
<property name="driverClass" value="${jdbc.driverClassName}" />
<property name="jdbcUrl" value="${jdbc.url}" />
<property name="user" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
<property name="acquireIncrement" value="1"></property>
<property name="idleConnectionTestPeriod" value="6000"></property>
<property name="initialPoolSize" value="10"></property>
<property name="autoCommitOnClose" value="true"></property>
<property name="maxIdleTime" value="10" ></property>
<property name="minPoolSize" value="5" ></property>
<property name="maxPoolSize" value="30" ></property>
<property name="maxStatements" value="100" ></property>
</bean>
<!-- 数据源切换使用下面的配置 masterDataSource & slaveDataSource
<bean id="masterDataSource" parent="dataSourceC3P0">
<property name="driverClass" value="${jdbc.driverClassName}" />
<property name="jdbcUrl" value="${jdbc.url}" />
<property name="user" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>
<bean id="slaveDataSource" parent="dataSourceC3P0">
<property name="driverClass" value="${slave.jdbc.driverClassName}" />
<property name="jdbcUrl" value="${slave.jdbc.url}" />
<property name="user" value="${slave.jdbc.username}" />
<property name="password" value="${slave.jdbc.password}" />
</bean>
<bean id="dataSource" class="com.base.DynamicDataSource">
<property name="targetDataSources">
<map key-type="java.lang.String">
<entry key="slave" value-ref="slaveDataSource" />
</map>
</property>
<property name="defaultTargetDataSource" ref="masterDataSource" />
</bean>
-->
<bean id="hibermateInterceptor" class="com.base.HibermateInterceptor"/>
<bean id="sessionFactory"
class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
<!-- connection -->
<property name="dataSource">
<ref local="dataSourceC3P0" />
</property>
<property name="entityInterceptor" ref="hibermateInterceptor"/>
<!-- hibernate自身属性 -->
<property name="hibernateProperties">
<props>
<prop key="hibernate.autoReconnect">false</prop>
<prop key="hibernate.defaultAutoCommit">true</prop>
<prop key="hibernate.connection.autocommit">true</prop>
<prop key="hibernate.connection.defaultAutoCommit">true</prop>
<prop key="hibernate.show_sql">false</prop>
<prop key="hibernate.format_sql">false</prop>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>
<prop key="hibernate.cache.use_second_level_cache">false</prop>
<!-- Disable the second-level cache -->
<prop key="hibernate.cache.provider_class">org.hibernate.cache.internal.NoCacheProvider</prop>
<!--
<prop key="hibernate.current_session_context_class">org.springframework.orm.hibernate4.SpringSessionContext</prop>
-->
<prop key="hibernate.current_session_context_class">thread</prop>
<!-- c3p0 -->
<!-- 连接池hibernate配置 <prop key="hibernate.connection.provider_class">org.hibernate.connection.ProxoolConnectionProvider</prop> -->
<!-- 需要再次配置数据源,c3p0才起作用 -->
<prop key="hibernate.connection.provider_class">org.hibernate.service.jdbc.connections.internal.C3P0ConnectionProvider </prop>
<prop key="hibernate.connection.driver_class">${jdbc.driverClassName}</prop>
<prop key="hibernate.connection.url">${jdbc.url}</prop>
<prop key="hibernate.connection.username">${jdbc.username}</prop>
<prop key="hibernate.connection.password">${jdbc.password}</prop> <!-- -->
<!-- 连接池中JDBC连接的最小数量。Hibernate默认为1 -->
<prop key="hibernate.c3p0.min_size">3</prop>
<!-- 连接池中JDBC连接的最大数量。Hibernate默认为100 -->
<prop key="hibernate.c3p0.max_size">56</prop>
<!-- 何时从连接池中移除一个空闲的连接(以秒为单位)时。Hibernate默认为0,永不过期 -->
<prop key="hibernate.c3p0.timeout">600</prop>
<!-- 被缓存的预编译语句数量。用来提高性能。Hibernate默认为0,缓存不可用 -->
<prop key="c3p0.max_statements">255</prop>
<!-- 一个连接被自动验证前的闲置时间(以秒为单位)。Hibernate默认为0 -->
<prop key="hibernate.c3p0.idle_test_period">600</prop>
<!-- 当连接池里面的连接用完的时候,C3P0一下获取的新的连接数 -->
<prop key="hibernate.c3p0.acquire_increment">2</prop>
<!-- 每次都验证连接是否可用 -->
<prop key="hibernate.c3p0.validate">true</prop>
<!--因性能消耗大请只在需要的时候使用它。如果设为true那么在每个connection提交的 时候都将校验其有效性。 建议使用idleConnectionTestPeriod或automaticTestTable
等方法来提升连接测试的性能。Default: false -->
<prop key="idleConnectionTestPeriod">6000</prop>
<prop key="automaticTestTable">c3p0Test</prop>
<prop key="preferredTestQuery">select * from c3p0Test</prop>
</props>
</property>
<!-- 映射文件 -->
<property name="mappingDirectoryLocations">
<list>
<value>classpath:/com/hbm</value>
</list>
</property>
</bean>
<!-- 自动切换主从, 一定要配置在事务AOP之上 -->
<!--
<bean id="dataSourceAdvice" class="com.base.DataSourceAdvice" />
<aop:config>
<aop:advisor pointcut="execution(* com.dao..*.*(..))" advice-ref="dataSourceAdvice" />
</aop:config>
-->
<!-- 自定义事务拦截器
<bean id="transactionInterceptor" class="com.base.TransactionInterceptor">
<property name="transactionManager" ref="transactionManager"></property>
<property name="transactionAttributes">
<props>
<prop key="delete*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="update*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="add*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="save*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="create*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="log*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="login*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="query*">PROPAGATION_NOT_SUPPORTED,readOnly</prop>
<prop key="get*">PROPAGATION_NOT_SUPPORTED,readOnly</prop>
</props>
</property>
</bean>
-->
<!-- 注册事务拦截器
<bean id="autoproxy"
class="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="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<!-- 配置事务传播特性 -->
<!-- Spring中Propagation类的事务属性详解: PROPAGATION_REQUIRED:支持当前事务,如果当前没有事务,就新建一个事务。这是最常见的选择。
PROPAGATION_SUPPORTS:支持当前事务,如果当前没有事务,就以非事务方式执行。 PROPAGATION_MANDATORY:支持当前事务,如果当前没有事务,就抛出异常。
PROPAGATION_REQUIRES_NEW:新建事务,如果当前存在事务,把当前事务挂起。 PROPAGATION_NOT_SUPPORTED:以非事务方式执行操作,如果当前存在事务,就把当前事务挂起。
PROPAGATION_NEVER:以非事务方式执行,如果当前存在事务,则抛出异常。 PROPAGATION_NESTED:支持当前事务,如果当前事务存在,则执行一个嵌套事务,如果当前没有事务,就新建一个事务。 -->
<!-- -->
<tx:advice id="TransAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="save*" propagation="REQUIRED" />
<tx:method name="add*" propagation="REQUIRED" />
<tx:method name="create*" propagation="REQUIRED" />
<tx:method name="insert*" propagation="REQUIRED" />
<tx:method name="update*" propagation="REQUIRED" />
<tx:method name="merge*" propagation="REQUIRED" />
<tx:method name="del*" propagation="REQUIRED" />
<tx:method name="remove*" propagation="REQUIRED" />
<tx:method name="put*" propagation="REQUIRED" />
<tx:method name="get*" propagation="NOT_SUPPORTED" read-only="true" />
<tx:method name="query*" propagation="NOT_SUPPORTED" read-only="true" />
<tx:method name="login*" propagation="REQUIRED" />
<tx:method name="*" propagation="NOT_SUPPORTED" read-only="true" />
<tx:method name="*" timeout="30" />
</tx:attributes>
</tx:advice>
<!-- 配置参与事务的类 -->
<aop:config>
<aop:pointcut id="allTransServiceMethod" expression="execution(* com.dao..*.*(..))" />
<aop:advisor pointcut-ref="allTransServiceMethod" advice-ref="TransAdvice" />
</aop:config>
<!--=============================导入DAO bean配置文件==================================== -->
<import resource="classpath:spring/*-spring.xml" />
</beans>
HibernateUtil.java
/*
* @author : TF-BJ-C064
* @creation : 2014-7-23 下午3:57:39
* @description :
*
*/
package com.base;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class HibernateUtil {
private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.xml";
private static final ThreadLocal localSession = new ThreadLocal();
private static final ThreadLocal localTransaction = new ThreadLocal();
private static Configuration configuration = new Configuration();
private static SessionFactory sessionFactory;
private static String configFile = CONFIG_FILE_LOCATION;
static {
try {
//方式一
// configuration.configure(configFile);
// sessionFactory = configuration.buildSessionFactory();
//方式二
String[] configLocations = new String[] {"classpath:applicationContext.xml"};
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext(configLocations);
sessionFactory = ctx.getBean("sessionFactory", SessionFactory.class);
} catch (Exception e) {
System.err.println("%%%% Error Creating SessionFactory %%%%");
e.printStackTrace();
}
}
private HibernateUtil() {
}
/**
* Returns the ThreadLocal Session instance. Lazy initialize
* the <code>SessionFactory</code> if needed.
*
* @return Session
* @throws HibernateException
*/
public static Session getSession() throws HibernateException {
Session session = (Session) localSession.get();
if (session == null || !session.isOpen()) {
if (sessionFactory == null) {
rebuildSessionFactory();
}
session = (sessionFactory != null) ? sessionFactory.openSession()
: null;
localSession.set(session);
}
return session;
}
/**
* Rebuild hibernate session factory
*
*/
public static void rebuildSessionFactory() {
try {
//方式一
// configuration.configure(configFile);
// sessionFactory = configuration.buildSessionFactory();
//方式二
String[] configLocations = new String[] {"classpath:applicationContext.xml"};
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext(configLocations);
sessionFactory = ctx.getBean("sessionFactory", SessionFactory.class);
} catch (Exception e) {
System.err.println("%%%% Error Creating SessionFactory %%%%");
e.printStackTrace();
}
}
/**
* Close the single hibernate session instance.
*
* @throws HibernateException
*/
public static void closeSession() throws HibernateException {
Session session = (Session) localSession.get();
localSession.set(null);
if (session != null && session.isOpen()) {
session.close();
}
}
/**
* return session factory
*
*/
public static SessionFactory getSessionFactory() {
return sessionFactory;
}
/**
* return session factory
*
* session factory will be rebuilded in the next call
*/
public static void setConfigFile(String configFile) {
HibernateUtil.configFile = configFile;
sessionFactory = null;
}
/**
* return hibernate configuration
*
*/
public static Configuration getConfiguration() {
return configuration;
}
/**
* 开始当前线程中Hibernate Session的事务
* @return Transaction
* @throws HibernateException
*/
public static Transaction beginTransaction() throws HibernateException {
Transaction tx = (Transaction)localTransaction.get();
if(tx == null || tx.wasCommitted() || tx.wasRolledBack()){
Session session = getSession();
tx = (session != null) ? session.beginTransaction() : null;
localTransaction.set(tx);
}
return tx;
}
/**
* 提交当前线程中Hibernate Session的事务
* @throws HibernateException
*/
public static void commitTransaction() throws HibernateException {
Transaction tx = (Transaction)localTransaction.get();
localTransaction.set(null);
if(tx != null || (!tx.wasCommitted() && !tx.wasRolledBack())){
tx.commit();
}
}
/**
* 回滚当前线程中Hibernate Session的事务
* @throws HibernateException
*/
public static void rollbackTransaction() throws HibernateException {
Transaction tx = (Transaction)localTransaction.get();
localTransaction.set(null);
if(tx != null || (!tx.wasCommitted() && !tx.wasRolledBack())){
tx.rollback();
}
}
/**
* 当前Hibernate Session是否打开
* @return
*/
public static boolean isOpenSession() {
Session session = (Session) localSession.get();
if (session != null && session.isOpen()) {
return true;
}
return false;
}
}
*Dao.query()
session = HibernateUtil.getSession();
//todo sth...
HibernateUtil.closeSession();
经过测试登录LoginDao.login()函数,login函数中包含query 和 update 结果:
参考:http://blog.csdn.net/bluishglc/article/details/7774131