动态代理系列(一)JDK动态代理-超详细源码分析

分手后的思念是犯贱 2022-05-14 12:12 284阅读 0赞

本文转载自JDK动态代理-超详细源码分析

##一、为什么需要动态代理

###1.1 从代理模式说起

代理模式是指给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。这种模式有什么用呢？它可以在原对象的基础上增强原对象的功能，比如在原对象调用一个方法的前后进行日志、事务操作等。Spring AOP就使用了代理模式。

###1.2 代理模式——静态代理

如何实现代理模式呢？首先来看静态代理。静态代理是指在程序运行前就已经存在的编译好的代理类是为静态代理。实现静态代理有四个步骤：

  • ①定义业务接口；
  • ②被代理类实现业务接口；
  • ③定义代理类并实现业务接口；
  • ④最后便可通过客户端进行调用。（这里可以理解成程序的main方法里的内容）

我们按照这个步骤去实现静态代理。需求：在向数据库添加一个用户时前后打印日志。

####1.2.1业务接口

IUserService.java

  1. public interface IUserService {
  2.     void add(String name);  
  3. }

####1.2.2被代理类实现业务接口

UserServiceImpl.java

  1. public class UserServiceImpl implements IUserService{
  3.     @Override
  4.     public void add(String name) {
  5.         System.out.println("向数据库中插入名为：  "+name+" 的用户");
  6.     }
  8. }

####1.2.3定义代理类并实现业务接口

因为代理对象和被代理对象需要实现相同的接口。所以代理类源文件UserServiceProxy.java这么写：

  1. public class UserServiceProxy implements IUserService {
  2.     // 被代理对象
  3.     private IUserService target;
  5.     // 通过构造方法传入被代理对象
  6.     public UserServiceProxy(IUserService target) {
  7.         this.target = target;
  8.     }
  10.     @Override
  11.     public void add(String name) {
  12.         System.out.println("准备向数据库中插入数据");
  13.         target.add(name);
  14.         System.out.println("插入数据库成功");
  16.     }
  17. }

由于代理类(UserServiceProxy )和被代理类(UserServiceImpl )都实现了IUserService接口，所以都有add方法，在代理类的add方法中调用了被代理类的add方法，并在其前后各打印一条日志。

####1.2.4客户端调用

  1. public class StaticProxyTest {
  3.     public static void main(String[] args) {
  4.         IUserService target = new UserServiceImpl();
  5.         UserServiceProxy proxy = new UserServiceProxy(target);
  6.         proxy.add("陈粒");
  7.     }
  8. }

以上为静态代理的实现。

###1.3 代理模式——动态代理

既然有了静态代理，为什么会出现动态代理呢？那我们就说一下静态代理的一些缺点吧：

①代理类和被代理类实现了相同的接口，导致代码的重复，如果接口增加一个方法，那么除了被代理类需要实现这个方法外，代理类也要实现这个方法，增加了代码维护的难度。

②代理对象只服务于一种类型的对象，如果要服务多类型的对象。势必要为每一种对象都进行代理，静态代理在程序规模稍大时就无法胜任了。比如上面的例子，只是对用户的业务功能（IUserService）进行代理，如果是商品（IItemService）的业务功能那就无法代理，需要去编写商品服务的代理类。

于是乎，动态代理的出现就能帮助我们解决静态代理的不足。所谓动态代理是指：在程序运行期间根据需要动态创建代理类及其实例来完成具体的功能。动态代理主要分为JDK动态代理和cglib动态代理两大类，本文主要对JDK动态代理进行探讨。

##二、JDK动态代理实例

###2.1 使用JDK动态代理步骤

  • ①创建被代理的接口和类；
  • ②创建InvocationHandler接口的实现类，在invoke方法中实现代理逻辑；
  • ③通过Proxy的静态方法newProxyInstance( ClassLoaderloader, Class[] interfaces, InvocationHandler h)创建一个代理对象
  • ④使用代理对象。

###2.2 Demo

还是我们刚才的需求，这次换用动态代理实现：

####2.2.1 创建被代理的接口和类

这个和静态代理的源码相同，还是使用上面的IUserService.java和UserServiceImpl.java

