手写spring事务管理器

前面已经手写了数据库查询框架，现在开始进入正题手写事务管理器，什么是事务啥定义的这里不废话，请自行查阅书籍或网络文献。

这里来手写JDBC事务管理器，思考spring中使用注解@Transactional为什么就能进行事务控制？

好了直接进入正题，需要具备的基础知识如下:

1. Java反射，注解技术
2. 动态代理技术
3. ThreadLocal(方便理解，就是一个HashMap，key是当前执行线程的ID，value则是自定义设置的值，每个线程有独立的值)

这里复习下JDBC事务是如何实现的:

Connection conn=getConnection();//自定义实现
try{  
    conn.setAutoCommit(false);
    //做多个数据库update操作
    
    //提交
    conn.commit();
} catch (Exception e) {
    conn.rollback();
}finally{

}

JDBC事务的逻辑就是

1. 关闭自动提交
2. 执行数据库更新业务
3. 手动提交事务
4. 若发生异常则回滚 

可以看出跨Dao控制事务的原理，就是多个dao共同使用同一个连接不能被关系，且连接关闭自动提交。

我们思考spring的事务管理是在service层，对service层的每个方法进行代理拦截，判断该方法若有@Transactional事务注解，那么就为该方法增强，添加事务控制，实现事务service方法代理增加事务拦截，接下来我们开始实现

新建事务标识注解

@Target({ ElementType.METHOD, ElementType.TYPE })
	@Retention(RetentionPolicy.RUNTIME)
	@Inherited
	@Documented
	public @interface Transactional {
		String value() default "";
	}

新建事务管理器,实现事务控制的几个方法行为，ThreadLocal可以保证每条线程获取的资源为同一个

public class TranscationalManager {

	/**
	 * 开启事务
	 */
	final static ThreadLocal transcational = new ThreadLocal();

	/**
	 * 数据库连接
	 */
	final static ThreadLocal currentConnection = new ThreadLocal();

	static DataSource dataSource;


    /**
	 * 事务开启
	 */
	static void openTranscational() {
		transcational.set(true);
	}

	/**
	 * 是否开启事务 true开启/false未开启
	 */
	static boolean isOpenTranscational() {
		boolean result = false;
		if (transcational.get() == null) {
			result = false;
		} else {
			result = transcational.get();
		}
		return result;
	}

	/**
	 * 事务关闭
	 */
	static void closeTranscational() {
		transcational.set(false);
	}

	/**
	 * 事务提交
	 */
	static void commit() throws SQLException {
		Connection conn = currentConnection.get();
		if (conn != null) {
			conn.commit();
		}
	}

	/**
	 * 回滚
	 */
	static void rollback() throws SQLException {
		Connection conn = currentConnection.get();
		if (conn != null) {
			conn.rollback();
		}
	}

	/**
	 * 关闭连接，需要先关闭事务在调用此方法
	 */
	static void closeConnection() throws SQLException {
		closeTranscational();
		Connection conn = currentConnection.get();
		if (conn != null) {
			conn.close();
		}
	}

	/**
	 * 释放资源
	 */
	static void release() {
		transcational.remove();
		currentConnection.remove();
	}

}

接下来是数据库连接代理，目的是代理close方法，在开启事务时候，不关闭连接

public class ConnectionProxy implements InvocationHandler {
		Connection targetConn;

		public Connection proxyConnection(Connection targetConn) {
			this.targetConn = targetConn;
			Connection proxyConn = (Connection) Proxy.newProxyInstance(targetConn.getClass().getClassLoader(),
					new Class[] { Connection.class }, this);
			return proxyConn;
		}

		@Override
		public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
			if (method.getName().equals("close")) {
				// 清除当前的数据库连接
				if (isOpenTranscational()) {
					// 若开启事务的 连接将不做操作
					return null;
				}
				targetConn.setAutoCommit(true);
				targetConn.close();
				return null;
			}

			Object result = method.invoke(targetConn, args);
			return result;

		}

		public Connection getTargetConn() {
			return targetConn;
		}
	}

事务管理切面实现，service的方法有加事务注解的，那么将事务管理控制，这里仅仅实现了，如果当前存在事务，那么新的事务就加入该事务，类似spring 事务还有其他传播特性(如新开事务等)，这里没有实现，剩下留给大家了，这里主要是学习思想

public class TranscationalInvocationHandler implements InvocationHandler {
		public static Object proxyTranscational(Object service) throws InstantiationException, IllegalAccessException {
			// 此处若有 @Transactional 代理
			Class clazz = service.getClass();
			Class[] interfaces = clazz.getInterfaces();
			boolean isProxy = false;
			for (Method method : clazz.getDeclaredMethods()) {
				if (method.isAnnotationPresent(Transactional.class)) {
					isProxy = true;
					break;
				}
			}
			if (isProxy) {
				return Proxy.newProxyInstance(clazz.getClassLoader(), interfaces,
						new TranscationalInvocationHandler(service));
			} else {
				return service;
			}
		}

		Object traget;

		public TranscationalInvocationHandler(Object bean) {
			this.traget = bean;
		}

		public Object getTraget() {
			return traget;
		}

		@Override
		public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

			Object invoke = null;

			Method declaredMethod = traget.getClass().getDeclaredMethod(method.getName(), method.getParameterTypes());

