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>