####2.2.2 创建InvocationHandler接口的实现类

InvocationHandler的作用

在动态代理中InvocationHandler是核心，每个代理实例都具有一个关联的调用处理程序InvocationHandler。对代理实例调用方法时，将对方法调用进行编码并将其指派到它的调用处理程序InvocationHandler的 invoke 方法。所以对代理方法的调用都是通InvocationHadler的invoke来实现中，而invoke方法根据传入的代理对象，方法和参数来决定调用代理的哪个方法。
invoke方法签名：invoke（Object Proxy，Method method，Object[] args）

  1. public class MyInvocationHandler implements InvocationHandler {
  2.     //被代理对象，Object类型
  3.     private Object target;
  5.     public MyInvocationHandler(Object target) {
  6.         this.target = target;
  7.     }
  9.     @Override
  10.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  12.         System.out.println("准备向数据库中插入数据");
  13.         Object returnvalue = method.invoke(target, args);
  14.         System.out.println("插入数据库成功");
  16.         return returnvalue;
  17.     }
  19. }

####2.2.3 通过Proxy的静态方法创建代理对象并使用代理对象

代码中有注释：

public class DynamicProxyTest {

  1. public static void main(String[] args) {
  3.     IUserService target = new UserServiceImpl();
  4.     MyInvocationHandler handler = new MyInvocationHandler(target);
  5.     //第一个参数是指定代理类的类加载器（我们传入当前测试类的类加载器）
  6.     //第二个参数是代理类需要实现的接口（我们传入被代理类实现的接口，这样生成的代理类和被代理类就实现了相同的接口）
  7.     //第三个参数是invocation handler，用来处理方法的调用。这里传入我们自己实现的handler
  8.     IUserService proxyObject = (IUserService) Proxy.newProxyInstance(DynamicProxyTest.class.getClassLoader(),
  9.             target.getClass().getInterfaces(), handler);
  10.     proxyObject.add("陈粒");
  11. }

}

运行结果和静态代理一样，说明成功了。但是，我们注意到，我们并没有像静态代理那样去自己定义一个代理类，并实例化代理对象。实际上，动态代理的代理对象是在内存中的，是JDK根据我们传入的参数生成好的。那动态代理的代理类和代理对象是怎么产生的呢？重头戏来了，且往下看。

##三、动态代理源码深入分析

这部分如果想要更快更好的理解，建议一边对着源码(本文JDK 1.8)，一边看着博客。毕竟自己亲身实践效果才好嘛。

Proxy.newProxyInstance( ClassLoaderloader, Class[] interfaces, InvocationHandler h)产生了代理对象，所以我们进到newProxyInstance的实现：

  1. public static Object newProxyInstance(ClassLoader loader,
  2.                                           Class<?>[] interfaces,
  3.                                           InvocationHandler h)
  4.         throws IllegalArgumentException
  5.     {
  6.         //检验h不为空，h为空抛异常
  7.         Objects.requireNonNull(h);
  8.         //接口的类对象拷贝一份
  9.         final Class<?>[] intfs = interfaces.clone();
  10.         //进行一些安全性检查
  11.         final SecurityManager sm = System.getSecurityManager();
  12.         if (sm != null) {
  13.             checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
  14.         }
  16.         /*
  17.          * Look up or generate the designated proxy class.
  18.          *  查询（在缓存中已经有）或生成指定的代理类的class对象。
  19.          */
  20.         Class<?> cl = getProxyClass0(loader, intfs);
  22.         /*
  23.          * Invoke its constructor with the designated invocation handler.
  24.          */
  25.         try {
  26.             if (sm != null) {
  27.                 checkNewProxyPermission(Reflection.getCallerClass(), cl);
  28.             }
  29.             //得到代理类对象的构造函数，这个构造函数的参数由constructorParams指定
  30.             //参数constructorParames为常量值：private static final Class<?>[] constructorParams = { InvocationHandler.class };
  31.             final Constructor<?> cons = cl.getConstructor(constructorParams);
  32.             final InvocationHandler ih = h;
  33.             if (!Modifier.isPublic(cl.getModifiers())) {
  34.                 AccessController.doPrivileged(new PrivilegedAction<Void>() {
  35.                     public Void run() {
  36.                         cons.setAccessible(true);
  37.                         return null;
  38.                     }
  39.                 });
  40.             }
  41.             //这里生成代理对象，传入的参数new Object[]{h}后面讲
  42.             return cons.newInstance(new Object[]{h});
  43.         } catch (IllegalAccessException|InstantiationException e) {
  44.             throw new InternalError(e.toString(), e);
  45.         } catch (InvocationTargetException e) {
  46.             Throwable t = e.getCause();
  47.             if (t instanceof RuntimeException) {
  48.                 throw (RuntimeException) t;
  49.             } else {
  50.                 throw new InternalError(t.toString(), t);
  51.             }
  52.         } catch (NoSuchMethodException e) {
  53.             throw new InternalError(e.toString(), e);
  54.         }
  55.     }

