代理模式（从静态代理到动态代理）

代理模式的定义：

为其它对象提供一个代理对象，并由代理对象控制这个对象的访问。

代理模式的作用：

个人理解：需要在不修改源码的情况下，将方法进行增强。

举例：

定义一个接口 Barking

public interface Barking {
   void bark();
}

实现类有 Dog

public class Dog implements Barking{
   public Dog() {
   }
   public void bark() {
      System.out.println("dog barking...");
   }
}

现在想要对Dog的bark方法进行增强，比如：怒吼一声前，先吃饱东西。

public class HungryDog implements Barking {
   private Barking target;

   public HungryDog(Barking target) {
      this.target = target;
   }

   public void bark() {
      System.out.println("eating first...");
      target.bark();
   }
}

那么HungryDog就作为静态代理类，增强了bark()方法，它代替了真实对象提供服务。

动态代理

假如对于所有的Animal类及其子类，都想进行同一种增强。这时候使用静态代理的话，每一个真实类都要创建一个对应的静态代理类，这在代码的复用性上就大打折扣了。

动态代理解决了这一问题。首先介绍JDK动态代理，这种动态代理方式是由反射机制实现的。

1. JDK动态代理

在JDK动态代理中需要实现接口：java.lang.reflect.InvocationHandler

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

public class JDKProxy implements InvocationHandler {
   //真实对象
   private Object target;

   /**
    * 绑定真实对象，并返回代理对象
    * @param target
    * @return
    */
   public Object binding(Object target) {
      this.target = target;
      Class clazz = target.getClass();
      //返回代理对象
      return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
   }
   
   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      System.out.println("使用JDK动态代理对方法进行增强...");
      //调用原方法
      Object result = method.invoke(target, args);
      return result;
   }
}

Object proxy = Proxy.newProxyInstance(target.getClass().getClassLoader(), //类的加载器
target.getClass().getInterfaces(), //对象的接口，明确代理对象挂在哪些接口下

this);//指明代理类，this代表用当前类对象，那么就要求其实现InvocationHandler接口

可以这样使用代理对象：

public class Test {
	public static void main(String[] args) {
		//jdk代理
		Dog dog = new Dog();
		JDKProxy jdkProxy = new JDKProxy();
		Object o = jdkProxy.binding(dog);
		Barking bark = (Barking) o;
		bark.bark();
	}
}

结果输出为：

使用JDK动态代理对方法进行增强...
dog barking...

对于JDK 的Proxy,有以下几点：

1）Interface：对于JDK proxy，真实类是需要一个Interface的，这也是一个缺陷

2）Proxy，Proxy 类是动态产生的，这个类在调用Proxy.newProxyInstance(targetCls.getClassLoader, targetCls.getInterface,InvocationHander)之后，会产生一个Proxy类的实例。实际上这个Proxy类也是存在的，不仅仅是类的实例。这个Proxy类可以保存到硬盘上。

3） Method:对于真实类的每个方法，现在Proxy类里面都不用静态显示出来

4） InvocationHandler: 这个类在真实类执行时，会先调用invoke方法。invoke方法再执行相应的代理操作，可以实现对业务方法的再包装

2. CGLIB动态代理

  JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，他的原理是生成真实类的一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。

真实类Wolf：

public class Wolf {

	public void bark() {
		System.out.println("wolf barking...");
	}
}

代理类

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CglibProxy implements MethodInterceptor {
	//真实对象
	private Object target;

	/**
	 * 创建真实对象的代理对象
	 * @param target
	 * @return
	 */
	public Object getInstance(Object target) {
		this.target = target;
		Enhancer enhancer = new Enhancer();
		enhancer.setSuperclass(this.target.getClass());
		//回调方法
		enhancer.setCallback(this);
		//创建代理对象
		return enhancer.create();
	}

	public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
		System.out.println("cglib 动态代理进行方法增强...");
		Object result = methodProxy.invokeSuper(o, objects);
		return result;
	}
}

测试

public class Test {
	public static void main(String[] args) {
		//cglib代理
		Wolf wolf = new Wolf();
		CglibProxy cglibProxy = new CglibProxy();
		wolf = (Wolf) cglibProxy.getInstance(wolf);
		wolf.bark();
	}
}

输出

cglib 动态代理进行方法增强...
wolf barking...

总结

在Spring AOP实现中 ，以上两种动态代理方式都被使用到了。总的来说，使用JDK动态代理需要真实类的被增强方法由接口提供；而cglib代理则是通过继承真实类来实现的，因此不能实现对final类的代理。