java 之DelayQueue,TaskDelayed,handlerFactory,dataChange消息配置.收发等.java spring事务处理TransactionTemplate

java 之DelayQueue,TaskDelayed,handlerFactory,dataChange消息配置.收发等.java spring事务处理TransactionTemplate等.

================================================================================

事物处理:

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.roolback();
 }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

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>