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

127 阅读 0 评论 84 点赞

我是靠谱客的博主玩命战斗机，最近开发中收集的这篇文章主要介绍Spring AOP的底层实现方式-代理模式，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

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

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

例如，在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();
   }

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

以上为个人经验，希望能给大家一个参考，也希望大家多多支持靠谱客。