【动态代理】JDK 动态代理的使用及原理

最新推荐文章于 2024-01-26 16:51:37 发布
最新推荐文章于 2024-01-26 16:51:37 发布
阅读量477 收藏 2
点赞数 1
分类专栏： 课外趣学 设计模式 文章标签： 代理模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sco5282/article/details/121758534
版权

在说动态代理之前，还是简单地回顾一下静态代理吧。

1. 静态代理

应用场景：

学生交作业给老师。现在想通过静态代理的方式，让班长（代理类）代替学生（被代理类）交作业给老师。

为了让代理类与被代理类有相同的行为，那么，通过会让被代理类去实现一个接口，而且，被代理类也会去实现相同的接口。如下：

静态代理案例

Person：公共接口

public interface Person {
	// 交作业的方法
    void handOut();
}

Student：被代理类

public class Student implements Person {

    @Override
    public void handOut() {
        System.out.println("学生交作业。");
    }
}

不使用静态代理

public class Test {

    public static void main(String[] args) {
        Person student = new Student();
        // 学生交作业。
        student.handOut();
    }

}

如果不使用静态代理，那么运行测试代码后，控制台将直接打印出：学生交作业。

使用静态代理

StudentProxy：代理类

public class StudentProxy implements Person {
	// 目标对象
    private Person person;

    public StudentProxy(Person person) {
        this.person = person;
    }

    @Override
    public void handOut() {
        System.out.println("【代理类】增强原方法");
        person.handOut();
    }

}

说明：

  1. 代理类中持有目标对象，然后通过构造器将目标对象传入；
  2. 重写 handOut() 方法，可增强被代理类的方法的功能。

修改测试类：

public class Test {

    public static void main(String[] args) {
        Person student = new Student();
        Person monitor = new StudentProxy(student);
        // 【代理类】增强原方法
		// 学生交作业。
        monitor.handOut();
    }

}

使用静态代理后，运行测试代码后，控制台将直接打印出：【代理类】增强原方法；学生交作业。

可见，StudentProxy#handOut() 方法确实增强了 Student#handOut() 方法
。

静态代理优、缺点

优点： 静态代理使用起来简单、方便
缺点： 一个代理类只能对一个业务接口的实现类进行包装，如果有多个业务接口的话就要定义很多实现类和代理类才行

2. JDK 动态代理

常用的动态代理有两类：JDK 动态代理、CGLIB 动态代理。这里主要讲下 JDK 动态代理。

2.1 JDK 动态代理介绍

JDK 动态代理是 JRE 提供给我们的类库，可以直接使用，不依赖第三方。

Java 动态代理类位于 java.lang.reflect 包下，一般主要涉及到以下两个类：

1. InvocationHandler：该接口中仅定义了一个方法：

public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
  • proxy：动态代理对象
  • method：被代理的方法
  • args：方法的参数数组

这个抽象方法在代理类中动态实现

2. Proxy：该类即为动态代理类

Proxy#newProxyInstance()：返回代理类的一个实例

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException

动态代理类：它是在运行时生成的一种类，在生成它时，必须提供一组 interfaces 给它，然后该类就会实现这些 interface。动态代理类就是 Proxy，它不会替你干任何事，在生成它的时候，也必须提供一个 handler，由它接管实际的工作。

2.2 JDK 动态代理使用

JDK 动态代理使用步骤

动态代理步骤：

  1. 创建一个实现了接口 InvocationHandler 的类，它必须实现 invoke() 方法
  2. 创建被代理的类和公共接口
  3. 调用 Proxy.newProxyInstance() 方法创建一个代理类
  4. 通过代理对象调用方法

我们使用 JDK 动态代理来实现下上面的应用场景吧。

Person：公共接口

public interface Person {
	// 交作业的方法
    void handOut();
}

Student：被代理类

public class Student implements Person {

    @Override
    public void handOut() {
        System.out.println("学生交作业。");
    }
}

InvocationHandler 实现类

添加一个 InvocationHandler，它不是代理类，因为它并没有实现公共接口 Person，它仅仅是一个包装器 wrapper。包装了 target 对象。

public class PersonHandlerImpl<T> implements InvocationHandler {

    // 被代理对象
    private T target;

    public PersonHandlerImpl(T target) {
        this.target = target;
    }

    /**
     * @param proxy: 动态代理对象
     * @param method: 正在执行的方法
     * @param args: 调用目标方法时传入的实参
     **/
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("【增强方法】代理对象正在执行的方法：" + method.getName());
        Object result = method.invoke(target, args);
        return result;
    }

}

