静态代理与JDK动态代理与CGLIB动态代理

时间  2019-11-29
标签 静态 代理 jdk 动态 cglib 栏目 网站开发 繁體版
原文   原文链接

为了理解spring的AOP。 理解JDK动态代理与CGLB动态代理，很是重要。html

讲动态代理必讲静态代理。java

静态代理与动态代理是一种设计思想git

静态代理

静态代理是在编译期将扩展代码织入代理对象github

实现方式spring

1.代理模式：能够理解为硬编码模式。就是代理类里持有被代理对象的引用。 经过调用代理类的实例。达到间接调用被代理对象的目的。ide

public interface UserInterface {
    void doSomething();
}

public class User implements UserInterface {
    @Override
    public void doSomething() {
        System.out.println("I'm doing something");
    }
}
public class UserProxy implements UserInterface {
    private UserInterface userInterface = null; // 持有被代理对象的引用
    @Override
    public void doSomething() {
        beforeDoSomething();
        if(operator == null){
            userInterface =  new User();
        }
        operator.doSomething();
        afterDoSomething();
    }
    private void beforeDoSomething() {
        System.out.println("before doing something");
    }
    private void afterDoSomething() {
        System.out.println("after doing something");
    }
}
复制代码

2.AspectJ编译织入 AspectJ是一种面前切面的技术，经过在编译期把AspectJ内容编译到字节码文件.class （这里不作过多解析推荐文章关于 Spring AOP (AspectJ) 你该知晓的一切）this

静态代理小结：编码

  • 静态代理不产生新的Class
  • 静态代理在编译期织入代理对象
  • 静态代理不灵活。

动态代理：

咱们熟知的动态代理：JDK动态代理和CGLB动态代理 他们都有一个共同点， 在内存中生成了新的字节码，这点很重要。这节咱们从生成的新字节码的角度来看看动态代理的两种方式spa

由于新生成的字节码在内存中，为了看到这些字节码咱们须要其以文件的形式展示出来。咱们在main方法里加下面两行代码就能够把内存的字节码拿出来了.net

//输出JDK动态代理
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
//输出CGLIB动态代理产生的类
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "./cglbproxy");
复制代码

咱们仍是以User类为例看看JDK动态代理生成的字节码文件与CGLB生成的字码文件 详情代码参考springlean项目

1.JDK动态代理：

//------------------------------------接口
interface UserInterface {
    void doSomething();
}
//------------------------------------被代理类
class User implements UserInterface {
    @Override
    public void doSomething() {
        System.out.println("我是实现了接口的User");
    }
}
//------------------------------------代理类(也是拦截器)
class JDKProxy implements InvocationHandler {

    // 要被代理的目标对象
    private UserInterface target;

