初探AOP内部实现

• 背景

想要了解Spring框架，那可以说AOP(面向切面编程)是必须要了解的。为此，查阅了很多资料，看过了很多网上的很多介绍，还是没有给我满意的答案，最终在一名老师（铁血教主）的指导下，才真正了解到了内部看似复杂无比的架构。AOP在如今的很多大型项目中都有涉及，主要为了解决添加日志，安全检查，权限管理等的问题。简单来说，就是利用代理，对某些方法的执行进行拦截或者管理。

• 原理

AOP其实就是利用代理机制对一个类形成一个代理对象，然后使用这个代理对象执行方法。有人可能问了，这有什么用？用处大了，利用代理对象执行原方法，我们便可以对代理对象进行限制，在其调用方法时加以控制。那为什么不直接对原对象控制呢？个人理解是这样的。使用代理的话，原类可以专心实现他的功能，而把权限管理，安全检查等问题，在外部实现，达到互不干涉却又可以共同工作的目的。

由于AOP主要依靠的便是代理机制，而我们最常用的代理便是JDKProxy和CGLIBProxy,这两种代理各有利弊，可以用于不同的场合。

JDKProxy:   指定类必须要实现一个接口，也就是说，如果被代理对象已经封装好，不能修改，那么就不能使用这个代理。并且由于返回的是一个接口对象，使得代理仅仅能够执行接口中的方法。

@SuppressWarnings("unchecked")
	private <T> T jdkProxy(Object object, Class<?> klass) {
		ClassLoader classLoader = klass.getClassLoader();
		Class<?>[] interfaces = klass.getInterfaces();
		
		InvocationHandler invocationHandler = new InvocationHandler() {
			
			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				return doInvoker(object, method, args);
			}
		};
		
		return (T) Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
	}

CGLIBProxy:  这个代理不需要实现接口，它的实现思想是用原类作为基类，用派生类的对象去执行方法。是不是感觉这个代理还是很不错的，当然，也有局限性，其一，原类必须拥有无参构造方法，也就是说允许继承。其二，原类的final方法不能被继承，那么代理也就不能执行final方法。

@SuppressWarnings("unchecked")
	private <T> T cglProxy(Object object, Class<?> klass) {
		Enhancer enhancer = new Enhancer();
		enhancer.setSuperclass(klass);
		MethodInterceptor methodInterceptor = new MethodInterceptor() {
			@Override
			public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
				return doInvoker(object, method, args);
			}
		};		
		enhancer.setCallback(methodInterceptor);
		
		return (T) enhancer.create();
	}

两种方法各有利弊，适用于不同的场合。不过大多数情况我们使用的还是CGLIBProxy。

• 注意事项

用代理对象执行方法时，调用原类中的方法的对象还是原对象，不是代理，这里给大家用代码加以验证。

我们现在这个方法里输出this，便可以看到，执行该方法的到底是谁？

	public int getNum() {
		System.out.println("this.getClass()：" + this.getClass());
		return num;
	}

		NormalClass normalClass = new NormalClass();//这是一个普通类，里面只有一个num成员
		normalClass.setNum(123);
		NormalClass normalClassProxy = new CGLibProxy().getProxy(normalClass);
		System.out.println("原对象的num" + normalClass.getNum());
		System.out.println("normalClass.getClass()：" + normalClass.getClass());
		System.out.println("代理对象的num" + normalClassProxy.getNum());
		System.out.println("normalClassProxy.getClass()" + normalClassProxy.getClass());

很明显可以看出，用代理执行该方法，在执行到该方法时，是原对象调用，不是代理在调用。这点必须清楚，而非原类的方法，才是代理调用。

• 大体框架介绍

好了，这才开始正式说AOP。先大概说一下整体的设计思路

• 代码是最好的老师

首先给出ProxyFactory的实现方式，这里其实是将两种代理的获取方式都放在factory里，没什么难度。但这里需要注意，每次代理生成的时候，要自动将生成一个ProxyPackage对象，并将代理注入。

public class ProxyFactory {
	private ProxyPackage proxyPackage;
	
	ProxyFactory() {
	}
	
	ProxyPackage getproxyPackage() {
		return proxyPackage;
	}
	
	//这里在每次取得代理时，会自动生成proxyPackage对象，无需手动生成，方便以后的map的put
	<T> T getCGLProxy(Object object, Class<?> klass) {
		T proxy = cglProxy(object, klass);
		proxyPackage = new ProxyPackage();
		proxyPackage.setProxy(proxy);
		proxyPackage.setObject(object);
		
		return proxy;
	}
	
