JDK动态代理的实现及原理

发表于 | 分类于 | 阅读次数   |   字数统计: 1,975(字)   |   阅读时长: 9(分)

简介

关于JDK的动态代理，最为人熟知的可能要数spring AOP的实现，默认情况下，Spring AOP的实现对于接口来说就是使用的JDK的动态代理来实现的，而对于类的代理使用CGLIB来实现。那么，什么是JDK的动态代理呢？

JDK的动态代理，就是在程序运行的过程中，根据被代理的接口来动态生成代理类的class文件，并加载运行的过程。

使用JDK代理

JDK提供了Java.lang.reflect.Proxy类来实现动态代理，可通过它的newProxyInstance来获得代理实现类。

1
2
3
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
        throws IllegalArgumentException
    {......}

根据方法定义可知，此方法需要三个参数 下面分别构造

被代理的接口

1
2
3
4
5
6
/**
 * Created by lilixin on 29/08/2017.
 */
public interface HelloWorld {
    void sayHello(String name);
}

接口的实现类

1
2
3
4
5
6
7
8
9
10
11
/**
 * @author lilixin
 * @description
 * @create 2017-08-29 4:46 PM
 **/
public class MyHelloWorld implements HelloWorld {
    @Override
    public void sayHello(String name) {
        System.out.println("hello "+name);
    }
}

实现一个InvocationHandler

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
 * @author lilixin
 * @description
 * @create 2017-08-29 4:21 PM
 **/
public class MyProxyInvocationHandler implements InvocationHandler{
    private Object target;
    public MyProxyInvocationHandler(Object target) {
        super();
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("invoke begin");
        Object invoke = method.invoke(target,args);
        System.out.println("invoke end");
        return invoke;
    }
}

测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import java.lang.reflect.Proxy;
/**
 * @author lilixin
 * @description 测试类
 * @create 2017-08-29 4:38 PM
 **/
public class DynamicProxyTest {
    public static void main(String[] args) {
        //创建InvocationHandler
        MyProxyInvocationHandler invocationHandler = new MyProxyInvocationHandler(new MyHelloWorld());
        HelloWorld world = (HelloWorld)Proxy.newProxyInstance(DynamicProxyTest.class.getClassLoader(), new Class[]{HelloWorld.class}, invocationHandler);
        world.sayHello("LiLiXin");
    }
}

输出结果

1
2
3
invoke begin
hello LiLiXin
invoke end

原理及实现分析

从上面可知 JDK的使用很简单，但想要了解他的具体实现过程还是得从源码入手 这里的JDK版本是jdk1.7.0_80

newProxyInstance方法源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
        throws IllegalArgumentException
    {
        if (h == null) {
            throw new NullPointerException();
        }
        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }
        //可知这里是生成代理类的地方 应重点关注
        Class<?> cl = getProxyClass0(loader, intfs);
		//这里使用我们实现的InvocationHandler来获取代理类的构造函数
   try {
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {
                // create proxy instance with doPrivilege as the proxy class may
                // implement non-public interfaces that requires a special permission
                return AccessController.doPrivileged(new PrivilegedAction<Object>() {
                    public Object run() {
                        return newInstance(cons, ih);
                    }
                });
            } else {
                return newInstance(cons, ih);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString());
        }
    }

从源码中可知 代理类是在getProxyClass0(..)方法中生成的，应该重点关注此方法，newInstance(..)方法中只是调用了传入的参数的newInstance方法

getProxyClass0方法源码

1
2
3
4
5
6
7
8
private static Class<?> getProxyClass0(ClassLoader loader, Class<?>... interfaces) {
  if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }
        //JDK对代理进行了缓存，如果已经存在相应的代理类，则直接返回，否则才会通过ProxyClassFactory来创建代理  
        return proxyClassCache.get(loader, interfaces);
    }

具体缓存逻辑我们不需要关心，只需要关注如何生成代理类的，ProxyClassFactory是Proxy类的一个静态内部类，它实现了WeakCache的内部接口BiFunction的apply方法，WeakCache是其代理缓存的实现

ProxyClassFactory源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
private static final class ProxyClassFactory
       implements BiFunction<ClassLoader, Class<?>[], Class<?>>
   {
       // 所有代理类名字的前缀 
       private static final String proxyClassNamePrefix = "$Proxy";
       //用于生成代理类名字的计数器
       private static final AtomicLong nextUniqueNumber = new AtomicLong();
       @Override
       public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
           //省略了部分代码。。。
			//生成的代理类的包名
           String proxyPkg = null;     
           // 对于非公共接口，代理类的包名与接口的相同  
           for (Class<?> intf : interfaces) {
               int flags = intf.getModifiers();
               if (!Modifier.isPublic(flags)) {
                   String name = intf.getName();
                   int n = name.lastIndexOf('.');
                   String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                   if (proxyPkg == null) {
                       proxyPkg = pkg;
                   } else if (!pkg.equals(proxyPkg)) {
                       throw new IllegalArgumentException(
                           "non-public interfaces from different packages");
                   }
               }
           }
           if (proxyPkg == null) {
               // 对于公共接口的包名，默认为com.sun.proxy  
               proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
           }
           //用计数器及包名确定代理类的名字
           long num = nextUniqueNumber.getAndIncrement();
           String proxyName = proxyPkg + proxyClassNamePrefix + num;
            // 这里才是真正的生成代理类的字节码的地方  
           byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
               proxyName, interfaces);
           try {
           // 根据二进制字节码返回相应的Class实例  
               return defineClass0(loader, proxyName,
                                   proxyClassFile, 0, proxyClassFile.length);
           } catch (ClassFormatError e) {
     
               throw new IllegalArgumentException(e.toString());
           }
       }
   }

