代理模式

代理模式不仅仅是面试的一个高频考点，也是项目中用得非常多的一件工具。从一个非常简单的例子入手，假如我有一个接口Hello：

public interface Hello{
	void say(String name);
}

然后有一个实现类：

public class HelloImpl implements Hello{
	@Override
	public void say(String name){
		System.out.println("Hello!" + name);
	}
}

现在想在say方法的前面和后面处理一些逻辑，怎么办呢？当然可以把它们全部写在say方法里面，但是为了降低代码耦合度，我们可以用代理模式，写一个HelloProxy类，让它去调用HelloImpl的say方法。如：

public class HelloProxy implements Hello{
	private Hello hello;  //把接口设置成私有变量
	public HelloProxy(){
		hello = new HelloImpl();  //在构造方法中创建实现类的实例
	}
	
	@Override
	public void say(String name){
		before();
		hello.say(name);
		after();
	}
	
	private void before(){
		//...
	}
	private void after(){
		//...
	}
}

这就是简单的静态代理。为什么说是静态呢？因为假如你要给Hello1、Hello2、Hello3等等一共好多好多个类的好多好多个不同的方法全部加上before()和after()，那么你就得写一大堆xxxProxy类，每个类里面都是相似的逻辑。而为了避免这种情况，我们就要用动态代理。最简单的就是JDK自带的动态代理，也就是用Proxy.newProxyInstance()方法在程序中动态地创建一个xxx接口的代理类（前面提到的xxxProxy）。而这个方法一共三个参数，ClassLoader、要被代理的类的Interfaces、还有就是一个DynamicProxy类，我们需要用这个类去把要被代理的类“装”起来，同时在这个类中实现要被代理方法的处理，即之前的before()和after()。大概是这样的：

public class DynamicProxy implements InvocationHandler{
	private Object target;

	public DynamicProxy(Object target){
		this.target = target;
	}

	@Override
	public Object invoke(Object proxy, Method method, Objectp[] args) throws Throwable{
		before();
		Object result = method.invoke(target, args);
		after();
		return result;
	}
}

其中那个target变量就是被代理的目标对象。DynamicProxy实现了InvocationHandler接口，那么必须实现它的invoke()方法，通过反射调用method，在调用前后分别处理before和after，最后将方法的返回值result返回。
实际中的用法是这样的：

public static void main(String args[]){
	Hello hello = new HelloImpl();
	DynamicProxy dynaminProxy = new DynamicProxy(hello);  //把hello用DynamicProxy包起来
	Hello helloProxy = (Hello)Proxy.newProxyInstance(
		hello.getClass().getClassLoader();
		hello.getClass().getInterfaces();
		dynamicProxy
	); //生成代理类

	helloProxy.say("Jack"); //代理类调用方法
}

因为newProxyInstance的参数实在太多所以还可以进一步封装一下，返回一个泛型对象：

public class DynamicProxy implements InvocationHandler{
	...
	@SuppresWarnings("unchecked")
	public <T> T getProxy(){
		return (T) Proxy.newProxyInstance(
			target.getClass().getClassLoader();
			target.getClass().getInterfaces();
			this
		);
	}
	...
}

这时候直接使用getProxy就可以拿到代理对象了，不用写一大堆参数还要强制转型。
那么如果要代理一个没有任何接口的类，又要怎么办呢？
可以用CGlib这个类库，也是一个getProxy()解决，但首先要写一个CGLibProxy类实现它的MethodInterceptor（方法拦截器）接口：

public class CGLibProxy implements MethodInterceptor{
	public <T> T getProxy(Class<T> cls){
		return (T) Enhancer.create(cls, this);
	}
	public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable{
		//熟悉的代理逻辑
		before();
		Object result = method.invoke(target, args);
		after();
		return result;
	}
}

这时候就可以2行代码拿到代理对象：

CGLibProxy cgLibProxy = new CGLibProxy();
Hello helloProxy = cglibProxy.getProxy(HelloImpl.class);
helloProxy.say("Jack");

要是想做得再简单一点可以把CGLibProxy对象写成单例模式：

public class CGLibProxy implements MethodInterceptor{
	private static CGLibProxy instance = new CGLibProxy();

	private CGLibProxy(){
	}

	public static CGLibProxy getInstance(){
		return instance;
	}
	...
}

这是一个最简单的饿汉模式，这时候只需要：

Hello helloProxy = CGLibProxy.getInstance().getProxy(HelloImpl.class);

就可以拿到代理对象了。
CGLib创建代理的速度非常慢，而创建完后运行的速度却非常快。而JDK动态代理正好相反。如果在运行的时候不断地用CGLib去创建代理，效率就会下降，所以一般在系统初始化的时候采用CGLib创建代理，并放入Spring的ApplicationContext中备用。
除此之外还有一种方法实现代理，也就是使用AspectJ，它是一个面向切面的框架，定义了自己的AOP语法，所以它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。可以用插件的办法集成。
小结：代理模式有四种方法可以实现，分别是静态代理、JDK动态代理、CGLib动态代理、以及AspectJ。使用代理模式可以解决一个我们经常听到的问题——AOP（面向切面编程）。通过给原来的对象“套上”一层代理对象的“壳子”，可以解决许多诸如before\after之类的问题。
参考资料：《架构探险 从零开始写java web框架》