这段代码核心就是通过getProxyClass0(loader, intfs)得到代理类的Class对象，然后通过Class对象得到构造方法，进而创建代理对象。下一步看getProxyClass0这个方法。

  1. //此方法也是Proxy类下的方法
  2.     private static Class<?> getProxyClass0(ClassLoader loader,
  3.                                            Class<?>... interfaces) {
  4.         if (interfaces.length > 65535) {
  5.             throw new IllegalArgumentException("interface limit exceeded");
  6.         }
  8.         // If the proxy class defined by the given loader implementing
  9.         // the given interfaces exists, this will simply return the cached copy;
  10.         // otherwise, it will create the proxy class via the ProxyClassFactory
  11.         //意思是：如果代理类被指定的类加载器loader定义了，并实现了给定的接口interfaces，
  12.         //那么就返回缓存的代理类对象，否则使用ProxyClassFactory创建代理类。
  13.         return proxyClassCache.get(loader, interfaces);
  14.     }

这里看到proxyClassCache，有Cache便知道是缓存的意思，正好呼应了前面Look up or generate the designated proxy class。查询（在缓存中已经有）或生成指定的代理类的class对象这段注释。

在进入get方法之前，我们看下 proxyClassCache是什么？高能预警，前方代码看起来可能有乱，但我们只需要关注重点即可。

  1. private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
  2.         proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

