事务管理

JDBC事务管理

内容介绍：

JDBC事务是用 Connection对象控制的。JDBC Connection接口( java.sql.Connection)供给了两种事务形式：积极提交和手工提交。

1.在JDBC 中，事务垄断缺省是积极提交。换句话说，一条对数据库的更新语句代表一项事务垄断，垄断成功执行完，系统将积极调用commit()来提交，否则将调用rollback()进行事务回滚。

2.在JDBC 中，能够设置setAutoCommit(false)属性来遏止积极提交。而后就能够把多个数据库垄断的语句作为一个事务，在垄断告终后调 用commit()来举行大局提交，倘若其中一个语句垄断失利，都不会执行commit()，并且将发生响应的失常；出现异常时调用 rollback()进行事务回滚。

代码实例：

try{			
			
			conn.setAutoCommit(false);//禁止自动提交，设置回滚点
			stmt=conn.createStatement();
			stmt.executeUpdate("delete from t_user where userName=" + userName);
			stmt.executeUpdate("delete from t_userinfo where userName=" + userName);
			conn.commit(); //事务提交
			conn.setAutoCommit(true);			
	     }catch(Exception ex) {    
	         ex.printStackTrace();
	         try {
	        	 conn.rollback(); //操作不成功则回滚
	          }catch(Exception e) {
	        	  e.printStackTrace();
	          }
	     }finally{	    	
			stmt.close();
			conn.close();
	     }

JDBC事务总结：

JDBC事务的缺点是事务范围局限于一个数据库连接。一个JDBC不能跨越多个数据库操作。

JTA事务管理

内容分析：

JTA为J2EE平台提供了散布式事务服务。首先了解开发人员经常使用JDBC来作为DAO类中的底层数据操作。如果计划使用JTA来划分事务，你将需要一个实现了javax.sql.XADataSource，javax.sql.XAConnection，javax.sql.XAResource接口JDBC的驱动。实现了这些接口的驱动将有能力参与到JTA事务中。JTA是只是一组java接口用于描述，J2ee框架中事务管理与应用程序，资源管理，以及服务器之间的事务通信。它主要包括高层接口即面向应用程序的接口；XAResource接口即面向资源的接口；以及事务管理器的接口。JTA只提供接口，不提供实现。

接口分析：

XADataSource：创建数据源对象

XAConnection：创建JTA的Connection

XAResource：定义资源管理器和事务管理之间的协定。

一个XADataSource对象是一个XAConnection对象的工厂。

通过 XAResource 对象管理 XAConnection 对象。

XAConnections是参与到JTA事务中的连接。

JTATransaction可以实现同一事务对应不同的数据库，但是它仍然无法实现事务的嵌套。

代码分析：

try{		
			transaction.begin();
			stmt=conn.createStatement();
			stmt.executeUpdate("delete from t_user where userName=" + userName);
			stmt.executeUpdate("delete from t_userinfo where userName=" + userName);
			transaction.commit(); //事务提交		
	     }catch(Exception ex) {    
	         ex.printStackTrace();
	         try {
	        	 transaction.rollback(); //操作不成功则回滚
	          }catch(Exception e) {
	        	  e.printStackTrace();
	          }
	     }finally{	    	
				stmt.close();
				conn.close();
	     }

JTA总结：

在上层代码隐含的太多了，底层的东西我们不是很清楚，JTA就是对以前的JDBC进行封装，达到简化易用的效果。使用事务的时候假如调用不同的方法的时候我们将我们事务进行传递。

容器事务管理（具有代表性的是Spring的事务管理）

1.spring和hibernate的集成（编程式事务）

事务使用：我想要添加一个用户，再添加用户同时也需要记录到日志文件中去，所以这两个方法就构成了一个事务。

代码实例：

UserManager类中的方法：

public void addUser(User user){
		Session session =HibernateUtil.getSessionFactory().getCurrentSession();
		try{			
			session.beginTransaction();		
			session.save(user);
			Log log=new Log();
			log.setDetail("CSDN为什么不允许我发表到首页");
			log.setType("这是为什么");
			log.setTime(new Date());
			LogManager logManager= new LogManagerImpl();
			logManager.addLog(log);
			session.getTransaction().commit();			
		}catch(Exception e){
			e.printStackTrace();
			session.getTransaction().rollback();
		}
	}

LogManager类中的方法：

public void addLog(Log log){
		HibernateUtil.getSessionFactory().getCurrentSession().save(log);
	}

Hibernate.cfg.xml文件中加上