	@SuppressWarnings("unchecked")
	private <T> T cglProxy(Object object, Class<?> klass) {
		Enhancer enhancer = new Enhancer();
		enhancer.setSuperclass(klass);
		MethodInterceptor methodInterceptor = new MethodInterceptor() {
			@Override
			public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
				return doInvoker(object, method, args);
			}
		};		
		enhancer.setCallback(methodInterceptor);
		
		return (T) enhancer.create();
	}
	

//这里的DOInvoke()方法，在proxyPackage中实现
	private Object doInvoker(Object object, Method method, Object[] args) throws Throwable {
		Object result = null;
		// 前置拦截
		if (proxyPackage.doBefore(method, args) == false) {
			return null;
		}
		try {
			result = method.invoke(object, args);
			// 后置拦截
			proxyPackage.doAfter(method, result);
		} catch (Throwable e) {
			// 异常拦截
			proxyPackage.doDealException(method, e);
			throw e;
		}
		
		return result;
	}
	
	<T> T getJDKProxy(Object object, Class<?> klass) {
		T proxy = jdkProxy(object, klass);
		proxyPackage = new ProxyPackage();
		proxyPackage.setProxy(proxy);
		
		return proxy;
	}
	
	@SuppressWarnings("unchecked")
	private <T> T jdkProxy(Object object, Class<?> klass) {
		ClassLoader classLoader = klass.getClassLoader();
		Class<?>[] interfaces = klass.getInterfaces();
		
		InvocationHandler invocationHandler = new InvocationHandler() {
			
			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				return doInvoker(object, method, args);
			}
		};
		
		return (T) Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
	}

这就是要封装成的代理类，每一个代理要附带这个代理需要的拦截器。当用这个代理执行方法 时，要一层层通过拦截器的审核。我们在实现时，主要加了置前拦截，置后拦截，异常拦截，当然这只是在Test。

public class ProxyPackage {
	private Object proxy;			//取得的代理
	private Object object;			//原对象
	private boolean injection;		//这是为了之后的ioc做准备的，可以先不考虑
	private List<Intercepter> intercepterList;

	ProxyPackage() {
		this.intercepterList = new ArrayList<>();
		injection = false;
	}
	
	Object getObject() {
		return object;
	}
	
	boolean isInjection() {
		return injection;
	}

	void setInjection(boolean injection) {
		this.injection = injection;
	}

	void setObject(Object object) {
		this.object = object;
	}

	void addIntercepter(Intercepter intercepter) 
			throws IntercepterAlreadyExistException {
		if (intercepterList.contains(intercepter)) {
			String intercepterName = intercepter.getClass().getName();
			throw new IntercepterAlreadyExistException("拦截器(" 
					+ intercepterName + ")已存在！");
		}
		intercepterList.add(intercepter);
	}
	
	void removeIntercepter(Intercepter intercepter) {
		if (!intercepterList.contains(intercepter)) {
			return;
		}
		intercepterList.remove(intercepter);
	}

	boolean doBefore(Method method, Object[] args) {
		for (Intercepter intercepter : intercepterList) {
			if (!intercepter.getMethod().equals(method)) {
				continue;
			}
			if (intercepter.before(args) == false) {
				return false;
			}
		}
		
		return true;
	}
	
	Object doAfter(Method method, Object result) {
		for (Intercepter intercepter : intercepterList) {
			if (!intercepter.getMethod().equals(method)) {
				continue;
			}
			result = intercepter.after(result);
		}
		
		return result;
	}
	
	void doDealException(Method method, Throwable e) {
		for (Intercepter intercepter : intercepterList) {
			if (!intercepter.getMethod().equals(method)) {
				continue;
			}
			intercepter.dealException(e);
		}
	}
	
	<T> ProxyPackage setProxy(T proxy) {
		this.proxy = proxy;
		
		return this;
	}
	
	@SuppressWarnings("unchecked")
	<T> T getProxy() {
		return (T) proxy;
	}

每一个拦截器对象要注明klass和method.用来标注是为那个指定方法加的拦截器。

public abstract class Intercepter {
	private Class<?> klass;
	private Method method;

	public Intercepter() {
	}
	
	public Intercepter(Class<?> klass, Method method) {
		this.klass = klass;
		this.method = method;
	}
	
	public abstract boolean before(Object[] args);
	public abstract Object after(Object reault);
	public abstract void dealException(Throwable e);
	
	public void setMethod(Method method) {
		this.method = method;
	}
	
	public Method getMethod() {
		return method;
	}
	
	public void setKlass(Class<?> klass) {
		this.klass = klass;
	}
	
	public Class<?> getKlass() {
		return klass;
	}

给出适配器，让用户选择性覆盖使用。

public class IntercepterAdapter extends Intercepter {

	public IntercepterAdapter() {
	}

	public IntercepterAdapter(Class<?> klass, Method method) {
		super(klass, method);
	}

	@Override
	public boolean before(Object[] args) {
		return true;
	}

