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>