添加一个代理工厂类 ProxyFactory：生产代理对象

public class ProxyFactory {

    public static Object creatProxyObj(Object target) {
        PersonHandlerImpl handler = new PersonHandlerImpl(target);
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), handler);
    }

}

测试类：

public class Test {

    public static void main(String[] args) {
        Person student = new Student();
        Person studentProxy = (Person) ProxyFactory.creatProxyObj(student);
        studentProxy.handOut();
    }

}

Proxy 根据 target 的接口生成了一个实现类，它就是动态代理类 $Proxy0。

生成过程：由于拿到的是接口，那么，我们便可以获知接口的所有的信息（方法的定义），也就能声明一个类去实现这个接口，并重写这个接口中所有的方法。而在这些重写的方法中会调用其它对象的方法。当然，这个被调用的对象不能是 target。因为，如果是 target 对象，那么，我们如何增强其中的方法 handOut()。

所以，它调用的是 target 的包装类，这个类需要我们来实现。但是，JDK 给出了约束，这个包装类要实现 InvocationHandler 接口。上述例子中，就是 PersonHandlerImpl。这个类里面有个方法，它是 target 的所有方法的调用入口 invoke()。在调用它之前，我们可以加自己的代码增强。

所以，可以这么认为：动态代理类 代理了 InvocationHandler，而 InvocationHandler 又代理了我们的 target，两级代理

2.3 JDK 动态代理的原理

通过 Debug 模式，我们可以知道：当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的 handler 对象的 invoke() 方法来进行调用。

即：当调用 studentProxy.handOut() 方法时，

Person studentProxy = (Person) ProxyFactory.creatProxyObj(student);
studentProxy.handOut();

会自动调用 PersonHandlerImpl#invoke() 方法：

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    System.out.println("【增强方法】代理对象正在执行的方法：" + method.getName());
    Object result = method.invoke(target, args);
    return result;
}

这是为什么呢？？？

过程分析：

我们通过 Debug 模式看代码慢慢分析：

首先看看 Proxy#newProxyInstance() 方法：返回一个代理类对象

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
    throws IllegalArgumentException
{
	// 1.校验 InvocationHandler 是否为空
    Objects.requireNonNull(h);

    // 2.根据类加载器和接口来获取动态代理类对应的 Class 类型
    Class<?> cl = getProxyClass0(loader, intfs);

	// 3.通过反射来获取构造器对象并生成动态代理对象
    try { 
        final Constructor<?> cons = cl.getConstructor(constructorParams);
        final InvocationHandler ih = h;
        //...
        return cons.newInstance(new Object[]{h});
    } catch (IllegalAccessException|InstantiationException e) {
        throw new InternalError(e.toString(), e);
    }
    // ...
}

重点看第2步：Proxy#getProxyClass0 方法：

// 代理类缓存
private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
        proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
// ...

private static Class<?> getProxyClass0(ClassLoader loader,
                                       Class<?>... interfaces) {
    // 1.公共接口数量不能超过 2^16 - 1 个
    if (interfaces.length > 65535) {
        throw new IllegalArgumentException("interface limit exceeded");
    }

    // 2.先从缓存中取代理类实例。如果缓存中有，则直接去；否则，需要ProxyClassFactory生成代理类
    return proxyClassCache.get(loader, interfaces);
}

查看 WeakCache#get() 方法：

public V get(K key, P parameter) {
    //...

    while (true) {
        if (supplier != null) {
            V value = supplier.get();
            if (value != null) {
                return value;
            }
        }
    }
    //...
}

虽然，这个 get() 方法有很多逻辑，但是，它最后一定会调用 V value = supplier.get(); 并且，会返回 value。因为，这是一个 while(true) 循环，且只有一个 return 语句。

查看 Factory#get() 方法：

Factory 为 WeakCache 的一个内部类

public synchronized V get() { // serialize access
        //...
        
        V value = null;
        try {
            value = Objects.requireNonNull(valueFactory.apply(key, parameter));
        } finally {
            if (value == null) { // remove us on failure
                valuesMap.remove(subKey, this);
            }
        }
      	//...
      	
        return value;
    }
}

查看 valueFactory.apply(key, parameter) 语句。其中，valueFactory 是一个代理工厂 Proxy$ProxyClassFactory。

Proxy$ProxyClassFactory#apply() 方法：