	@Override
	public Object after(Object result) {
		return result;
	}

	@Override
	public void dealException(Throwable e) {
	}

最后将给一个map来装每一个类的代理，方便以后使用。这里要注意，我们只考虑了单例模式，至于多例模式，见后文。

public class ProxyBeanFactory {
	private static final Map<String, String> beanNameMap;//这是IOC要用的，这里先不做叙述
	private static final Map<String, ProxyPackage> beanMap;
	
	static {
		beanMap = new HashMap<>();
		beanNameMap = new HashMap<>();
	}
	
	protected ProxyBeanFactory() {
	}
	
	protected void addBeanName(String beanName, String className)
			throws Exception {
		String orgClassName = beanNameMap.get(beanName);
		if (orgClassName != null) {
			throw new BeanNameAlreadyExistException("Bean名称("
					+ beanName + ")重复！");
		}
		beanNameMap.put(beanName, className);
	}
	
	protected String getBeanClassName(String beanName) {
		return beanNameMap.get(beanName);
	}
	
	protected void createCGLProxy(Object object) throws Exception {
		cglProxy(object, object.getClass());
	}
	
	protected void createCGLProxy(Class<?> klass) throws Exception {
		cglProxy(klass.newInstance(), klass);
	}
	
	protected ProxyPackage getMecProxy(String className) {
		return beanMap.get(className);
	}
	
	protected <T> T getProxy(Class<?> klass) {
		ProxyPackage mecProxy = beanMap.get(klass.getName());
		if (mecProxy == null) {
			return null;
		}
		return mecProxy.getProxy();
	}
	
	private void cglProxy(Object object, Class<?> klass) throws Exception {
		String className = klass.getName();
		ProxyPackage mecProxy = beanMap.get(className);
		if (mecProxy != null) {
			// TODO 应该抛异常
			return;
		}
		
		ProxyFactory proxyFactory = new ProxyFactory();
		proxyFactory.getCGLProxy(object, klass);
		beanMap.put(className, proxyFactory.getproxyPackage());
		
		return;
	}
	
	protected <T> T getJDKProxy(Object object) throws Exception {
		return jdkProxy(object, object.getClass());
	}
	
	protected <T> T getJDKProxy(Class<?> klass) throws Exception {
		return jdkProxy(klass.newInstance(), klass);
	}
	
	private <T> T jdkProxy(Object object, Class<?> klass) throws Exception {
		String className = klass.getName();
		ProxyPackage mecProxy = beanMap.get(className);
		if (mecProxy != null) {
			return mecProxy.getProxy();
		}
		
		ProxyFactory proxyFactory = new ProxyFactory();
		T proxy = proxyFactory.getJDKProxy(object, klass);
		beanMap.put(className, proxyFactory.getproxyPackage());
		
		return proxy;
	}
	
	protected void addIntercepter(Class<?> klass, Intercepter intercepter)
			throws Exception {
		if (!intercepter.getKlass().equals(klass)) {
			return;
		}
		beanMap.get(klass.getName()).addIntercepter(intercepter);
	}
	
	protected void removeIntercepter(Class<?> klass, Intercepter intercepter) {
		beanMap.get(klass.getName()).removeIntercepter(intercepter);
	}

写了这么多，赶紧给出一个Test。

public class NormalClassIntercepter extends MecIntercepterAdapter {

	public NormalClassIntercepter(Class<?> klass, Method method) {
		super(klass, method);
	}

	public NormalClassIntercepter() {
	}

	@Override
	public boolean before(Object[] args) {
		for (Object arg : args) {
			System.out.println(arg);
		}
		return true;
	}

	@Override
	public Object after(Object result) {
		System.out.println(result);
		return result;
	}

	public static void main(String[] args) throws NoSuchMethodException, SecurityException {
		//这是要代理的类
		Class<?> klass = NormalClass.class;
		Method method = klass.getDeclaredMethod("normalAction", new Class<?>[] { String.class} );
		//
		NormalClassIntercepter intercepter = new NormalClassIntercepter(NormalClass.class, method);
		
		BeanFactory beanFactory = new BeanFactory();
		try {
			NormalClass normal = beanFactory.getCGLProxy(NormalClass.class);
			beanFactory.addIntercepter(klass, intercepter);
			
			System.out.println("函数执行结果是" + normal.normalAction("abcde"));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

这里只添加了一个拦截器，可以看到已经可以看到拦截器的雏形了。当执行原方法时，实际上上是从fatory中取得bean（这里就是代理），然后利用代理执行原方法，便可以在执行时加以控制。当然可以发现，我们拦截器的添加，实际上是需要手动添加的，可是这不是很麻烦吗。有什么简单办法呢，这是便需要IOC的引入，为我们自动扫描拦截器或者bean，并且自动注入。