proxyClassCache是个WeakCache类的对象，调用proxyClassCache.get(loader, interfaces); 可以得到缓存的代理类或创建代理类（没有缓存的情况）。说明WeakCache中有get这个方法。先看下WeakCache类的定义（这里先只给出变量的定义和构造函数）：

  1. //K代表key的类型，P代表参数的类型，V代表value的类型。
  2. // WeakCache<ClassLoader, Class<?>[], Class<?>>  proxyClassCache  说明proxyClassCache存的值是Class<?>对象，正是我们需要的代理类对象。
  3. final class WeakCache<K, P, V> {
  5.     private final ReferenceQueue<K> refQueue
  6.         = new ReferenceQueue<>();
  7.     // the key type is Object for supporting null key
  8.     private final ConcurrentMap<Object, ConcurrentMap<Object, Supplier<V>>> map
  9.         = new ConcurrentHashMap<>();
  10.     private final ConcurrentMap<Supplier<V>, Boolean> reverseMap
  11.         = new ConcurrentHashMap<>();
  12.     private final BiFunction<K, P, ?> subKeyFactory;
  13.     private final BiFunction<K, P, V> valueFactory;
  16.     public WeakCache(BiFunction<K, P, ?> subKeyFactory,
  17.                      BiFunction<K, P, V> valueFactory) {
  18.         this.subKeyFactory = Objects.requireNonNull(subKeyFactory);
  19.         this.valueFactory = Objects.requireNonNull(valueFactory);
  20.     }

其中map变量是实现缓存的核心变量，他是一个双重的Map结构: (key, sub-key) -> value。其中key是传进来的Classloader进行包装后的对象，sub-key是由WeakCache构造函数传人的KeyFactory()生成的。value就是产生代理类的对象，是由WeakCache构造函数传人的ProxyClassFactory()生成的。如下，回顾一下:

  1. private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
  2.         proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

产生sub-key的KeyFactory代码如下，这个我们不去深究，只要知道他是根据传入的ClassLoader和接口类生成sub-key即可。

  1. private static final class KeyFactory
  2.         implements BiFunction<ClassLoader, Class<?>[], Object>
  3.     {
  4.         @Override
  5.         public Object apply(ClassLoader classLoader, Class<?>[] interfaces) {
  6.             switch (interfaces.length) {
  7.                 case 1: return new Key1(interfaces[0]); // the most frequent
  8.                 case 2: return new Key2(interfaces[0], interfaces[1]);
  9.                 case 0: return key0;
  10.                 default: return new KeyX(interfaces);
  11.             }
  12.         }
  13.     }

通过sub-key拿到一个Supplier<Class<?>>对象，然后调用这个对象的get方法，最终得到代理类的Class对象。

好，大体上说完WeakCache这个类的作用，我们回到刚才proxyClassCache.get(loader, interfaces);这句代码。get是WeakCache里的方法。源码如下：

  1. //K和P就是WeakCache定义中的泛型，key是类加载器，parameter是接口类数组
  2. public V get(K key, P parameter) {
  3.         //检查parameter不为空
  4.         Objects.requireNonNull(parameter);
  5.          //清除无效的缓存
  6.         expungeStaleEntries();
  7.         // cacheKey就是(key, sub-key) -> value里的一级key，
  8.         Object cacheKey = CacheKey.valueOf(key, refQueue);
  10.         // lazily install the 2nd level valuesMap for the particular cacheKey
  11.         //根据一级key得到 ConcurrentMap<Object, Supplier<V>>对象。如果之前不存在，则新建一个ConcurrentMap<Object, Supplier<V>>和cacheKey（一级key）一起放到map中。
  12.         ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
  13.         if (valuesMap == null) {
  14.             ConcurrentMap<Object, Supplier<V>> oldValuesMap
  15.                 = map.putIfAbsent(cacheKey,
  16.                                   valuesMap = new ConcurrentHashMap<>());
  17.             if (oldValuesMap != null) {
  18.                 valuesMap = oldValuesMap;
  19.             }
  20.         }
  22.         // create subKey and retrieve the possible Supplier<V> stored by that
  23.         // subKey from valuesMap
  24.         //这部分就是调用生成sub-key的代码，上面我们已经看过怎么生成的了
  25.         Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
  26.         //通过sub-key得到supplier
  27.         Supplier<V> supplier = valuesMap.get(subKey);
  28.         //supplier实际上就是这个factory
  29.         Factory factory = null;
  31.         while (true) {
  32.             //如果缓存里有supplier ，那就直接通过get方法，得到代理类对象，返回，就结束了，一会儿分析get方法。
  33.             if (supplier != null) {
  34.                 // supplier might be a Factory or a CacheValue<V> instance
  35.                 V value = supplier.get();
  36.                 if (value != null) {
  37.                     return value;
  38.                 }
  39.             }
  40.             // else no supplier in cache
  41.             // or a supplier that returned null (could be a cleared CacheValue
  42.             // or a Factory that wasn't successful in installing the CacheValue)
  43.             // lazily construct a Factory
  44.             //下面的所有代码目的就是：如果缓存中没有supplier，则创建一个Factory对象，把factory对象在多线程的环境下安全的赋给supplier。
  45.             //因为是在while（true）中，赋值成功后又回到上面去调get方法，返回才结束。
  46.             if (factory == null) {
  47.                 factory = new Factory(key, parameter, subKey, valuesMap);
  48.             }
  50.             if (supplier == null) {
  51.                 supplier = valuesMap.putIfAbsent(subKey, factory);
  52.                 if (supplier == null) {
  53.                     // successfully installed Factory
  54.                     supplier = factory;
  55.                 }
  56.                 // else retry with winning supplier
  57.             } else {
  58.                 if (valuesMap.replace(subKey, supplier, factory)) {
  59.                     // successfully replaced
  60.                     // cleared CacheEntry / unsuccessful Factory
  61.                     // with our Factory
  62.                     supplier = factory;
  63.                 } else {
  64.                     // retry with current supplier
  65.                     supplier = valuesMap.get(subKey);
  66.                 }
  67.             }
  68.         }
  69.     }

所以接下来我们看Factory类中的get方法。

  1. public synchronized V get() { // serialize access
  2.             // re-check
  3.             Supplier<V> supplier = valuesMap.get(subKey);
  4.             //重新检查得到的supplier是不是当前对象
  5.             if (supplier != this) {
  6.                 // something changed while we were waiting:
  7.                 // might be that we were replaced by a CacheValue
  8.                 // or were removed because of failure ->
  9.                 // return null to signal WeakCache.get() to retry
  10.                 // the loop
  11.                 return null;
  12.             }
  13.             // else still us (supplier == this)
  15.             // create new value
  16.             V value = null;
  17.             try {
  18.                  //代理类就是在这个位置调用valueFactory生成的
  19.                  //valueFactory就是我们传入的 new ProxyClassFactory()
  20.                 //一会我们分析ProxyClassFactory()的apply方法
  21.                 value = Objects.requireNonNull(valueFactory.apply(key, parameter));
  22.             } finally {
  23.                 if (value == null) { // remove us on failure
  24.                     valuesMap.remove(subKey, this);
  25.                 }
  26.             }
  27.             // the only path to reach here is with non-null value
  28.             assert value != null;
  30.             // wrap value with CacheValue (WeakReference)
  31.             //把value包装成弱引用
  32.             CacheValue<V> cacheValue = new CacheValue<>(value);
  34.             // put into reverseMap
  35.             // reverseMap是用来实现缓存的有效性
  36.             reverseMap.put(cacheValue, Boolean.TRUE);
  38.             // try replacing us with CacheValue (this should always succeed)
  39.             if (!valuesMap.replace(subKey, this, cacheValue)) {
  40.                 throw new AssertionError("Should not reach here");
  41.             }
  43.             // successfully replaced us with new CacheValue -> return the value
  44.             // wrapped by it
  45.             return value;
  46.         }
  47.     }

