Apache - Spring: 理解Spring的事务管理(一) - AOP (Aspect Oriented Programming)

一. 什么是AOP?

AOP 既是 面向切面编程.

在两个功能模块中，插入一个AOP组件，而该组件与这两个模块间具有源码无关性，也就是一点也不耦合在这两个功能模块间，倘若其中一个功能模块调用了该组件中的某个方法，则该组件不是AOP组件.

Spring 中运用 AOP 实现事务管理 就是一个很好的 例子.

 

二. 用静态Proxy方式 通过AOP 模拟实现Spring中的事务管理

UserDAO.java

public interface UserDAO {
	public void save(User user);
}

 

UserImpl.java

public class UserImpl implements UserDAO{

	public void save(User user){
		System.out.println("save user");
	}

}

 UserDAOProxy.java

public class UserDAOProxy implements UserDAO{
	private UserDAO _userDAO;
	
	public UserDAOProxy(UserDAO userDAO){
		_userDAO = userDAO; 
	}
	
	public void save(User user){
		UserTransaction t = null;
		
		try{
			t = (UserTransaction)(new InitialContext().lookup("java/tx") );
			
			_userDAO.save(user);
			
			t.commit();
		}catch(Exception e){
			if( t != null ){
				try {
					t.rollback();
				} catch (Exception ex){
					
				}
			}
		}
		
	}

Test Code

public void testProxyAOP(){
    UserDAO userDAO = new UserDAOProxy( new UserImpl );
    userDAO.save(); // 事务已经通过 UserDAOProxy 加载
}

   

思想， 用 Proxy 类 UserDAOProxy.java 构造 一个AOP切面 实现一个绑定了事务的 UserDAO.

  1. 这个切面 与 UserImpl 代码无关.

  2. 通过这个切面我们给UserImpl绑定上了事物.

静态Proxy实现的弊端 - 需要针对每个DAO实现一个DAOProxy. - impossible for the implementation of a large project

 

三. 用动态Proxy 通过AOP 模拟实现Spring中的事务管理

   动态Proxy顾名思义就是自动实现DAOProxy的调用

   首先来看个例子，在User实体和操作实体之间做个切面，该切面的作用是判断该User是不是管理员，是则可以修改用户信息，若不是，则不能.

User.java

public class User {
	public static final int NORMAL_USER = 1;
	public static final int ADMIN_USER = 2;
	
	private int _userPrivilege = 0;
	
	public User(int p){
		checkUserPrivilege();
		_userPrivilege = p;
	}

	public int getUserPrivilege(){
		return _userPrivilege;
	}
	
	private void checkUserPrivilege() {
		// TODO implementation.
		
	}
	
}

 

OperationDAO.java

public interface OperationDAO {
	
	public void modifyCustomerInfo(User u);
	
}

 

UserOperationDAOImpl.java

public class UserOperationDAOImpl implements OperationDAO {
	 // only Admin can modify user info
	public void modifyCustomerInfo(User u) {
		// TODO Auto-generated method stub
		System.out.println("the user info modified ~~ ");
	}
}

 

 UserOperationHandler.java (the dynamic proxy handler)

public class UserOperationHandler implements InvocationHandler {
	
	private Object _source;
	
    /**
     * Returns an instance of a proxy class for the specified interfaces
     * that dispatches method invocations to the specified invocation handler.
     * @param	loader the class loader to define the proxy class
     * @param	interfaces the list of interfaces for the proxy class to implement
     * @param   h the invocation handler to dispatch method invocations to
     * @return	a proxy instance with the specified invocation handler of a proxy class 
     * 			that is defined by the specified class loader and 
     * 			that implements the specified interfaces 
     */
	public Object bind(Object source){
		_source = source;
		return Proxy.newProxyInstance(_source.getClass().getClassLoader(),
				_source.getClass().getInterfaces(), this);
	}
	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		// TODO Auto-generated method stub
		User u = (User)args[0];
		if( u.getUserPrivilege() == User.ADMIN_USER ){
			method.invoke(_source, args);
		}else{
			System.out.println("you have no privilege");
		}
		return null;
	}

}

UserOperationDAOImplTest.java

public class UserOperationDAOImplTest {
	
	@Test
	public void testAOPInvoke(){
		UserOperationHandler handler = new UserOperationHandler();
		
		OperationDAO dao = (OperationDAO) handler.bind( new UserOperationDAOImpl() );
		User normalUser = new User( User.NORMAL_USER );
		dao.modifyCustomerInfo(normalUser);

		User adminUser = new User( User.ADMIN_USER );
		dao.modifyCustomerInfo( adminUser );
	}
}	

运行结果如下:

you have no privilege
the user info modified ~~ 

   这样，我们通过 AOP切面（UserOperationHandler ） 实现了User实体和Operation实体之间的简单的权限管理. 但需注意的是，UserOperationHandler 是与User实体,Operation实体间是独立的，无丝毫代码相关性.

     现在我们已经熟悉了什么是动态Proxy. 关键部分总结如下:

          1. return Proxy.newProxyInstance(_source.getClass().getClassLoader(), _source.getClass().getInterfaces(), this); 根据传入的“接口类型(_source.getClass().getInterfaces())”动态构造一个“代理类实例”返回, 该代理类就是JVM在内存中根据指定的“接口类型”动态构造的动态类，并实现了传入的所有接口. 这里看出， Dynamic要求所代理的类必须是某个接口的实现，否则则无法构造出相应的 动态类。（Spring 则是使用的动态Proxy管配置和管理事务，所以每个Service必须加上一个接口）

          2. UserOperationHandler#invoke() 方法将在被代理类(UserOperationDAOImpl)的方法之前触发. 这样我们就可以在“被代理类方法调用的前后”进行一些处理.

    再次, 修改静态 UserDAOProxy.java 使其成为 动态Proxy

 

public class UserDAOAOPProxy implements InvocationHandler {

	private Object _source;

	public Object bind(Object source) {
		_source = source;
		return Proxy.newProxyInstance(_source.getClass().getClassLoader(),
				_source.getClass().getInterfaces(), this);
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		// TODO Auto-generated method stub
		Object result = null;
		// added the transaction according with the action name.
		if (!method.getName().startsWith("save")) {
			UserTransaction tx = null;
			try {
				tx = (UserTransaction) (new InitialContext().lookup("java/tx"));
				result = method.invoke( _source, args);
				tx.commit();
			} catch (Exception ex) {
				if (null != tx) {
					try {
						tx.rollback();
					} catch (Exception e) {
					}
				}
			}
		} else {
			result = method.invoke( _source, args);
		}
		return result;
	}

}

   这样，就实现了UserDAO的动态Proxy. 稍微需要注意的是，这里我通过Hard Coded把事务加在了“save" 方法上. 实际上我们可以通过配置文件导入，就像Spring那样，如下:  

<property name="transactionAttributes">
   <props>
      <prop key="save*">PROPAGATION_REQUIRED</prop>
      <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
   </props>
</property>

    这里涉及的只是简单的理解Spring如何通过AOP如何实现事务管理，而Spring的整个事务管理机制远比这个复杂，比如事务的PROPAGATION，传递之类的....

四. CGLIB

    前面涉及的是如何通过接口动态实现AOP，而CGLIB正式通过实体类实现AOP

    个人感觉他的实现方式有异曲同工之妙，

         CGLIB是通过生成 目标类的 一个子类

         Dynamic Proxy是通过生成 目标类的 一个 Proxy代理类.

    两者的关系可以用下图表示