			// 不需要事务
			if (!declaredMethod.isAnnotationPresent(Transactional.class)) {
				try {
					return method.invoke(traget, args);
				} catch (InvocationTargetException e) {
					throw e.getTargetException();
				} finally {
					// 原本不存在事务时候 才释放资源
					if (!TranscationalManager.isOpenTranscational()) {
						TranscationalManager.closeConnection();// 防止开发者在dao层面拿取数据库连接 没有关闭导致连接泄漏
						TranscationalManager.release();
					}
				}
			}

			// 如果原本存在事务，那么加入事务
			if (TranscationalManager.isOpenTranscational()) {
				try {
					// 数据库连接处理
					return invoke = method.invoke(traget, args);
				} catch (InvocationTargetException e) {
					TranscationalManager.rollback();
					throw e.getTargetException();
				}
			}

			// 需要开启事务
			try {
				// 有事务注解的开启事务
				TranscationalManager.openTranscational();
				// 数据库连接处理
				invoke = method.invoke(traget, args);
				TranscationalManager.commit();
			} catch (InvocationTargetException e) {
				TranscationalManager.rollback();
				throw e.getTargetException();
			} finally {
				// 关闭连接 释放资源
				TranscationalManager.closeConnection();
				TranscationalManager.release();
			}
			return invoke;
		}

	}

事务管理器获取数据库连接代理主入口

/**
	 * 获取数据库连接
	 */
	public static Connection getConnection() throws SQLException {
		if (currentConnection.get() != null) {
			return currentConnection.get();
		}
		Connection conn = dataSource.getConnection();
		ConnectionProxy connectionProxy = new ConnectionProxy();
		Connection proxyConnection = connectionProxy.proxyConnection(conn);
		currentConnection.set(proxyConnection);
		
		if(TranscationalManager.isOpenTranscational()){
			conn.setAutoCommit(false);
		}else{
			conn.setAutoCommit(true);
		}
		
		return proxyConnection;
	}

事务管理器代理service层接口

	/**
	 * 代理service层的事务控制
	 */
	@SuppressWarnings("unchecked")
	public static  T proxyTranscationalService(T serviceBean) {
		try {
			return (T) TranscationalInvocationHandler.proxyTranscational(serviceBean);
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

 到这里我们已经实现了事务管理器，接下来开始测试

准备：数据库mysql，在test用户下新建user表

CREATE TABLE `user` (
  `user_name` varchar(255) DEFAULT NULL,
  `password` varchar(255) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

 新建service层的接口与实现类

/**
	 * 测试接口类
	 */
	public interface UserService{
		void modifyUsers() throws Exception;
	}
	
	

这里实现service俩个dao操作，分别往同一张user表插入数据，获取2次连接，使用完分别关闭连接，并没有手动控制事务(在mybatis更新操作中，用户是屏蔽数据库连接的，这里为了与其他知识解耦，这里就简单JDBC操作来替代了)

public class UserServiceImpl implements UserService{

		/**
		 * 加上事务注解
		 */
		@Transactional
		@Override
		public void modifyUsers() throws Exception {
		
			//操作1与操作2 同属于一个事务，
			//模拟dao操作1
			Connection conn = TranscationalManager.getConnection();
			PreparedStatement pst = conn.prepareStatement(" insert into user(user_name,password) values('姓名1','123' ) ");
			pst.executeUpdate();
			pst.close();
			conn.close();
			if(true) {
//				throw new RuntimeException("强制异常，让后面的执行不了，会发现前者并没有插入到数据库库中");
			}
			//模拟dao操作2
			Connection conn1 = getConnection();
			PreparedStatement pst1 = conn1.prepareStatement(" insert into user(user_name,password) values('姓名2','123' ) ");
			pst1.executeUpdate();
			pst1.close();
			conn1.close();
			
			if(true) {
				throw new RuntimeException("强制异常，让后面的执行不了，会发现前者并没有插入到数据库库中");
			}
		}
	}

  接下来就是主函数测试，执行后发生了异常，可以观察数据库表并没有新增数据，可以自行注释修改 if(true)的代码段，分别表示发生异常的时候，数据将回滚，如果没有异常，那么会发现数据库新增2条数据

/**
	 * 主函数测试
	 */
	public static void main(String[] args) {
		
		//原本的service层的
		UserService userService = new UserServiceImpl();
		
		//事务管理代理
		userService = proxyTranscationalService(userService);
	
		try {
			//执行更新
			userService.modifyUsers();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

跨Dao事务在service层实现了事务管理，可以发现这些框架都是基于动态代理的灵活运用，将逻辑可以在各个切面进行插入，这就是所谓的切面编程AOP

另外本人该分类章节下所有文字与程序代码都是鄙人纯所写，鄙人其实从来没看过开源框架源码，纯靠使用开源框架的特性逆向思考分析它是如何实现的(那些框架在我眼中最初版本也就是我这样的，然后不断迭代，程序框架不断的提炼，使用设计模式程序分层抽象，方便扩展)，最后附上源码下载链接:TranscationalManager.java-互联网文档类资源-CSDN下载

接下来可以思考下"分布式事务"是如何的实现的呢? 看完了点个关注，评论下，谢谢支持！ 后续我将分享"如何手写分布式事务框架"