Spring事务处理

1、事务处理简介
  >>事务：一系列步骤组成的有机集合。
  >>事务特性：ACID
    原子性：表示事务执行过程中，把事务作为一个工作单元处理，一个工作单元可能包括若干个操作步骤，每个操作步骤都必须完成才算完成，若因任何原因导致其中一个，则表示此操作失败，前面完成的步骤必须回滚，系统回到事务开始前的状态。
    一致性：如果事务开始跟事务结束时系统都处理一致状态，无论事务成功还是失败。原因：必须保证事务操作的数据一致。
    隔离性：2个事务在操作过程中是相互独立的，互不相干。
    持久性：事务执行成功后，在系统中产生的结果应该是持久的。


2、事务处理
   有3种方式：
  >>关系型数据库的事务处理
  >>传统的JDBC事务处理
  >>分布式事务处理
  本文重点放在   第二中传统的事务处理
public class HelloWorld{
 private DataSource dataSource;
 //获取数据源
 public void setDataSource(DataSource dataSource){
  this.dataSource = dataSource;
 }
 Connection conn = null;
 Statement stmt = null;
 try{
  //获取数据连接
  conn = dataSource.getConnection();
  //开始事务
  conn.setAutoCommit(false);
  stmt = conn.createStatement();
  //执行想要操作
  stmt.executUpdat(...);
  //执行成功则提交事务
  conn.commit();
 }catch(....){
  if(conn != null){
   //执行不成功，则回滚
   conn.rooback();
  }catch(...){...}
 }finally{...}
}
以上是传统到不能再传统的jdbc对事务的处理，权当对jdbc一次复习，接下来是如何通过Spring实现对事务的处理。
Spring对事务的处理可分2种方式实现 
1：编程式事务处理
2：声明式事务处理
扯一下spring对事务处理的原理：
Spring中事务处理实际上是基于动态AOP机制实现的，默认情况下，spring使用java动态代理机制，如果代理对象并没有实现摸一个接口，Spring则通过cglib实现，此时必须添加执行cglib的jar包。
统一介绍事务api
spring事务中心接口：
org.springframework.transaction.PlatformtransactionManager


public interface PlatformTransactionManager{
 //目前的事务
 TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;
 //提交事务
 void commit(TransactionStatus status) throws TransactionException;
 //事务回滚
 void rollback(TransactionStatus) throws TransactionException;
}


TransactionDefinition
代表事务处理时一些属性定义，如事务名称，隔离层次 传播行为 等等
public interface TransactionDefinition{
 //获得事务的传播行为
 int getPropagationBehavior();
 //获得事务的隔离层次
 int getsolationLevel();
 //判断事务是否超时
 int getTimeour();
 //是否为只读事务
 boolean isReadOnly();
 //返回一个事务的名字
 String getName();
}


TransactionStatus
代表目前的事务，通常不直接使用它，可以借助它的setRollbackOnly方法设定只读事务。
public interface TransactionStatus{
 //判断是否是一个新事务
 boolean isNewTransaction();
 //设定为只读事务
 void setRollbackOnly();
 //判断是否是只读事务
 boolean isRollbackOnly();
 //判断一个事务是否完成
 boolean isCompleted();
}
事务处理模板
TransactionTemplate extends DefaultTransactionDefinition implements InitializingBean{
 private PlatformTransactionManager tranactionManger = null;
 //通知依赖注入
 publc TransactionTemplate(PlatformTransactionManager transactionManager){
  this.transactionManager = transactionManager;
 }
 public void setTransactionManager(PlatformTransactionManager transaction transactionManager){
  this.transactionManger = transactionManager;
 }
 public PlatformTransactionManager getTransactionManager){
  return transactionManager;
 }
 //执行完毕后调用
 public void afterPropertiesSet(){
  if(this.transactionManager == null){
   throw new IllegalArgumentException("xxxxx");
  }
 }
 //在这里进行事务处理
 public Object execute(TransactionCallback action) throws TransactionException{
  TransactionStatus status = this.transactionManager.getTransaction(this);
  Object result = null;
  try{
   //执行具体方法
   result = action.doInTransaction(status);
  }catch(RuntimeException ex){
   rollbackOnException(status, ex);
   throw ex;
  }catch(Error err){
   rollbackOnException(status, err);
   throw err;
  }
  this.transactionManager.commit(status);
  return result;
 }


 //如果有异常就rollback
 private void rollbackOnException(TransactionStatus status, Throwable ex) throws TransactionException{
  try{
   this.transactionManager.rollback(status);
  }catch(RuntimeException ex2){
   throw ex2;
  }catch(Error err){
   throw err;
  }
 }
}


