[#0x0042] Spring AOP学习（二）：动态代理

　　如果系统中有500个类，每个类都要添加日志功能，此时无论是直接修改源代码、继承还是组合，都是十分巨大的工作量。此时AOP可以帮我们解决这个问题。

 

　　现在假设记录日志的功能已经单独提出来了，由LogInterceptor来完成：

package com.bjsxt.aop;

public class LogInterceptor {
	public void beforeMethod() {
		System.out.println("logging...");
	}
}

有了Spring AOP，我们就可以用配置文件来说明：“在某个类的每一个方法执行之前，都给我调用一次beforeMethod()方法”（更复杂一点的做法是给beforeMethod()方法添加一个Method参数，这样可以配置可以具体到某个类的某个方法上），如：

<beans>
	<bean id="u" class="com.bjsxt.dao.impl.UserDAOImpl" >
		<!-- 非标准写法，仅作演示 -->
		<Log class="com.bjsxt.aop.LogInterceptor" logMethod="beforeMethod" targetMethod="all" />
	</bean>
</beans>

这样，在配置文件中给500个bean都加上这么一段，就能给这500个类都加上日志功能了。

 

　　那么Spring AOP是如何实现的呢？用的是动态代理的方法。

　　参考[#0x0022]，我们可以把LogInterceptor实现成一个InvocationHandler

package com.bjsxt.aop;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class LogInterceptor implements InvocationHandler {
	private Object target;
	
	public Object getTarget() {
		return target;
	}

	public void setTarget(Object target) {
		this.target = target;
	}

	public void beforeMethod(Method m) {
		System.out.println(m.getName() + ": logging...");
	}

	public Object invoke(Object proxy, Method m, Object[] args)　throws Throwable {
		beforeMethod(m);
		m.invoke(target, args);
		return null;
	}
}

调用的代码如下： 

public class AOPTest
{
	public static void main(String[] args)
	{
		UserDAO userDAO = new UserDAOImpl();
		LogInterceptor li = new LogInterceptor();
		li.setTarget(userDAO);
		
		UserDAO userDAOProxy = (UserDAO)Proxy.newProxyInstance(userDAO.getClass().getClassLoader(), userDAO.getClass().getInterfaces(), li);
		
		userDAOProxy.save(new User());
	}
}

 

　　这里要特殊说明的是：

　　(1) userDAOProxy对象是UserDAOImpl类的动态代理，userDAOProxy是代理对象，UserDAOImpl对象是被代理对象；

　　(2) 若想用Java API来给某个类（如UserDAOImpl）来创建动态代理，那么这个类必须实现一个接口（如UserDAO），没有实现接口的类用Java API是无法创建动态代理的（但cglib可以）。所以在Proxy.newProxyInstance()方法中，需要把被代理类的接口，即userDAO.getClass().getInterfaces()传递进去。

　　(3) 代理对象和被代理对象应该在同一个classLoader中，如果在不同的classLoader中，它们就无法互相访问，所以userDAO.getClass().getClassLoader()也作为参数传递给了Proxy.newProxyInstance()。代理对象和被代理对象需要互相访问的原因在(4)

　　(4) 我们得到的userDAOProxy对象，其类型应该是一个组合了LogInterceptor的类（li作为参数被传递给了Proxy.newProxyInstance()），而LogInterceptor又组合了userDAOImpl（li.setTarget(userDAO)）；加上userDAOProxy又实现了UserDAO接口，所以userDAOProxy看上去应该是这样一个类：

// 非标准写法，仅作演示用
public class UserDAOProxy implements UserDAO {
	private InvocationHandler invocationHandler;

	public UserDAOProxy(InvocationHandler invocationHandler) {
		super();
		this.invocationHandler = invocationHandler;
	}

	public InvocationHandler getInvocationHandler() {
		return invocationHandler;
	}

	public void save(User user) {
		this.invocationHandler.invoke(proxy, UserDAO.class.getDeclaredMethod("save", User.class), user);
	}
}

（同[#0x0022]，invoke()方法中的proxy对象还是不知道是干嘛用的……视频中说这个proxy对象就是userDAOProxy自身，待研究）

　　这样，Proxy.newProxyInstance(userDAO.getClass().getClassLoader(), userDAO.getClass().getInterfaces(), li)也就相当于new UserDAOProxy(li)。userDAOProxy的save()方法的实际过程是：

Spring AOP为系统添加逻辑（业务逻辑，如上文的日志）的动态代理方法大抵就是这样。

　　如果UserDAO还有个delete()方法，那么userDAOProxy.delete()也会去调用li.invoke(proxy, delete, user)。这就体现了InvocationHandler是“对被代理对象的任意方法的invocation都handle”这么一个概念。

　　当然，更好的实现是把beforeMethod这部分逻辑提出来，让LogInterceptor这个类侧重“Interceptor”而不包含"Log"的逻辑，beforeMethod完全可以用一个Logger类来实现