拨云见日，来到ProxyClassFactory的apply方法，代理类就是在这里生成的。

  1. //这里的BiFunction<T, U, R>是个函数式接口，可以理解为用T，U两种类型做参数，得到R类型的返回值
  2. private static final class ProxyClassFactory
  3.         implements BiFunction<ClassLoader, Class<?>[], Class<?>>
  4.     {
  5.         // prefix for all proxy class names
  6.         //所有代理类名字的前缀
  7.         private static final String proxyClassNamePrefix = "$Proxy";
  9.         // next number to use for generation of unique proxy class names
  10.         //用于生成代理类名字的计数器
  11.         private static final AtomicLong nextUniqueNumber = new AtomicLong();
  13.         @Override
  14.         public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
  16.             Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
  17.             //验证代理接口，可不看
  18.             for (Class<?> intf : interfaces) {
  19.                 /*
  20.                  * Verify that the class loader resolves the name of this
  21.                  * interface to the same Class object.
  22.                  */
  23.                 Class<?> interfaceClass = null;
  24.                 try {
  25.                     interfaceClass = Class.forName(intf.getName(), false, loader);
  26.                 } catch (ClassNotFoundException e) {
  27.                 }
  28.                 if (interfaceClass != intf) {
  29.                     throw new IllegalArgumentException(
  30.                         intf + " is not visible from class loader");
  31.                 }
  32.                 /*
  33.                  * Verify that the Class object actually represents an
  34.                  * interface.
  35.                  */
  36.                 if (!interfaceClass.isInterface()) {
  37.                     throw new IllegalArgumentException(
  38.                         interfaceClass.getName() + " is not an interface");
  39.                 }
  40.                 /*
  41.                  * Verify that this interface is not a duplicate.
  42.                  */
  43.                 if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
  44.                     throw new IllegalArgumentException(
  45.                         "repeated interface: " + interfaceClass.getName());
  46.                 }
  47.             }
  48.             //生成的代理类的包名 
  49.             String proxyPkg = null;     // package to define proxy class in
  50.             //代理类访问控制符: public ,final
  51.             int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
  53.             /*
  54.              * Record the package of a non-public proxy interface so that the
  55.              * proxy class will be defined in the same package.  Verify that
  56.              * all non-public proxy interfaces are in the same package.
  57.              */
  58.             //验证所有非公共的接口在同一个包内；公共的就无需处理
  59.             //生成包名和类名的逻辑，包名默认是com.sun.proxy，类名默认是$Proxy 加上一个自增的整数值
  60.             //如果被代理类是 non-public proxy interface ，则用和被代理类接口一样的包名
  61.             for (Class<?> intf : interfaces) {
  62.                 int flags = intf.getModifiers();
  63.                 if (!Modifier.isPublic(flags)) {
  64.                     accessFlags = Modifier.FINAL;
  65.                     String name = intf.getName();
  66.                     int n = name.lastIndexOf('.');
  67.                     String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
  68.                     if (proxyPkg == null) {
  69.                         proxyPkg = pkg;
  70.                     } else if (!pkg.equals(proxyPkg)) {
  71.                         throw new IllegalArgumentException(
  72.                             "non-public interfaces from different packages");
  73.                     }
  74.                 }
  75.             }
  77.             if (proxyPkg == null) {
  78.                 // if no non-public proxy interfaces, use com.sun.proxy package
  79.                 proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
  80.             }
  82.             /*
  83.              * Choose a name for the proxy class to generate.
  84.              */
  85.             long num = nextUniqueNumber.getAndIncrement();
  86.             //代理类的完全限定名，如com.sun.proxy.$Proxy0.calss
  87.             String proxyName = proxyPkg + proxyClassNamePrefix + num;
  89.             /*
  90.              * Generate the specified proxy class.
  91.              */
  92.             //核心部分，生成代理类的字节码
  93.             byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
  94.                 proxyName, interfaces, accessFlags);
  95.             try {
  96.                 //把代理类加载到JVM中，至此动态代理过程基本结束了
  97.                 return defineClass0(loader, proxyName,
  98.                                     proxyClassFile, 0, proxyClassFile.length);
  99.             } catch (ClassFormatError e) {
  100.                 /*
  101.                  * A ClassFormatError here means that (barring bugs in the
  102.                  * proxy class generation code) there was some other
  103.                  * invalid aspect of the arguments supplied to the proxy
  104.                  * class creation (such as virtual machine limitations
  105.                  * exceeded).
  106.                  */
  107.                 throw new IllegalArgumentException(e.toString());
  108.             }
  109.         }
  110.     }