在有上面的api基础上，利用TransactionTemplate来实现事务处理。具体实例如下
>>>编程式事务处理


publc class HelloDAO{
 private DataSource dataSource;
 private PlatformTransactionManager transactionManager;
 //通过依赖注入来完善管理
 public void setDataSource(DataSource dataSource){
  this.dataSource = dataSource;
 }
 public void setTransactionManager(PlatformTransactionManager transactionManager){
  this.transactionManager = transactionManager;
 }
 //该方法进行事务处理
 public int create(String msg){
  TranactionTemplate transactionTemplate(transactionManager);
  Object result = transactionTemplate.execute(new TransactionCallback(){
   public Object doInTransaction(TransactionStatus status){
    //执行操作
    return resultObject;
   }
  });
 }
}
>>设置配置xml文件
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
 <!--使用SQLServer数据库-->
 <property name="driverClassName">
  <value>com.microsoft.jdbc.sqlserver.SQLServerDriver</value>
 </property>
 <!--设定url-->
 <property name="url">
  <value>jdbc:microsoft:sqlserver://localhost:1433/stdb</value>
 </property>
 <!--设定用户名-->
 <property name="name">
  <value>sa</value>
 </property>
 <!--密码-->
 <property name="msg">
  <value>123</value>
 </property>
</bean>
<!--设定transactionManager-->
<bean id="transactinManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
 <property name="dataSource">
  <ref bean="dataSource">
 </property>
</bean>
<!--示例中的一个dao-->
<bean id="helloDAO" class="com.langfei.xxxx.HelloDAO">
 <property name="dataSource">
  <ref bean="dataSource">
 </property>
 <property name="transactionManager">
  <ref bean="transactionManager"/>
 </property>
</bean>
说明一下：id为dataSource的bean，是采用DriverManagerDataSource的数据源


>>>声明式事务处理
1、添加aopallinace.jar
       cglib-nodep.jar


>>事例
public class HelloDao{
 private DataSource dataSource;
 privata JdbcTemplate jdbcTemplate;


 //依赖注入
 public void setDataSource(DataSource dataSource){
  this.dataSource = dataSource;
  jdbcTemplate = new JdbcTemplate(dataSource);
 }
 //注意这里看不到事务处理的代码，一切斗争配置文件中
 public void create(String sql){
  jdbcTemplate.update(sql);
 }
}


>>具体xml文件配置
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManageDataSource">
 <!--使用SQLServer数据库-->
 <property name="driverClassName">
  <value>com.microsof.jdbc.sqlserver.SQLServerDriver</value>
 </property>
 <!--设定URL-->
 .....
 <!--设定用户名-->
 ....
 <!--设定密码-->
 ....
</bean>


<!--设定transactionManager-->
....
<bean id="transactionManager">
</>
.....


<!--Dao-->
。。。。。
上面的具体配置跟编程式的一样，就简写啦，不同的在下面。


<!--声明事务处理-->
<bean id="helloDAOProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
 <property name ="transactionManager">
  <ref bean="transactionManager"/>
 </property>
 <!--致命代理的是HelloDAO类-->
 <property name="target">
  <ref bean="helloDAO">
 </property>
 
 <property name="transactionAttributes">
  <props>
   <!--表示HelloDAO中的create()方法进行事务管理，并指明如果当前没有事务，就新建一个事务-->
   <prop key="create">PROPAGATION_REQUIERD</prop>
  </props>
 </property>


 <!--
  PROPAGATION_REQUIRED: 如果当前没有事务，就新建一个事务
  PROPAGATION_SUPPORTS: 如果当前没有事务，就以非事务方式执行
  PROPAGATION_MANDATORY: 如果当前没有事务，就抛出异常
  PROPAGATION_REQUIRES_NEW:新建事务，如果当前存在事务，把当前事务挂起
  PROPAGATION_NOT_SUPPORTED:以非事务方式执行操作，如噶当前存在事务，就把当前事务挂起
  PROPAGATION_NEVER: 以非事务放水执行，如噶当前存在事务，则抛出异常
 
 -->
</bean>