由源码可知，最终是由sun.misc包中ProxyGenerator类的generateProxyClass()方法生成的代理类

generateProxyClass源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public static byte[] generateProxyClass(final String var0, Class[] var1) {
       ProxyGenerator var2 = new ProxyGenerator(var0, var1);
       final byte[] var3 = var2.generateClassFile();
       //根据参数决定是否把生成的代理文件保存到本地
       if(saveGeneratedFiles) {
           AccessController.doPrivileged(new PrivilegedAction<Void>() {
               public Void run() {
                   try {
                       int var1 = var0.lastIndexOf(46);
                       Path var2;
                       if(var1 > 0) {
                           Path var3x = Paths.get(var0.substring(0, var1).replace('.', File.separatorChar), new String[0]);
                           Files.createDirectories(var3x, new FileAttribute[0]);
                           var2 = var3x.resolve(var0.substring(var1 + 1, var0.length()) + ".class");
                       } else {
                           var2 = Paths.get(var0 + ".class", new String[0]);
                       }
                       Files.write(var2, var3, new OpenOption[0]);
                       return null;
                   } catch (IOException var4) {
                       throw new InternalError("I/O exception saving generated file: " + var4);
                   }
               }
           });
       }
       return var3;
   }

由源码得知，根据参数saveGeneratedFiles值来决定是否把生成的代理类保存到本地 继续跟跟踪源码

1
private static final boolean saveGeneratedFiles = ((Boolean)AccessController.doPrivileged(new GetBooleanAction("sun.misc.ProxyGenerator.saveGeneratedFiles"))).booleanValue();

GetBooleanAction实际上是调用Boolean.getBoolean(propName)来获得的，而Boolean.getBoolean(propName)调用了System.getProperty(name)，所以我们可以设置sun.misc.ProxyGenerator.saveGeneratedFiles这个系统属性为true来把生成的class保存到本地文件来查看。

重新执行测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
 * @author lilixin
 * @description 测试类
 * @create 2017-08-29 4:38 PM
 **/
public class DynamicProxyTest {
    public static void main(String[] args) {
        //设置属性值为true 这样就可以把生成的代理类保存到本地
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
        //创建InvocationHandler
        MyProxyInvocationHandler invocationHandler = new MyProxyInvocationHandler(new MyHelloWorld());
        HelloWorld world = (HelloWorld)Proxy.newProxyInstance(DynamicProxyTest.class.getClassLoader(), new Class[]{HelloWorld.class}, invocationHandler);
        world.sayHello("LiLiXin");
    }
}

生成的代理类源码

运行测试类 在目录com/sun/proxy下面可找到$Proxy0.class类，对其进行反编译

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class $Proxy0
  extends Proxy
  implements HelloWorld
{
  private static Method m1;
  private static Method m3;
  private static Method m0;
  private static Method m2;
  
  public $Proxy0(InvocationHandler paramInvocationHandler)
  {
    super(paramInvocationHandler);
  }
  
  public final boolean equals(Object paramObject)
  {
    try
    {
      return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }
  
  public final void sayHello(String paramString)
  {
    try
    {
      this.h.invoke(this, m3, new Object[] { paramString });
      return;
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }
  
  public final int hashCode()
  {
    try
    {
      return ((Integer)this.h.invoke(this, m0, null)).intValue();
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }
  
  public final String toString()
  {
    try
    {
      return (String)this.h.invoke(this, m2, null);
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }
  
  static
  {
    try
    {
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
      m3 = Class.forName("top.lilixin.user.controller.HelloWorld").getMethod("sayHello", new Class[] { Class.forName("java.lang.String") });
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
      return;
    }
    catch (NoSuchMethodException localNoSuchMethodException)
    {
      throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
    }
    catch (ClassNotFoundException localClassNotFoundException)
    {
      throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
    }
  }
}

从源码中可以看到，动态生成的代理类有如下特性：

  • 代理类继承了Proxy类，实现了代理的HelloWorld接口，由于java不能多继承，这里已经继承了Proxy类了，不能再继承其他的类，所以JDK的动态代理不支持对实现类的代理，只支持接口的代理。
  • 提供了一个使用InvocationHandler作为参数的构造方法。
  • 代理类实现代理接口的sayHello方法中，只是简单的调用了InvocationHandler的invoke方法，我们可以在invoke方法中进行一些特殊操作，甚至不调用实现的方法，直接返回。

spring AOP

从上面的源码分析中我们可以大致了解到spring aop的各种拦截如何实现，很明显 无非就是在method.invoke方法调用前后做文章 代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
    // BeforeAdvice  
    Object invoke = null;  
    try {  
        // AroundAdvice  
        invoke = method.invoke(target, args);  
        // AroundAdvice  
        // AfterReturningAdvice  
    }  
    catch (Throwable e) {  
        // AfterThrowingAdvice  
    }  
    finally {  
        // AfterAdvice  
    }  
    return invoke;  
}

总结

  1. 底层最终是由sun.misc包中ProxyGenerator类的generateProxyClass()方法生成的代理类
  2. 通过Proxy.newProxyInstance()生成代理类的实例对象，创建对象时传入InvocationHandler类型的实例。
  3. 调用新实例的方法 world.sayHello(“name”);即调用传入的InvocationHandler类中的invoke()方法。

本文融合多篇文章整理而成，具体文章连接已遗失，如有侵权请告知

关注我的微信，共同分享与讨论！