    public JDKProxy(UserInterface target){
        this.target=target;
    }
    public UserInterface createProxy(){
        return (UserInterface) Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("JDK前置拦截");
        return method.invoke(target,args);
    }
}
//------------------------------------内存生成的新代理类。
final class $Proxy0 extends Proxy implements UserInterface {
    private static Method m3;
  	//省略其余代码
  	.....
    public final void doSomething() throws {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
    static {
        try {
            m3 = Class.forName("cn.wqd.UserInterface").getMethod("doSomething", new Class[0]);
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
    ....
}
//------------------------------------调用。
public static void main(String[] args) {
 		User a=new User();
        //建立JDK代理
        JDKProxy jdkProxy=new JDKProxy(a);
        //建立代理对象
        UserInterface proxy=jdkProxy.createProxy();
        System.out.println(proxy.getClass().getName());
        //执行代理对象方法
        proxy.doSomething();
}
复制代码

System.out.println(proxy.getClass().getName()); 输出的是cn.wqd.$Proxy0。 咱们没有定义过cn.wqd.$Proxy0类，因此 cn.wqd.$Proxy0就是新生成的代理类。

对比咱们User类与$Proxy0类总结下新的代理类的特征

  • 新生成的代理类中定义了与被代理对象相同方法名的方法，如doSomething()方法
  • 新生成的代理类实现了与被代理类相同接口 ：UserInterface
  • 新生成的代理类继承了Proxy
  • 新生成的代理类是final类型

当咱们调用proxy.doSomething()的时候，指的是cn.wqd.$Proxy0.doSomething() ，其内部调用时父类Proxy的.InvocationHandler的invoke()方法,传入的参数(1)代理类对象 ,(2)目标对象的方法。

InvocationHandler属性参数其实就是咱们定义的JDKProxy,其invoke方法最终调用目标对象方法 method.invoke(target,args)。以此达到代理的目的。

小结一下：

  • JDK动态代理经过反射达到代理的目的
  • JDK动态代理会在内存生成一个继承了Proxy，实现了同被代理类实现的接口相同的接口的 代理类。
  • JDK动态代理执行链：代理类方法-->InvocationHandler.invoke()-->目标方法

2.CGLB动态代理：

//====================user
class UserNoInterface{

    public void doSomething() {
        System.out.println("我是没有实现接口的User");
    }
}
//====================拦截器
class CglibProxyIntercepter implements MethodInterceptor {
    @Override
    public Object intercept(Object sub, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("执行前...");
        Object object = methodProxy.invokeSuper(sub, objects);
        System.out.println("执行后...");
        return object;
    }
}

//------------------------------------调用。
public static void main(String[] args) {
 		Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(UserNoInterface.class);
        enhancer.setCallback(new CglibProxyIntercepter());
        UserNoInterface proxyCGLB= (UserNoInterface)  enhancer.create();
        System.out.println(proxyCGLB.getClass().getName());
        proxyCGLB.doSomething();
}
复制代码

CGLB动态代理不要求被代理类实现一个接口，就能够进行代理。 CGLB生成三个新的字码码文件，是否是很诡异。

file

System.out.println(proxyCGLB.getClass().getName()); 打印cn.wqd.UserNoInterface$$EnhancerByCGLIB$$b3361405 看来三个文件中。 cn.wqd.UserNoInterface$$EnhancerByCGLIB$$b3361405才是对应生成的代理类。 咱们分析下代理类代码。（为了便于理解，我只贴出有助于理解的代码具体查看详情代码参考springlean项目）

public class UserNoInterface$$EnhancerByCGLIB$$b3361405 extends UserNoInterface implements Factory {
    private boolean CGLIB$BOUND;
    public static Object CGLIB$FACTORY_DATA;
    private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
    private static final Callback[] CGLIB$STATIC_CALLBACKS;
    private MethodInterceptor CGLIB$CALLBACK_0;
    private static Object CGLIB$CALLBACK_FILTER;
    private static final Method CGLIB$doSomething$0$Method;
    private static final MethodProxy CGLIB$doSomething$0$Proxy;
    private static final Object[] CGLIB$emptyArgs;
    private static final Method CGLIB$equals$1$Method;
    private static final MethodProxy CGLIB$equals$1$Proxy;
    private static final Method CGLIB$toString$2$Method;
    private static final MethodProxy CGLIB$toString$2$Proxy;
    private static final Method CGLIB$hashCode$3$Method;
    private static final MethodProxy CGLIB$hashCode$3$Proxy;
    private static final Method CGLIB$clone$4$Method;
    private static final MethodProxy CGLIB$clone$4$Proxy;

    static void CGLIB$STATICHOOK1() {
        CGLIB$THREAD_CALLBACKS = new ThreadLocal();
        CGLIB$emptyArgs = new Object[0];
        Class var0 = Class.forName("cn.wqd.UserNoInterface$$EnhancerByCGLIB$$b3361405");
        Class var1;
        Method[] var10000 = ReflectUtils.findMethods(new String[]{"equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods());
        CGLIB$equals$1$Method = var10000[0];
        CGLIB$equals$1$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$1");
        CGLIB$toString$2$Method = var10000[1];
        CGLIB$toString$2$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$2");
        CGLIB$hashCode$3$Method = var10000[2];
        CGLIB$hashCode$3$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$3");
        CGLIB$clone$4$Method = var10000[3];
        CGLIB$clone$4$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$4");
        CGLIB$doSomething$0$Method = ReflectUtils.findMethods(new String[]{"doSomething", "()V"}, (var1 = Class.forName("cn.wqd.UserNoInterface")).getDeclaredMethods())[0];
        CGLIB$doSomething$0$Proxy = MethodProxy.create(var1, var0, "()V", "doSomething", "CGLIB$doSomething$0");
    }

    final void CGLIB$doSomething$0() {
        super.doSomething();
    }

    public final void doSomething() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if(this.CGLIB$CALLBACK_0 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if(var10000 != null) {
            var10000.intercept(this, CGLIB$doSomething$0$Method, CGLIB$emptyArgs, CGLIB$doSomething$0$Proxy);
        } else {
            super.doSomething();
        }
    }
	.....
}
复制代码

总结下特征

  • 代理类继承了被代理类，
  • 代理类为每一个目标类的方法都生成了两个方法，以doSomething()为例，一个是重写方法doSomething()，另外一个是CGLIB$doSomething$0()，CGLIB$doSomething$0()方法内部调用的是super.doSomething()也就是目标方法的doSomething()方法
  • 代理类会得到全部在父类继承来的方法，而且会建立一个MethodProxy类型属性与之对应。以doSomething()例子，CGLIB$doSomething$0$Method获取的父类方法，CGLIB$doSomething$0$Proxy与之对应的MethodProxy
CGLIB$doSomething$0$Method = ReflectUtils.findMethods(new String[]{"doSomething", "()V"}, (var1 = Class.forName("cn.wqd.UserNoInterface")).getDeclaredMethods())[0];
CGLIB$doSomething$0$Proxy = MethodProxy.create(var1, var0, "()V", "doSomething", "CGLIB$doSomething$0");
复制代码

由于拿到的proxyCGLB是代理类对象实例，因此proxyCGLB.doSomething()调用的就是

public final void doSomething() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if(this.CGLIB$CALLBACK_0 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if(var10000 != null) {
            var10000.intercept(this, CGLIB$doSomething$0$Method, CGLIB$emptyArgs, CGLIB$doSomething$0$Proxy);
        } else {
            super.doSomething();
        }
    }
复制代码

咱们看看这段逻辑：

首先，检查(MethodInterceptor)CGLIB$CALLBACK_0是否为null，看到MethodInterceptor咱们应该明白了这个地方的CGLIB$CALLBACK_0应该就是上文定义的CglibProxyIntercepter 。

不为null。则执行CglibProxyIntercepter.intercept()方法，入参分别为：

  • this:代理类对象，
  • CGLIB$doSomething$0$Method目标对象方法
  • CGLIB$emptyArgs方法入参
  • CGLIB$doSomething$0$Proxy代理方法。

CglibProxyIntercepter.intercept()方法内部经过调用MethodProxy.invokeSuper(sub, objects)。

咱们看看MethodProxy的内部：

public Object invoke(Object obj, Object[] args) throws Throwable {
        try {
            this.init();
            MethodProxy.FastClassInfo fci = this.fastClassInfo;
            return fci.f1.invoke(fci.i1, obj, args);
        } catch (InvocationTargetException var4) {
            throw var4.getTargetException();
        } catch (IllegalArgumentException var5) {
            if(this.fastClassInfo.i1 < 0) {
                throw new IllegalArgumentException("Protected method: " + this.sig1);
            } else {
                throw var5;
            }
        }
    }
    public Object invokeSuper(Object obj, Object[] args) throws Throwable {
        try {
            this.init();
            MethodProxy.FastClassInfo fci = this.fastClassInfo;
            return fci.f2.invoke(fci.i2, obj, args);
        } catch (InvocationTargetException var4) {
            throw var4.getTargetException();
        }
    }
    ///fastclass
 	private static class FastClassInfo {
        FastClass f1;
        FastClass f2;
        int i1;
        int i2;

        private FastClassInfo() {
        }
    }
复制代码

这里有invoke()与invokeSuper()。为啥上面要调用invokeSuper()不调用invoke()呢？

这里就要涉及到CGLB的FastClass机制。 FastClass.机制：为代理类和被代理类各生成一个Class。这个Class会为代理类或被代理类的方法分配一个index(int类型)索引。经过这个索引能够直接定位到要调用的方法，省去了反射。 具体推荐阅读 参考1 参考2

这里咱们只需知道结果:MethodProxy.FastClassInfo 属性的最终值会是

private static class FastClassInfo {
        FastClass f1;//被代理类UserNoInterface的FastClass
        FastClass f2;//代理类UserNoInterface$$EnhancerByCGLIB$$b3361405的FastClass
        int i1;//被代理类的doSomething()的索引
        int i2;//代理类CGLIB$doSomething$0()（内部调用被代理对象的方法）的索引。
        private FastClassInfo() {
        }
    }
复制代码

三个文件分别为：

  • UserNoInterface$$EnhancerByCGLIB$$b3361405$$FastClassByCGLIB$$fc90c93c《代理类的FastClass》
  • UserNoInterface$$EnhancerByCGLIB$$b3361405《 cglb生成的代理类》
  • UserNoInterface$$FastClassByCGLIB$$29e52466《被代理类的FastClass》

咱们在回头看看invoke()，invokeSuper()方法

  • invoke() 调用的是fci.f1.invoke(fci.i1, obj, args);也就是调用的是被代理类UserNoInterface的FastClass的invoke方法。
  • invokeSuper()调用的是fci.f2.invoke(fci.i2, obj, args);也就是调用的是代理类UserNoInterface$$EnhancerByCGLIB$$b3361405的FastClass的invoke方法.
//=================被代理对象的fastclass的invoke方法
public Object invoke(int var1, Object var2, Object[] var3) throws InvocationTargetException {
        UserNoInterface var10000 = (UserNoInterface)var2;
        int var10001 = var1;

        try {
            switch(var10001) {
            case 0:
                var10000.doSomething();
                return null;
            }
        } catch (Throwable var4) {
            throw new InvocationTargetException(var4);
        }

        throw new IllegalArgumentException("Cannot find matching method/constructor");
    }

//=================代理对象的fastclass的invoke方法
public Object invoke(int var1, Object var2, Object[] var3) throws InvocationTargetException {
        b3361405 var10000 = (b3361405)var2;
        int var10001 = var1;
        try {
            switch(var10001) {
          
            case 7:
                var10000.doSomething();
                return null;
            case 15:
                var10000.CGLIB$doSomething$0();
                return null;
            }
        } catch (Throwable var4) {
            throw new InvocationTargetException(var4);
        }

        throw new IllegalArgumentException("Cannot find matching method/constructor");
    }
		
复制代码

咱们看到若是调用了MethodProxy.invoke() 会调用被代理对象的fastclass的invoke方法，会调用var10000.doSomething()。而var10000其实就是代理对象,这样就出现了死循环。 这也是网上为啥说的不能在此处使用MethodProxy.invoke()的缘由。

看看最终的调用链：

代理对象.doSomething()--->拦截器.intercept()--->MethodProxy.invokeSuper(sub, objects)--->代理类的FastClass类对象的.invoke()--->代理对象的CGLIB$doSomething$0()方法--->目标对象的方法doSomething()

小结：

  • CGLB动态代理能够代理没有实现接口的类
  • CGLB动态代理经过Enhancer 实现代理功能
  • CGLB动态代理生成一个目标对象的子类。

总结：

  • 静态代理从源头解决代理问题
  • 动态代理从运行使用时解决代理问题。
  • JDK动态代理经过InvocationHandler实现拦截。
  • GCLB经过MethodInterceptor实现拦截。

重点：

1.JDK动态是经过反射来实现的。两个要素是Proxy+InvocationHandler

  • Proxy 用于建立代理，而且内存中建立的类也继承Proxy
  • InvocationHandler加强器，实现对目标方法的加强。

2.CGLB动态代理：两要素Enhancer + MethodInterceptor(CallBack)

  • Enhancer建立代理
  • MethodInterceptor 加强器， 实现对目标方法加强。

3.JDK代理与CGLB动态代理都在内存中生成新的字节码，最终仍是落在Class对象上，

要素是手段，字节码才是目的。JVM并不关心你java代码，他关心的是在内存中可被使用的字节码。

欢迎你们关注个人公众号【源码行动】，最新我的理解及时奉送。

在这里插入图片描述
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程