到这里其实已经分析完了，但是本着深究的态度，决定看看JDK生成的动态代理字节码是什么，于是我们将字节码保存到磁盘上的class文件中。代码如下：

  1. public class DynamicProxyTest {
  3.     public static void main(String[] args) {
  5.         IUserService target = new UserServiceImpl();
  6.         MyInvocationHandler handler = new MyInvocationHandler(target);
  7.         //第一个参数是指定代理类的类加载器（我们传入当前测试类的类加载器）
  8.         //第二个参数是代理类需要实现的接口（我们传入被代理类实现的接口，这样生成的代理类和被代理类就实现了相同的接口）
  9.         //第三个参数是invocation handler，用来处理方法的调用。这里传入我们自己实现的handler
  10.         IUserService proxyObject = (IUserService) Proxy.newProxyInstance(DynamicProxyTest.class.getClassLoader(),
  11.                 target.getClass().getInterfaces(), handler);
  12.         proxyObject.add("陈粒");
  14.         String path = "D:/$Proxy0.class";
  15.         byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0", UserServiceImpl.class.getInterfaces());
  16.         FileOutputStream out = null;
  18.         try {
  19.             out = new FileOutputStream(path);
  20.             out.write(classFile);
  21.             out.flush();
  22.         } catch (Exception e) {
  23.             e.printStackTrace();
  24.         } finally {
  25.             try {
  26.                 out.close();
  27.             } catch (IOException e) {
  28.                 e.printStackTrace();
  29.             }
  30.         }
  32.     }
  33. }

