动态代理详解

最新推荐文章于 2023-04-21 14:51:01 发布
最新推荐文章于 2023-04-21 14:51:01 发布
阅读量168 收藏
点赞数
分类专栏： java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22162093/article/details/108851151
版权

jdk动态代理

实例：动态代理有两个对象，目标对象和代理对象。使用JDK动态代理，目标对象必须实现一个接口。

public class JdkDynamicProxyTest {

    interface IPerson {
        void say() ;
    }

    static class Person implements IPerson {
        @Override
        public void say() {
            System.out.println("hello world");
        }
    }

    static class JdkProxy implements InvocationHandler {

        //目标对象
        private Object target;

        //得到代理对象
        public Object getProxy(Object target) {
            this.target = target;
            return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                    target.getClass().getInterfaces(), this);
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("say before");
            method.invoke(target, args);
            System.out.println("say after");
            return null;
        }
    }

    public static void main(String[] args) {
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
        JdkProxy jdkProxy = new JdkProxy();
        IPerson person = (IPerson) jdkProxy.getProxy(new Person());
        person.say();
    }
}

原理
System.getProperties().put(“sun.misc.ProxyGenerator.saveGeneratedFiles”, “true”);会在项目路径下生成一个$Proxy0.class文件，反编译这个文件，就能够明白JDK动态代理原理。

final class $Proxy0 extends Proxy implements IPerson {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void say() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("com.ming.aop.IPerson").getMethod("say");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

代理的大概结构包括4部分：
静态字段：被代理的接口所有方法都有一个对应的静态变量；
静态块：主要是通过反射初始化静态变量；
具体每个代理方法：逻辑都差不多就是 h.invoke，h是Proxy的属性。主要是调用我们定义好的invocatinoHandler逻辑,触发目标对象target上对应的方法;
类结构如下：

public class Proxy implements java.io.Serializable {
    protected InvocationHandler h;
}

构造函数：从这里传入我们InvocationHandler逻辑（如上的JdkProxy ）；构造函数在newProxyInstance方法中通过反射调用

public $Proxy0(InvocationHandler var1) throws  {
    super(var1);
}

protected Proxy(InvocationHandler h) {
    Objects.requireNonNull(h);
    this.h = h;
}

cglib动态代理

cglib使用需要实现MethodInterceptor接口，与JDK动态代理不同的是，cglib不需要目标类实现接口。

public class CglibDynamicProxyTest {

    static class Person {
        public void say() {
            System.out.println("hello world");
        }
    }

    static class CglibProxy implements MethodInterceptor {

        Object target;

        public Object getProxy(Object target) {
            this.target = target;
            final Enhancer enhancer = new Enhancer();
            enhancer.setUseFactory(false);
            enhancer.setSuperclass(target.getClass());
            enhancer.setCallback(this);
            return enhancer.create();
        }

        @Override
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
            System.out.println("say before");
            methodProxy.invokeSuper(o, objects);
            System.out.println("say after");
            return null;
        }
    }

    public static void main(String[] args) {
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "G:\\gitRepository\\demo");
        CglibProxy cglibProxy = new CglibProxy();
        Person person = (Person) cglibProxy.getProxy(new Person());
        person.say();
    }
}

原理
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,“G:\gitRepository\demo”);会在配置的路径下会生成三个字节码文件，其中有两个继承FastClass类的是索引文件，还有一个继承person对象，是我们要研究的。

public class CglibDynamicProxyTest$Person$$EnhancerByCGLIB$$681783b8 extends Person {
    private boolean CGLIB$BOUND;
    private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
    private static final Callback[] CGLIB$STATIC_CALLBACKS;
    private MethodInterceptor CGLIB$CALLBACK_0;
    private static final Method CGLIB$say$0$Method;
    private static final MethodProxy CGLIB$say$0$Proxy;
    private static final Object[] CGLIB$emptyArgs;
    private static final Method CGLIB$finalize$1$Method;
    private static final MethodProxy CGLIB$finalize$1$Proxy;
    private static final Method CGLIB$equals$2$Method;
    private static final MethodProxy CGLIB$equals$2$Proxy;
    private static final Method CGLIB$toString$3$Method;
    private static final MethodProxy CGLIB$toString$3$Proxy;
    private static final Method CGLIB$hashCode$4$Method;
    private static final MethodProxy CGLIB$hashCode$4$Proxy;
    private static final Method CGLIB$clone$5$Method;
    private static final MethodProxy CGLIB$clone$5$Proxy;

