Spring AOP的底层实现方式-代理模式

在学习Spring的过程中，留下一下痕迹。

代理模式，其实就是让别人做同样的事情，但是别人却不仅将我的事情做了，还会把他的事情也做了，换言之，这个人做的事情，是他独有的事情和我需要做的事情的综合。回到代码，那么就是，代理类执行与委托类同样的方法，在这方法里代理类不仅可以执行委托类的方法的内容，还可以添加自己的另外的内容，在使用代理类的时候，会比直接使用委托类具有更多的能力，所以我们会直接使用代理类。

通常，代理类虽然具备更多的能力，但是代理类更多的能力其实是比较固定的。

例如，在JDBC里，或在ORM框架里，都会存在事务的开启和提交，如果我们直接将事务代码和业务代码写在一起，其实也是可以的，不过，这样做会使得每一个需要事务的方法，都要添加事务代码，造成代码的分散冗余，那么，针对这种情况，我们希望业务代码可以抽离出来，每一个业务方法都只写业务内容，同时我们又希望，在执行业务方法时，可以有一种方式自动添加业务代码，这种需求，其实就是有了代理的需求，因为我们希望还是使用原来的方法，但是出来的效果希望是多出事务代码，也就是希望业务代码得到增强。可以这样理解了，抽离出来的业务代码，是一个委托类，而可以将委托类自动增强并添加事务代码的代码，是一个代理类，它代理执行委托类，具备了委托类原有的业务能力之余，增加了事务处理的代码。

我理解的代理模式，其实就是将委托类融入到代理类里，换句话说，代理类也就是委托类的扩充而已。

还有不仅是spring 的AOP是代理模式，还有Struts2的 * 实现也是基于 * 的， * 是一种很常见也很重要的设计模式。

说了很多，那么如何实现代理，那我们先说说静态代理。

1.1 静态代理

一个接口，两个实现类，代理实现类组合真实实现类

静态代理，是一种根据上面的理论，很自然会想到的一种不依赖于其他技术的代理模式实现方式。而他的实现过程如下图。

如果使用过静态代理，那么很容易理解，静态代理存在的缺陷。

因此，也就出现了 * 。

* 的动态, 就是可以动态的切换真实实现类, 也就是说可以一个代理类(相同的代码, 相同的增强操作)应对一堆不确定的真实实现类.

1.2 *

JDK * 和CGlib字节码 *

1.2.1 JDK * （必须有接口）

通过java.lang.reflect.Proxy类实现。

* 就是为了解决静态代理不灵活的缺陷而产生的。静态代理是固定的，一旦确定了代码，如果委托类新增一个方法，而这个方法又需要增强，那么就必须在代理类里重写一个带增强的方法。而 * 可以灵活替换代理方法，动态就是体现在这里。

public interface TargetClass {
   void sayHello();
}

public class TargetClassImpl implements TargetClass{
   public void sayHello() {
       System.out.println("你好");
   }
}

public class JdkProxy implements InvocationHandler {
   private TargetClass targetClass;
   public Object createProxy(TargetClass targetClass){
       //传入真实实现类, 本身要做的事情会由他自己做, 代理类会额外进行其他增强操作
       this.targetClass = targetClass;
       //获取本类类加载器
       ClassLoader classLoader = JdkProxy.class.getClassLoader();
       ///获取被代理对象的所有接口
       Class[] clazz = targetClass.getClass().getInterfaces();
       System.out.println(clazz.length);
       //生成代理类并返回
       return Proxy.newProxyInstance(classLoader, clazz, this);
   }
   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
       System.out.println("JDKProxy前置增强");
       Object obj = method.invoke(targetClass,args);
       System.out.println("JDKProxy后置增强");
       return obj;
   }
}

public class Test {
   public static void main(String[] args) {
JdkProxy jdkProxy = new JdkProxy();
TargetClass targetClass = new TargetClassImpl();
TargetClass targetClass1 = (TargetClass) jdkProxy.createProxy(targetClass);
targetClass1.sayHello();
}

1.2.2 CGlib *

（不需要类继承任何接口，字节码技术）

CGlib包在Spring core包里。

public class CGlibTaretClass {
   public void sayHello(){
       System.out.println("我是CGlib,我不需要接口");
   }
}

package CGlibProxyTest;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class CGlibProxy implements MethodInterceptor{
   //代理方法
   public Object createProxy(Object target){
       //创建一个动态类对象
       Enhancer enhancer = new Enhancer();
       //确定要增强的类,设置期父类
       enhancer.setSuperclass(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 obj = methodProxy.invokeSuper(o,objects);
       System.out.println("CGlib后置增强");
       return obj;
   }
}

public class Test {
   public static void main(String[] args) {
CGlibProxy cGlibProxy = new CGlibProxy();
       CGlibTaretClass cGlibTaretClass = new CGlibTaretClass();
       CGlibTaretClass cGlibTaretClass1 = (CGlibTaretClass)cGlibProxy.createProxy(cGlibTaretClass);
       cGlibTaretClass1.sayHello();
  }

最后：代理模式解决的是常见的代码组织问题，它并不神秘，不要被他的名字吓倒。

来源：https://blog.csdn.net/zsbgood/article/details/81160758