我对Java动态代理的理解

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了我对Java动态代理的理解，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含15217字，纯文字阅读大概需要22分钟。

内容图文

虽然面向应用开发的程序员很少直接使用动态代理技术，但是诸如AOP，事务控制，Spring容器注入等等，实际上都是基于动态代理实现的，可见，动态代理是多么重要。这篇随笔记录了我对动态代理技术原理的一两点理解。

1. 什么是代理

1.1 什么是代理

       下图所示为一般地代理模式类图，实际上，代理proxy代替具体对象向客户暴露接口，让客户直接通过代理对象调用真实对象的方法。形象地来说，比如买飞机票的时候，你不必非得去机场售票处买票，可以在市区酒店乃至街道上各个代理售票点购买机票，而代售点，就是机场售票中心的代理。乘客调用代售点的“售卖机票”的功能，由于代售点和机场票务中心是联网的，所以你获得了机场官方承认的有效机票。

图1.1 代理模式类图

1.2 静态代理与动态代理的区别

        上面用了现实生活中的例子解释了一下代理的基本意义，那么在程序中，有静态代理和动态代理之分，他们的区别是什么？首先，我们用最简单的静态代理的例子来说明什么是静态代理。代码如下。

 1 import java.util.Random;
 2 
 3 public class StaticProxyDemo {
 4     public static void main(String[] args) {
 5         TicketStation ticketStation = new ProxyTicketStation(new OfficalTicketStation());
 6         ticketStation.buyTicket();
 7     }
 8 
 9 }
10 
11 /**
12  * 机票对象，每张机票有一个id编号
13  */
14 class Ticket {
15     private final int id;
16     public Ticket(int id) {
17         this.id = id;
18     }
19 
20     public String toString() {
21         return "Ticket:" + id;
22     }
23 }
24 
25 
26 /**
27  * 机票销售接口
28  */
29 interface TicketStation {
30     Ticket buyTicket();
31 }
32 
33 
34 /**
35  * 机场官方售票大厅, 实现机场销售接口
36  */
37 class OfficalTicketStation implements TicketStation {
38     private static Random rand = new Random(47);
39 
40     public Ticket buyTicket() {
41         return new Ticket(rand.nextInt(100));
42     }
43 }
44 
45 
46 /**
47  * 代理售票点，持有一个官方售票大厅的引用
48  * 表示两者之间是联网的
49  */
50 class ProxyTicketStation implements TicketStation {
51 
52     private final TicketStation ticketStation;
53     public ProxyTicketStation(TicketStation station) {
54         ticketStation = station;
55     }
56 
57     /**
58      * 代理售票点实际调用官方售票大厅的方法获得机票
59      */
60     public Ticket buyTicket() {
61         System.out.println("连接机场票务中心....");
62         Ticket ticket = ticketStation.buyTicket();
63         if (ticket != null) {
64             System.out.println("您购买的机票编号为: " + ticket);
65         }
66         return ticket;
67     }
68 }

        我们直接从main方法中看到创建代理对象的过程：

       TicketStation ticketStation = new ProxyTicketStation(new OfficalTicketStation());

1) 创建真实对象：new OfficalTicketStation()

2) 创建代理对象，将真实对象作为构造函数传入

以上两部就是创建静态代理对象的一般步骤，很简单，也很容易理解。之所以能够这样new出一个代理对象，是因为ProxyTicketStation的字节码文件在编译期就已经编译好了，于是，第一次访问该类的静态成员时（构造器也是静态成员），JVM的类加载器就将ProxyTicketStation.class文件加载之后生成了Class对象存入堆内存中，这样就可以通过该类的Class对象创建具体实例了。这里之所以叫静态代理，原因就是ProxyTicketStation.class这个字节码文件，是编译器读取你的源码(ProxyTicketStation.java)生成的并且存放在了磁盘上，你的程序跑起来之后，她只是安静地等待运行过程中需要时被加载。

        那么相对的，动态代理就是程序运行时， 由特定程序而不是编译器，动态地写出来的类的字节码（或者通过远程传入的），然后加载实例产生的代理对象。通过Javassist等开源框架，程序员们可以方便的在程序中生成字节码，当然，Java底层天然就可以写，只不过相对复杂，而动态代理对象的字节码是Java底层写的。