    static void CGLIB$STATICHOOK1() {
        CGLIB$THREAD_CALLBACKS = new ThreadLocal();
        CGLIB$emptyArgs = new Object[0];
        Class var0 = Class.forName("com.ming.test.CglibDynamicProxyTest$Person$$EnhancerByCGLIB$$681783b8");
        Class var1;
        CGLIB$say$0$Method = ReflectUtils.findMethods(new String[]{"say", "()V"}, (var1 = Class.forName("com.ming.test.CglibDynamicProxyTest$Person")).getDeclaredMethods())[0];
        CGLIB$say$0$Proxy = MethodProxy.create(var1, var0, "()V", "say", "CGLIB$say$0");
        Method[] var10000 = ReflectUtils.findMethods(new String[]{"finalize", "()V", "equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods());
        CGLIB$finalize$1$Method = var10000[0];
        CGLIB$finalize$1$Proxy = MethodProxy.create(var1, var0, "()V", "finalize", "CGLIB$finalize$1");
        CGLIB$equals$2$Method = var10000[1];
        CGLIB$equals$2$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$2");
        CGLIB$toString$3$Method = var10000[2];
        CGLIB$toString$3$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$3");
        CGLIB$hashCode$4$Method = var10000[3];
        CGLIB$hashCode$4$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$4");
        CGLIB$clone$5$Method = var10000[4];
        CGLIB$clone$5$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$5");
    }

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

    public final void say() {
        //1. 得到MethodInterceptor，我们实现的接口，通过enhancer.setCallback(this)设置的。
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (this.CGLIB$CALLBACK_0 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }
        //2. 调用代理的逻辑
        if (var10000 != null) {
            var10000.intercept(this, CGLIB$say$0$Method, CGLIB$emptyArgs, CGLIB$say$0$Proxy);
        } else {
            super.say();
        }
    }
    //..省略一些方法
    private static final void CGLIB$BIND_CALLBACKS(Object var0) {
        CglibDynamicProxyTest$Person$$EnhancerByCGLIB$$681783b8 var1 = (CglibDynamicProxyTest$Person$$EnhancerByCGLIB$$681783b8)var0;
        if (!var1.CGLIB$BOUND) {
            var1.CGLIB$BOUND = true;
            Object var10000 = CGLIB$THREAD_CALLBACKS.get();
            if (var10000 == null) {
                var10000 = CGLIB$STATIC_CALLBACKS;
                if (CGLIB$STATIC_CALLBACKS == null) {
                    return;
                }
            }

            var1.CGLIB$CALLBACK_0 = (MethodInterceptor)((Callback[])var10000)[0];
        }

    }

    static {
        CGLIB$STATICHOOK1();
    }
}

代理类继承了目标类，并重写目标类方法。代理的大概结构包括三大块：

静态字段:目标类中所有方法(包括父类中的方法，Object除外)以及Object中finalize、equals、toString、hashCode、clone方法,都对应一个Method和MethodProxy静态变量。
静态代码块:静态代码块中调用CGLIB$STATICHOOK1()静态方法，这个方法主要是通过反射初始化Method静态变量，并初始化MethodProxy静态变量。Method表示目标类的方法,MethodProxy表示代理类中方法。
目标类中的方法：代理类中有两个方法，一个是重写目标类方法，重写的逻辑也比较简单，得到MethodInterceptor对象，然后调用intercept方法，intercept方法是我们实现的方法。还有一个CGLIBsay0方法，这个是给MethodProxy调用，实现逻辑直接调用目标类方法，在调用methodProxy.invokeSuper(o,
objects)时会调用这个方法。

注意如下的代码会发生了死循环。

@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
    System.out.println("say before");
    method.invoke(o, objects);
    System.out.println("say after");
    return null;
}

我们从反编译的代码中var10000.intercept(this, CGLIB$say 0 0 0Method, CGLIB e m p t y A r g s , C G L I B emptyArgs, CGLIB emptyArgs,CGLIBsay 0 0 0Proxy)中可以看出，o表示的是代理类，method表示的是目标类中方法，但是因为代理类重写了目标类中方法，所以还是调用代理类中的方法。代理的方法又会调用intercept，就形成了死循环。

jdk动态代理类与cglib代理区别

jdk动态代理目标类必须实现一个接口，而cglib不需要。是因为jdk代理会继承Proxy类，而java又是单继承。
jdk代理类与目标类实现相同的接口，cglib代理直接继承目标类。
jdk和cglib都是把实现逻辑代理给接口。jdk代理给InvocationHandler接口，cglib代理给MethodInterceptor接口。
cglib一个目标类方法会生成两个代理方法，一个重写目标方法，并实现代理逻辑，还有一个直接调用目标类方法。

寻烟的衣袖
关注
专栏目录
cglib简单使用与理解
tkk13的博客
07-04 1769
cglib是动态代理的实现包 与jdk动态代理的差异在于前者被代理的类，不需要实现任何接口，该包动态生成被代理类的子类并代理其中的所有方法（某些特殊情况除外，具体参考cglib详细使用的文章） public static void main(String[] args) { //生成cglib增强器,相当于工厂类 Enhancer enhancer = new Enhancer(); //传入被代理的类 enhancer.setSuperclass(TargetClass.class
Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理）
06-21
Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理） Java 动态代理是 Java 编程语言中的一种强大工具，广泛应用于 Spring AOP、Hibernate 数据查询、测试框架的后端 mock、RPC 远程调用、Java 注解...
Cglib及其基本使用
weixin_33835690的博客
04-03 653
前言 最近一直在看Spring源码，其实我之前一直知道AOP的基本实现原理： 如果针对接口做代理默认使用的是JDK自带的Proxy+InvocationHandler 如果针对类做代理使用的是Cglib 即使针对接口做代理，也可以将代理方式配置成走Cglib的 之后要看AOP源码了，Proxy+InvocationHandler这套我已经很熟了，想着如果把Cglib研究研究，应该...
cglib的简单使用
what are you living for ?
03-24 3260
一、前言 最近在看Spring的源码，其中有牵扯到cglib的相关内容，遂简单记录下cglib是如何使用的 二、原理（节选自网络） CGLIB原理：动态生成一个要代理类的子类，子类重写要代理的类的所有不是final的方法。在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。它比使用java反射的JDK动态代理要快。 CGLIB底层：使用字节码处理框架ASM，来转换字节码并生成新的类...
cglib用法
dianliangpi8063的博客
08-28 235
CGLib动态代理的介绍及用法（单回调、多回调、不处理、固定值、懒加载） 参照： https://blog.csdn.net/difffate/article/details/70552056 前面介绍了代理模式，讲了动态代理常见的实现方式，包含了JDK的动态代理和CGLib的动态代理。本文将介绍下CGLib动态代理及几种用法。CGLib（Code Generation Librar...
cGlib使用
qq_39638957的博客
10-02 350
深入理解Java虚拟机，第二章第58页用到了cGlib。 下载cGLib jar包，http://www.java2s.com/Code/Jar/c/Downloadcglib222jar.htm 下载asm jar包，http://www.java2s.com/Code/Jar/o/Downloadorgobjectwebasm310v200803061910jar.htm 注意，上...
Java 动态代理详解（学习资料）
06-17
CGLIB 动态代理JDK 动态代理要求目标类必须实现接口，但在某些情况下，我们可能需要为没有接口的类创建代理，这时可以使用 CGLIB。CGLIB（Code Generation Library）是一个强大的高性能的代码生成库，它可以在运行期...
Java动态代理详解； CGLib实现动态代理1
08-08
Java 动态代理详解与 CGLib 实现 在 Java 中，代理模式是一种设计模式，它允许我们在不修改原有对象的基础上，为对象增加额外的功能。代理模式的核心在于代理类（Proxy）作为真实对象（RealSubject）的替代品，提供...
java静态代理和动态代理详解
最新发布
10-16
在Java中，代理主要分为静态代理和动态代理。 1. 静态代理： 静态代理是在编译时就已经明确代理类与被代理类关系的一种方式。为了实现静态代理，我们需要手动创建一个代理类，这个代理类通常会实现与被代理类相同的...
Java设计模式：静态代理、装饰者、动态代理详解
12-21
Java提供了两种动态代理机制：JDK动态代理和CGLIB动态代理。 1. JDK动态代理基于接口，通过java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口实现。代理类在运行时由Proxy类动态生成，代理类...
cglib使用的jar包
12-04
测试基于cglib动态代理测试使用的jar包. asm-7.0-beta.jar asm-commons-7.0-beta.jar asm-util-7.0-beta.jar cglib-3.1.jar
cglib 使用
qq_35356190的博客
07-07 354
1.目标类 public class CglibDao { public CglibDao() { select(); } public void update() { System.out.println("CglibDao.update()"); } public void select() { System.out.println("CglibDao.select()"); } } ...
(转贴)cglib的应用
netfishx's matrix
12-12 115
反射、Proxy和元数据是Java最强的三个特征，再加上CGLib (Code Generation Library)和ASM，使得Java虽然没有Ruby，Python般后生可畏，一样能做出强悍的框架。   Proxy可以看作是微型的AOP，明白提供了在继承和委托之外的第三个代码封装途径，只要有足够的想象力，可以做得非常好玩，Spring的源码里用Proxy就用得很随便，看得我非常眼红。可惜Pr...
学习笔记 Cglib的使用
weixin_52572040的博客
08-15 232
实现 对已有类的方法的拓展 而不改变类方法的源代码
Cglib入门到使用
weixin_46203834的博客
04-21 894
Cglib是一个强大的Java代码生成库，用于创建动态代理和增强对象。本文介绍了Cglib的基础知识、核心原理和使用方法，以及一些高级用法，如字段拦截、构造函数拦截和BeanGenerator等。Cglib提供了比Java自带的动态代理更好的性能和灵活性，可以满足各种代理需求，是Java开发人员不可或缺的工具之一。
Spring框架复习10-AOP（番外）cglib动态代理
05-08 112
第一步：编写原始类（这里不需要实现接口，cglib的原理是通过继承实现的） public class GoodDao { public void save(){ System.out.println("保存商品"); } } 第二步：编写动态代理类 public class CglibProxy { public GoodDao createP...
CGlib
wsfengye的博客
02-05 132
温故了一个cglib和asm，找到几篇写得比较好，介绍得比较清楚的文章：    1、CGlib简单介绍，访问地址：http://www.blogjava.net/stone2083/archive/2008/03/16/186615.html，从简单的示例到不同业务场景的变化，一步步让读者明白，为什么要使用cglib以及哪种场景下需要使用cglib；    2、cglib源码学习交流，访问地址：h...
CGLIB 普通用法
weixin_33841503的博客
04-30 102
定义拦截回调， 实现MethodInterceptor接口 package proxy; import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy; import java.lang.reflect.Method; /** * @author Mr Morning * @dat...
JAVA反射机制与动态代理详解
"JAVA的反射机制与动态代理" 在Java编程中，反射机制和动态代理是两种强大的工具，它们允许程序在运行时检查类、接口、字段和方法的信息，并能够动态地创建和调用对象。这使得代码具有高度的灵活性和可扩展性。 **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值