事务的本质：让程序像我们看到的那样执行。

    数据库事务就是对于界定为同一个事务的一组数据库操作，要么同时成功，要么同时失败，不可能出现部分成功的中间状态。

    对于JDBC原生事务，首先要设置自动提交为false：connection.setAutoCommit(false)，如果整个执行过程没有异常则提交事务commit，否则就回滚rollback。对于原生态的jdbc事务，编码显得非常繁琐，并且对于整个系统的共性业务，特别适合用AOP的方式来实现。

    下面说到重点了，TeaFramework事务实现。

    1、事务的使用应该尽量简单，在方法或者class上加一个注解便可搞定，对于class有事务注解，那么该class所有方法都有进行事务控制。

@Target({ ElementType.TYPE, ElementType.METHOD }) @Retention(RetentionPolicy.RUNTIME) public @interface Transcation { }

    2、事务的传播

    事务的传播描述的是多个事务嵌套的问题，对于大部分场景而言，顶层方法有事务，则子事务被纳入当前事务，这种场景占80%，那么TeaFramework只实现这种事务传播。

    请看具体的代码

public class TranscationProxy extends AbstractProxy { 	private Logger logger = LoggerFactory.getLogger(getClass());  	@Override 	public void invoke(Proxy proxy) throws Throwable { 		BeanProxy beanProxy = (BeanProxy) proxy; 		boolean classHasTranscationAnnotation = beanProxy.getObj().getClass().getSuperclass() 				.isAnnotationPresent(Transcation.class); 		boolean methodHasTranscationAnnotation = beanProxy.getMethod().isAnnotationPresent(Transcation.class); 		if (TranscationThreadVariable.get() == null 				&& (classHasTranscationAnnotation || methodHasTranscationAnnotation)) {// 如果类或者方法有Transcation注解则进入 			try { 				before(proxy); 				proxy.invoke(proxy); 				after(proxy); 			} catch (Throwable e) { 				exception(proxy); 				throw e; 			} finally { 				end(beanProxy); 			} 		} else { 			proxy.invoke(proxy); 		}  	}  	@Override 	public void before(Proxy proxy) { 		try { 			TranscationThreadVariable.set(true); 			logger.debug("开启事务"); 			if (ConnectionThreadVariable.getConnetion() == null) { 				Connection connection = DataSourceHelp.getConnection(); 				connection.setAutoCommit(false); 				ConnectionThreadVariable.setConnetion(connection); 			} 		} catch (Exception e) { 			throw new TranscationException(e); 		} 	}  	@Override 	public void after(Proxy proxy) { 		try { 			logger.debug("提交事务"); 			ConnectionThreadVariable.getConnetion().commit(); 		} catch (Exception e) { 			throw new TranscationException(e); 		} 	}  	@Override 	public void exception(Proxy proxy) { 		try { 			logger.debug("回滚事务"); 			ConnectionThreadVariable.getConnetion().rollback(); 		} catch (Exception e) { 			throw new TranscationException(e); 		} 	}  	@Override 	public void end(Proxy proxy) { 		try { 			logger.debug("关闭连接"); 			ConnectionThreadVariable.getConnetion().close(); 		} catch (Exception e) { 			throw new TranscationException(e); 		} finally { 			ConnectionThreadVariable.clearThreadVariable(); 			TranscationThreadVariable.clearThreadVariable(); 		} 	}  } 

    这里本质上是实现了一个代理类，用AOP的思路来实现

    1、before：在事务开启之前，获取数据库连接，并设置自动提交为false

    2、after：执行过程如果没有任何异常，则提交事务

    3、exception：执行过程发生异常，则回滚事务

    4、end：执行结束，关闭数据库连接，归还给连接池

    那么事务的传播在哪里实现的呢？仅仅只有一行代码TranscationThreadVariable.set(true)，这行代码标示了当前线程中事务的状态，如果事务已经由上层方法开启，则下面所有的数据库操作与开启事务的方法共用一个数据库连接connection，那么就被纳入了一个事务。

    来看一个例子，在insert方法上加上@Transcation注解

@TeaDao("testDao") public interface TestDao {  	@Transcation 	@GetPrimaryKey(sql = "select s_users.nextval from dual", primaryKeyProperty = "id") 	@SQL("insert into users(id,name,password,createdate) values(#id#,#name#,#password#,#createdate#)") 	public int add(Map<String, Object> map);  	@DynamicSQL 	public int update();  	@SQL("delete from users") 	public int deleteUserById();  	@SQL("select * from users") 	public List<User> getAllUser();  	@DynamicSQL 	public List<User> findUser();  }

    执行结果：

    这就是TeaFramework事务的实现过程。

     项目地址：https://git.oschina.net/lxkm/teaframework
     博客：https://my.oschina.net/u/1778239/blog