2. 动态代理的实现原理 

        这里涉及到的JVM虚拟机运行的原理，我就通过这张图简要地说明一下。注意，这里省略了验证、解释等过程。

 图2.1 Java编译加载字节码文件

 上节说过，动态代理中，代理对象的字节码文件，是通过Java底层代码写的，那么具体是怎么写的呢？首先，就需要了解一下动态代理使用的三个步骤。

2.1 动态代理实现三个步骤

        第一步: 实现InvocationHandler接口

        第二步：创建动态代理对象

        第三步：通过代理对象调用方法

        简单地代码实现如下：

        实现InvocationHandler，该类的作用是，对于稍后动态代理类的所有方法的调用，都会重定向到InvocationHandler的invoke方法。在invoke方法中，可以统一处理非业务逻辑，比如记录对象调用的日志等。就是说，把非业务逻辑和业务逻辑分离了。而且自己实现的InvocationHandler可以复用，供不同proxy对象重定向调用invoke，就减少了需要写的类，是整体代码更加紧凑，易于维护。相反，静态代理类如果数量过多，就会使整体代码显得臃肿和零散，难以维护。

 1 import java.lang.reflect.InvocationHandler;
 2 import java.lang.reflect.Method;
 3 import java.util.stream.Stream;
 4 
 5 public class MyInvocationHandler implements InvocationHandler {
 6     private Object proxied;
 7 
 8     public MyInvocationHandler(Object proxied) {
 9         this.proxied = proxied;
10     }
11 
12 
13     public Object invoke(Object proxy, Method method, Object[] args) {
14         System.out.println("Invoke method: " + method.getName() + ", args: " + args);
15         if (args != null)
16             Stream.of(args).forEach(System.out::println);
17         try {
18             if (method.getName().equals("buyTicket")) {
19                 System.out.println("Buy ticket....");
20                 Ticket result = (Ticket) method.invoke(proxied, args);
21                 System.out.println(result);
22             }
23         } catch (Throwable t) {
24             System.err.println(t);
25         }
26 
27         return null;
28     }
29 }

        创建代理对象以及调用代理对象方法。创建代理对象proxy时，需要传入三个参数。第一个参数是类加载器，类加载器用于加载代理类字节码文件，一般地，使用当前环境的类加载器即可，如果字节码来自网络或者磁盘，就需要自己实现类加载器了，为什么？因为默认的三个类加载器（启动类加载器，扩展类加载器和系统类加载器）只能加载位于特定目录和classpath下的字节码文件.class。第二个参数是动态创建的代理类，需要实现哪些接口，这里仅需要使用TicketStation接口即可。第三个参数是InvocationHandler对象，这里传入我们实现的handler，这是最重要的参数，因为Java底层在生成代理类的时候，在其每个方法调用中，都会将调用重定向到handler的invoke方法。

 1 import java.lang.reflect.Proxy;
 2 
 3 public class DynamicTicketProxyDemo {
 4     public static void main(String[] args) {
 5         // 创建代理对象
 6         TicketStation official = new OfficalTicketStation();
 7         TicketStation proxy = (TicketStation) Proxy.newProxyInstance(
 8                 TicketStation.class.getClassLoader(),      // 类加载器
 9                 new Class[]{TicketStation.class},          // 代理类需要实现的接口
10                 new MyInvocationHandler(official));        // InvocationHandler，对代理所有方法的调用都会重定向到该类invoke方法
11 
12         // 调用代理对象方法
13         proxy.buyTicket();
14     }
15 }