<property name="hibernate.current_session_context_class"> thread</property>

1、openSession和getCurrentSession的区别？
* openSession必须关闭，currentSession在事务结束后自动关闭
* openSession没有和当前线程绑定，currentSession和当前线程绑定

2、如果使用currentSession需要在hibernate.cfg.xml文件中进行配置：
* 如果是本地事务（jdbc事务）
<property name="hibernate.current_session_context_class">thread</property>
* 如果是全局事务（jta事务）

       <property name="hibernate.current_session_context_class">jta</property>

编程式事务总结：

hibernate的事务通过交给Session来执行，当session中存在一个事务的时候，在执行的时候就会通过线程捕捉到这个事务进行下面的操作。

2.spring+hibernate,采用声明式事务

1、实例演示

事务使用：我想要添加一个用户，再添加用户同时也需要记录到日志文件中去，所以这两个方法就构成了一个事务。

代码实例：

UserManager类中的方法：

public void addUser(User user){		
		this.getHibernateTemplate().save(user);
		Log log=new Log();
		log.setDetail("CDSN为什么不允许我向首页上发");
		log.setType("这是为什么");
		log.setTime(new Date());			
		logManager.addLog(log);
	}

LogManager类中的方法：

public void addLog(Log log){
		this.getHibernateTemplate().save(log);
	}

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:aop="http://www.springframework.org/schema/aop"
	     xmlns:tx="http://www.springframework.org/schema/tx"
	     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
    
    <!--
		1、声明式事务配置(applicationContext.xml中配置)
		@配置SessionFactory(hibernate.cfg.xml文件里的内容可以全部配置到applicationContext.xml中)  -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean" >
    	<property name="configLocation">
    		<value>classpath:hibernate.cfg.xml</value>
    	</property>    	
    </bean>
     <!-- 
     	@配置事务管理器
      -->      
  	<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
          <property name="sessionFactory">
              <ref bean="sessionFactory"/>
          </property>
    </bean>
  	  <!-- 
     	@哪些类哪些方法使用事务
      --> 
  		<aop:config>
  			<aop:pointcut  id="allManagerMethod" expression="execution(* com.bjpowernode.usermgr.manager.*.*(..))"/>
  			<aop:advisor pointcut-ref="allManagerMethod"   advice-ref="txAdvice"/>
  		</aop:config>
  	  <!-- 
     	@事务的传播特性
      --> 
  		<tx:advice id="txAdvice" transaction-manager="transactionManager">
  			<tx:attributes>
  				<tx:method name="add*" propagation="REQUIRED"/>
  				<tx:method name="del*" propagation="REQUIRED"/>
  				<tx:method name="modify*" propagation="REQUIRED"/>
  				<tx:method name="find*" propagation="REQUIRED" read-only="true"/>
  			</tx:attributes>
  		</tx:advice>
</beans>

2、编写业务逻辑方法

       * 继承HibernateDaoSupport类，使用HibernateTemplate来持久化，HibernateTemplate是

         Hibernate Session的轻量级封装

       * 默认情况下运行期异常才会回滚（包括继承了RuntimeException子类），普通异常是不会滚的

       * 编写业务逻辑方法时，最好将异常一直向上抛出，在表示层（struts）处理

       * 关于事务边界的设置，通常设置到业务层，不要添加到Dao上  

3、了解事务的几种传播特性

       1.    PROPAGATION_REQUIRED: 如果存在一个事务，则支持当前事务。如果没有事务则开启

       2.    PROPAGATION_SUPPORTS: 如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行

       3.    PROPAGATION_MANDATORY: 如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常。

       4.    PROPAGATION_REQUIRES_NEW: 总是开启一个新的事务。如果一个事务已经存在，则将这个存在的事务挂起。

       5.    PROPAGATION_NOT_SUPPORTED: 总是非事务地执行，并挂起任何存在的事务。

       6.    PROPAGATION_NEVER: 总是非事务地执行，如果存在一个活动事务，则抛出异常

       7.    PROPAGATION_NESTED：如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务,  则按TransactionDefinition.PROPAGATION_REQUIRED属性执行 

总结：利用Spring框架下，Spring提供了事务管理器，事务管理器的由来是有SessionFactory来创建的，所以Spring对一系列的创建工作做了良好的封装，对事务进行了支持。

总结：事务管理的方式就是通过这三种类型管理，我感觉越是给人提供方便的事务管理越能让人体会到编程的简单，容器事务管理就是一种“傻瓜“事务，要想了解更深层的东西还是应该使用最初始的事务管理。