public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
        //...

        if (proxyPkg == null) {
            proxyPkg = com.sun.proxy + ".";
        }

        // 代理对象的名称
        long num = nextUniqueNumber.getAndIncrement();
        String proxyName = proxyPkg + "$Proxy" + num;

        // 1.生成代理对象字节码
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
            proxyName, interfaces, accessFlags);
        try {
            return defineClass0(loader, proxyName,
                                proxyClassFile, 0, proxyClassFile.length);
        } 
        //...
    }
}

通过这个方法，我们来生成一个字节码文件看看：

public class Test2 {

    public static void main(String[] args) {
        Person student = new Student();
        Person studentProxy = (Person) ProxyFactory.creatProxyObj(student);
        studentProxy.handOut();
        // 生成字节码文件
        createProxyClassFile();
    }

    private static void createProxyClassFile(){
        String name = "ProxyObject";
        byte[] data = ProxyGenerator.generateProxyClass(name, new Class[]{Person.class});
        FileOutputStream out =null;
        try {
            out = new FileOutputStream(name + ".class");
            out.write(data);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(null != out) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

反编译这个 class 文件：

public final class ProxyObject extends Proxy implements Person {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    public ProxyObject(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 void handOut() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    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 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"));
            m3 = Class.forName("com.zzc.proxy.dynamicproxy.Person").getMethod("handOut");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

这就是我们生成的真正的动态代理类：$Proxy0。

它继承了 Proxy 类，并且实现了公共的接口 Person。

语句：Person studentProxy = (Person) ProxyFactory.creatProxyObj(student); 中的
studentProxy 就是它的一个实例。

语句：studentProxy.handOut(); 就是调用动态代理类中的方法：

public final void handOut() throws  {
    try {
        super.h.invoke(this, m3, (Object[])null);
    }
    //...
}

所以，为什么会自动调用 PersonHandlerImpl#invoke() 方法？

因为 JDK 生成了一个动态代理类，它继承 Proxy，并实现了 Person 接口，自然会重写 handOut() 方法。在重新的方法中，又通过反射去调用了 PersonHandlerImpl#invoke() 方法。

sco5282
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java代理之jdk动态代理+应用场景实战
20年码农
04-10 1399
本文将先介绍jdk动态代理的基本用法，并对其原理和注意事项予以说明。之后将以两个最常见的应用场景为例，进行代码实操。这两个应用场景分别是和，它们在许多开发框架中广泛使用。比如在spring和mybatis中均使用了拦截器模式，在mybatis中还利用动态代理来实现声明性接口的功能。因此，掌握动态代理的原理和代码书写方式，对阅读理解这些开源框架非常有益。文中的示例代码基于jdk8编写，且都经过验证，但在将代码迁移到博客的过程中，难免存在遗漏。
Java JDK动态代理实现原理实例解析
08-19
主要介绍了Java JDK动态代理实现原理实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
【拿来吧你】JDK动态代理
黑白法师的博客
03-07 894
从源码角度分析jdk动态代理
java + 动态代理 + 动态代理实际应用场景
04-28
1：静态代理出现的实际背景，静态代理时如何演化成动态代理 2： 动态代理demo 举例实际应用场景（载入数据库驱动的时候，使用AIDL与系统Servic进行通信） 3: 动态代理使用到基础理论：ClassLoader 加载.class字节码文件得到 ， Class对象， Class对象通过 newProxyInstance 得到代理对象 4： 动态代理使用到基础理论：Class.forName("xxxx") 得到Class类 。
【Java基础】细说java动态代理及使用场景
fumeidonga的博客
05-16 2254
Java代理模式是一种结构型设计模式，它允许通过创建一个代理对象来间接访问另一个对象，从而控制对原始对象的访问。
一文搞懂Java动态代理的用法和使用场景
最新发布
oandy0的博客
01-26 614
Java的动态代理，在日常开发中可能并不经常使用，但是并不代表他不重要。Java的动态代理的最主要的用途就是应用在各种框架中。因为使用动态代理可以很方便的运行期生成代理类，通过代理类可以做很多事情，比如AOP，比如过滤器、拦截器等。
jdk动态代理使用详解
congge
06-18 2万+
jdk动态代理和cglib静态代理使用详解
JDK动态代理（AOP）使用及原理分析视频教程课件
12-24
动态代理是使用jdk的反射机制，创建对象的能力， 创建的是代理类的对象。 而不用你创建类文件。不用写java文件。 动态：在程序执行时，调用jdk提供的方法才能创建代理类的对象。jdk动态代理，必须有接口，目标类必须...
Jdk动态代理和cglib动态代理原理
12-19
java静态代理 jdk动态代理 cglib动态代理 代理原理
JDK动态代理的底层实现原理
06-19
JDK动态代理的底层实现原理
面试官：你说你懂动态代理，那你知道为什么JDK中的代理类都要继承Proxy吗？
12-21
之前我已经写过了关于动态代理的两篇文章，本来以为这块应该没啥问题，没想到今天又被难住了… 太难了！！！ 之前文章的链接： 动态代理学习（一）自己动手模拟JDK动态代理、 动态代理学习（二）JDK动态代理源码分析 在动态代理学习（二）JDK动态代理源码分析中我已经讲JDK底层生成的字节码文件反编译成了java代码，如下： public final class proxy extends Proxy implements MyService { private static Method m1; private static Method m4; private stati
Java 动态代理 Demo
10-03
Java Jdk 和 Cglib 动态代理 Demo 1.通过 JDK 反射形式创建动态代理 2.通过CGLIB基于ASM字节码技术创建动态代理 3.Java 反射原理演示 4.CGLib 依赖如下： <groupId>cglib <artifactId>cglib <version>3.3.0 ...
JAVA动态代理
qq_32117059的博客
02-25 1338
java中有两种常见的动态代理方式 JDK原生动态代理和CGLIB动态代理使用以及原理
详解java动态代理机制以及使用场景
小爷欣欣
07-27 1万+
(1)什么是代理？ 大道理上讲代理是一种软件设计模式，目的地希望能做到代码重用。具体上讲，代理这种设计模式是通过不直接访问被代理对象的方式，而访问被代理对象的方法。这个就好比 商户---->明星经纪人(代理)---->明星这种模式。我们可以不通过直接与明星对话的情况下，而通过明星经纪人(代理)与其产生间接对话。 (2)什么情况下使用代理？ (1)设计模式中有一个设计原则是开闭原则...
详解java动态代理机制以及使用场景(一)
热门推荐
远方和诗 的博客
10-19 6万+
说起java动态代理，在我刚开始学java时对这项技术也是十分困惑，明明可以直接调通的对象方法为什么还要使用动态代理？随着学习的不断深入和工作经验的积累，慢慢的体会并理解了java动态代理机制。昨天再给公司新同事做技术培训时有同学就对动态代理产生了疑问，我这里梳理一遍一并记录一下，方便大家查看对自己也是加深记忆。
JDK 动态代理
AdamShyly的博客
05-13 617
代理的应用场景就是当一个实体类不能直接访问目标类中的方法，而此时就需要一个中间代理类帮助该实体类访问该目标类的方法，实现控制访问、功能增强。 在JDK的代理模式中分为静态代理和动态代理两种模式，对于静态代理而言对于每一个中间代理类都需要我们手动创建，其中不乏业务逻辑相同的代码，造成代码冗余；而且每次当代理类实现接口的抽象方法发生变化时，目标类和代理类都需要手动修改源码，不利于代码维护。而动态代理便对该缺陷进行了优化，将代理类对象的创建交由JDK的反射机制处理，重复的业务逻辑代码可以被全部封装到一个实现了I
动态代理是什么？应用场景？怎么实现？
6个日的博客
03-23 644
怎么实现动态代理的应用：Spring的AOP，加事务，加权限，加日志，自定义拦截方法。
Java设计模式之：静态代理和JDK动态代理（案例实战）
02-23
代理模式：是一种设计模式，提供了对目标对象的间接访问方式，即通过代理访问目标对象。如此便于在目标实现的基础上增加额外的功能操作，前拦截，后拦截等，以满足自身的业务需求，同时代理模式便于扩展目标对象功能的特点也为多人所用。代理模式在不修改源代码的情况下使得原本不具有某种行为能力的类对象具有某种行为能力。本课程以自定义连接池为案例详细讲解动态代理，让学生在学完代理后，能灵活运用代理。
JDK动态代理与Cglib动态代理使用详解
共勉
11-26 1772
动态代理你真的会用了吗，Cglib各种重载的方法你用过几种？
cglib和jdk动态代理原理
07-28
C知道：cglib和jdk动态代理都是实现Java动态代理的方式，它们的原理略有不同。 JDK动态代理是通过反射机制来实现的。当我们使用JDK动态代理时，需要定义一个接口，并且创建一个实现了InvocationHandler接口的代理类...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值