2.2 代理对象是怎样创建的

        通过2.1节，我们已经知道了怎样在代码中写动态代理，毫无疑问，最重要的一步是 Proxy.newProxyInstance()方法的调用，理解了这个方法的实现，也就能对动态代理有更深入的理解，那么本节就从源码来了解一下Java动态代理的实现。

 1 public static Object newProxyInstance(ClassLoader loader,
 2                                           Class<?>[] interfaces,
 3                                           InvocationHandler h)
 4         throws IllegalArgumentException
 5     {
 6         Objects.requireNonNull(h);          // invocationHandler必须传
 7 
 8         final Class<?>[] intfs = interfaces.clone();
 9         final SecurityManager sm = System.getSecurityManager();
10         if (sm != null) {
11             checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
12         }
13 
14         /*
15          * Look up or generate the designated proxy class.
16          */
17         Class<?> cl = getProxyClass0(loader, intfs);      // 1.核心方法，获取动态代理的类对象
18 
19         /*
20          * Invoke its constructor with the designated invocation handler.
21          */
22         try {
23             if (sm != null) {
24                 checkNewProxyPermission(Reflection.getCallerClass(), cl);
25             }
26 
27             final Constructor<?> cons = cl.getConstructor(constructorParams);    // 2.获取带参数的构造器
28             final InvocationHandler ih = h;
29             if (!Modifier.isPublic(cl.getModifiers())) {
30                 AccessController.doPrivileged(new PrivilegedAction<Void>() {
31                     public Void run() {
32                         cons.setAccessible(true);
33                         return null;
34                     }
35                 });
36             }
37             return cons.newInstance(new Object[]{h});     // 2.创建代理对象并返回
38         } catch (IllegalAccessException|InstantiationException e) {
39             throw new InternalError(e.toString(), e);
40         } catch (InvocationTargetException e) {
41             Throwable t = e.getCause();
42             if (t instanceof RuntimeException) {
43                 throw (RuntimeException) t;
44             } else {
45                 throw new InternalError(t.toString(), t);
46             }
47         } catch (NoSuchMethodException e) {
48             throw new InternalError(e.toString(), e);
49         }
50     }

上述方法做的事情就是：1.必要校验； 2. 创建代理对象的Class对象； 3. 调用Constructor.newInstance来创建代理对象。

        最重要的一步就是Class<?> cl = getProxyClass0(loader, intfs)，该方法源代码如下： 1 private static Class<?> getProxyClass0(ClassLoader loader,

 1 private static Class<?> getProxyClass0(ClassLoader loader,
 2                                            Class<?>... interfaces) {
 3         if (interfaces.length > 65535) {
 4             throw new IllegalArgumentException("interface limit exceeded");
 5         }
 6 
 7         // 尝试从缓存中获取代理对象的类对象，如果没有， 
 8         // 就调用ProxyClassFactory工厂方法去创建代理对象的Class对象
 9         return proxyClassCache.get(loader, interfaces);
10     }

getProxyClass0()方法中，proxyClassCache缓存在Proxy类加载时就初始化了，作为Proxy类的常量定义：

1 public class Proxy implements java.io.Serializable {
2     private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
3         proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
4 
5 }

可以看到，proxyClassCache是一个WeakCache缓存对象， 实例化时就传入了ProxyClassFactory代理对象类工厂实例，这样的话，当调用proxyClassCache.get(loader, interfaces)，如果缓存中不存在满足当前interfaces的类对象，就会调用ProxyClassFactory工厂来创建代理对象的类对象，ProxyClassFactory嵌入在Proxy的类，它实现了参数化函数接口BiFunction<ClassLoader, Class<?>[], Class<?>>，即通过传入两个参数-----这里是loader和interfaces-----来获得代理类的Class对象，源代码如下，这里省略了部分代码，值保留最核心的部分：

 1 private static final class ProxyClassFactory
 2         implements BiFunction<ClassLoader, Class<?>[], Class<?>>
 3     {
 4         // 代理对象的名称前缀
 5         private static final String proxyClassNamePrefix = "$Proxy";  
 6 
 7         // 原子操作，每创建一个代理对象，就会在前缀后加上一个数字以区分
 8         private static final AtomicLong nextUniqueNumber = new AtomicLong();
 9 
10         @Override
11         public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
12 
13             String proxyPkg = null;     // 要创建代理类的包
14             int accessFlags = Modifier.PUBLIC | Modifier.FINAL;    //这里都是public final的
15             // 这里是组装代理类完整的包名
16             for (Class<?> intf : interfaces) {
17                 int flags = intf.getModifiers();
18                 if (!Modifier.isPublic(flags)) {
19                     accessFlags = Modifier.FINAL;
20                     String name = intf.getName();
21                     int n = name.lastIndexOf('.');
22                     String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
23                     if (proxyPkg == null) {
24                         proxyPkg = pkg;
25                     } else if (!pkg.equals(proxyPkg)) {
26                         throw new IllegalArgumentException(
27                             "non-public interfaces from different packages");
28                     }
29                 }
30             }
31 
32             if (proxyPkg == null) {
33                 proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
34             }
35 
36             /*
37              * 组装出代理类的完整限定名
38              */
39             long num = nextUniqueNumber.getAndIncrement();
40             String proxyName = proxyPkg + proxyClassNamePrefix + num;  
41 
42             /*
43              * 最终要的代码，生成代理类的字节码
44              */
45             byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
46                 proxyName, interfaces, accessFlags);
47             try {
48                 return defineClass0(loader, proxyName,
49                                     proxyClassFile, 0, proxyClassFile.length);
50             } catch (ClassFormatError e) {
51                 /*
52                  * A ClassFormatError here means that (barring bugs in the
53                  * proxy class generation code) there was some other
54                  * invalid aspect of the arguments supplied to the proxy
55                  * class creation (such as virtual machine limitations
56                  * exceeded).
57                  */
58                 throw new IllegalArgumentException(e.toString());
59             }
60         }
61     }