运行这段代码，会在D盘生成一个名为$Proxy0.class的文件。通过反编译工具,得到JDK为我们生成的代理类是这样的：

  1. public final class $Proxy0 extends Proxy
  2.     implements IUserService
  3. {
  5.     private static Method m1;
  6.     private static Method m2;
  7.     private static Method m3;
  8.     private static Method m0;
  9.     //代理类的构造函数，其参数正是是InvocationHandler实例，
  10.     //Proxy.newInstance方法就是通过通过这个构造函数来创建代理实例的
  11.     public $Proxy0(InvocationHandler invocationhandler)
  12.     {
  13.         super(invocationhandler);
  14.     }
  15.      // Object类中的三个方法，equals，toString， hashCode
  16.     public final boolean equals(Object obj)
  17.     {
  18.         try
  19.         {
  20.             return ((Boolean)super.h.invoke(this, m1, new Object[] {
  21.                 obj
  22.             })).booleanValue();
  23.         }
  24.         catch (Error ) { }
  25.         catch (Throwable throwable)
  26.         {
  27.             throw new UndeclaredThrowableException(throwable);
  28.         }
  29.     }
  31.     public final String toString()
  32.     {
  33.         try
  34.         {
  35.             return (String)super.h.invoke(this, m2, null);
  36.         }
  37.         catch (Error ) { }
  38.         catch (Throwable throwable)
  39.         {
  40.             throw new UndeclaredThrowableException(throwable);
  41.         }
  42.     }
  43.     //接口代理方法
  44.     public final void add(String s)
  45.     {
  46.         try
  47.         {
  48.             // invocation handler的 invoke方法在这里被调用
  49.             super.h.invoke(this, m3, new Object[] {
  50.                 s
  51.             });
  52.             return;
  53.         }
  54.         catch (Error ) { }
  55.         catch (Throwable throwable)
  56.         {
  57.             throw new UndeclaredThrowableException(throwable);
  58.         }
  59.     }
  61.     public final int hashCode()
  62.     {
  63.         try
  64.         {
  65.             // 在这里调用了invoke方法。
  66.             return ((Integer)super.h.invoke(this, m0, null)).intValue();
  67.         }
  68.         catch (Error ) { }
  69.         catch (Throwable throwable)
  70.         {
  71.             throw new UndeclaredThrowableException(throwable);
  72.         }
  73.     }
  75.     // 静态代码块对变量进行一些初始化工作
  76.     static 
  77.     {
  78.         try
  79.         {
  80.             m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {
  81.                 Class.forName("java.lang.Object")
  82.             });
  83.             m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
  84.             m3 = Class.forName("com.zhb.jdk.proxy.IUserService").getMethod("add", new Class[] {
  85.                 Class.forName("java.lang.String")
  86.             });
  87.             m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
  88.         }
  89.         catch (NoSuchMethodException nosuchmethodexception)
  90.         {
  91.             throw new NoSuchMethodError(nosuchmethodexception.getMessage());
  92.         }
  93.         catch (ClassNotFoundException classnotfoundexception)
  94.         {
  95.             throw new NoClassDefFoundError(classnotfoundexception.getMessage());
  96.         }
  97.     }
  98. }

生成了Object类的三个方法：toString，hashCode，equals。还有我们需要被代理的方法。

至此整个JDK动态代理的过程，就分析完了!

本文转载自JDK动态代理-超详细源码分析

发表评论

表情：
评论列表 （有 0 条评论，284人围观）

还没有评论，来说两句吧...

相关阅读

    相关 从源码分析JDK动态代理

    引言 动态代理非常的重要，虽然我们在日常的工作中没有非常底层的 编写过动态代理的代码，但是动态代理却起着非常重要的功能，想一下我们经常使用的框架： 日志框架、AOP等等，

    Love The Way You LieLove The Way You Lie/ 0 赞/ 100 阅读

    相关 JDK动态代理分析

    代理：代理是一种模式，提供了对目标对象的间接访问方式，即通过代理访问目标对象。如此便于在目标实现的基础上增加额外的功能操作，前拦截，后拦截等，以满足自身的业务需求，同时代理模式

    悠悠悠悠/ 0 赞/ 266 阅读

    相关 JDK动态代理之源码分析

    一、代理模式是什么？ 代理模式就是给一个对象提供一个代理对象，并由代理对象管理着被代理对象的引用。就像生活中的代理律师，你只需要找好代理律师，剩下的都交给代理律师来打理。

    绝地灬酷狼绝地灬酷狼/ 0 赞/ 304 阅读