上述代码中，最重要的一步就是byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags); 这一步是调用ProxyGenerator来生成代理类字节码文件，如同Javaassist框架可以方便地生成类字节码一样，ProxyGenerator封装了底层代码来生成代理类字节码。回忆一下JVM加载过程，通常情况下，JVM类记载器运行时加载的是编译期生成并保存在磁盘特定路径中的.class文件，既然编译器能生成.class字节码文件，Java当然能够支持程序员自己写程序在程序运行时生成.class字节码文件喽，这里ProxyGenerator.generateProxyClass就是Java实现的这样一种过程，只不过封装了复杂的底层逻辑。我们姑且只需要知道ProxyGenerator.generateProxyClass生成了代理类的.class文件即可。

        既然生成了.class字节码文件，那么接下来呢？自然是加载并初始化这个类，这一过程就是调用类加载器将.class文件读入Java虚拟机内存中， 经过一系列的验证，内存分配，解析之后，初始化该类，即执行静态代码块或者初始化静态成员。这一过程，就是Proxy类中这个方法执行的：

private static native Class<?> defineClass0(ClassLoader loader, String name, byte[] b, int off, int len);

我们看到这个方法时native的，表示加载验证初始化代理类的过程是更底层的实现，这里就不必继续深究下去了。总之，该方法会返回给我们一个代理类的Class对象。跳转到Proxy.newProxyInstance方法源码中去，接下来就是获取构造器对象，然后通过构造器的newInstance方法，生成代理对象实例，最终返回给我们。值得注意的是，这里获取的构造器 final Constructor<?> cons = cl.getConstructor(constructorParams)是带参数constructorParams的构造器，该包括该构造器代理类是由 ProxyGenerator.generateProxyClass()方法写的，constructorParams参数在Proxy类中有定义：

1 public class Proxy implements java.io.Serializable {
2 
3     /** parameter types of a proxy class constructor */
4     private static final Class<?>[] constructorParams =
5         { InvocationHandler.class };
6 }

即，代理对象的构造器参数是需要传入InvocationHandler实例，这也是为什么Proxy.newProxyInstance()方法必须传入InvocationHandler对象的原因，最后调用return cons.newInstance(new Object[]{h});方法，其中h就是我们传入的InvocationHandler对象， 通过这个构造器传入的InvocationHandler对象，生成的代理对象，被调用任何方法时，都会重定向到InvocatoinHandler.invoke()方法上去，这都是底层写的字节码来实现的。

        还有一点，就是在生成代理类的字节码时候，所有方法都是public final修饰的，即生成的代理类是不能重写。

内容总结

以上是互联网集市为您收集整理的我对Java动态代理的理解全部内容，希望文章能够帮你解决我对Java动态代理的理解所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端