java动态代理的实现以及原理

1.前言

之前对动态代理的技术只是表面上理解,没有形成一个体系,这里总结一下,整个动态代理的实现以及实现原理,以表述的更清楚一些。

2.动态代理的实现应用到的技术

1、动态编译技术,可以使用Java自带的JavaCompiler类,也可以使用CGLIB、ASM等字节码增强技术,Java的动态代理包括Spring的内部实现貌似用的都是这个

2、反射,包括对于类.class和getClass()方法的理解,Method类、Constructor类的理解

3、IO流,主要就是字符输出流FileWriter

4、对于ClassLoader的理解

3.动态代理示例

接口类:

1

2

3

4

public interface UserService { 

    public abstract void add();

    public abstract void update();

}

接口实现类:

1

2

3

4

5

6

7

8

9

10

public class UserServiceImpl implements UserService { 

   

     public void add() { 

        System.out.println("----- add -----"); 

    }

     

    public void update(){

         System.out.println("----- update-----"); 

    }

}

代理处理类MyInvocationHandler.java

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

import java.lang.reflect.InvocationHandler; 

import java.lang.reflect.Method; 

import java.lang.reflect.Proxy; 

   

public class MyInvocationHandler implements InvocationHandler { 

   

    private Object target; 

   

    public MyInvocationHandler(Object target) { 

        super(); 

        this.target = target; 

    

   

    public Object getProxy() { 

        return Proxy.newProxyInstance(Thread.currentThread() 

                .getContextClassLoader(), target.getClass().getInterfaces(), 

                this); 

    

   

    @Override 

    public Object invoke(Object proxy, Method method, Object[] args) 

            throws Throwable { 

        System.out.println("----- before -----"); 

        Object result = method.invoke(target, args); 

        System.out.println("----- after -----"); 

        return result; 

    

 测试类:

1

2

3

4

5

6

7

8

9

10

11

12

public class DynamicProxyTest { 

   

    public static void main(String[] args) { 

        UserService userService = new UserServiceImpl(); 

        MyInvocationHandler invocationHandler = new MyInvocationHandler( 

                userService); 

   

        UserService proxy = (UserService) invocationHandler.getProxy(); 

        proxy.add();

        proxy.update();

    

 输出:

1

2

3

4

5

6

----- before -----

----- add -----

----- after -----

----- before -----

----- update -----

----- after -----

用起来是很简单,其实这里基本上就是AOP的一个简单实现了,目的是在目标对象的方法执行之前和执行之后进行了增强。

Spring的AOP实现其实也是用了Proxy和InvocationHandler这两个东西的。 

4.动态代理原理

下面我们从jdk实现的源代码的层面分析一下,动态代理产生的整个过程。

上面的程序的入口,便是代理处理类MyInvocationHandler中的getProxy()方法。

1

2

3

4

5

public Object getProxy() { 

       return Proxy.newProxyInstance(Thread.currentThread() 

               .getContextClassLoader(), target.getClass().getInterfaces(), 

               this); 

}

Proxy.newProxyInstance() 方法,最终将返回一个实现了指定接口的类的实例,

其三个参数分别是:ClassLoader,指定的接口及我们自己定义的InvocationHandler类。我摘几条关键的代码出来,看看这个代理类的实例对象到底是怎么生成的。

4.1 Proxy.newProxyInstance的源码(JDK1.6):

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

public static Object newProxyInstance(ClassLoader loader,

                      Class[] interfaces,

                      InvocationHandler h)

    throws IllegalArgumentException

    {

    if (h == null) {

        throw new NullPointerException();

    }

 

    /*

     * Look up or generate the designated proxy class.

     */

       //getProxyClass获得这个代理类

        Class cl = getProxyClass0(loader, interfaces); // stack walk magic: do not refactor

 

    /*

     * Invoke its constructor with the designated invocation handler.

     */

    try {

            //然后通过c1.getConstructor()拿到构造函数

            final Constructor cons = cl.getConstructor(constructorParams);

            final InvocationHandler ih = h;

            SecurityManager sm = System.getSecurityManager();

            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() {

                    public Object run() {

                        //通过cons.newInstance返回这个新的代理类的一个实例,注意:调用newInstance的时候,传入的参数为h,即我们自己定义好的InvocationHandler类

                        return newInstance(cons, ih);

                    }

                });

            else {

                return newInstance(cons, ih);

            }

    catch (NoSuchMethodException e) {

        throw new InternalError(e.toString());

    }

    }

4.2 我们再去看getProxyClass0()方法的源码:

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

private static Class getProxyClass0(ClassLoader loader, Class... interfaces) {

        .........省略一些代码

        // 如果目标类实现的接口数大于65535个则抛出异常(我XX) 

        if (interfaces.length > 65535) {

        throw new IllegalArgumentException("interface limit exceeded");

    }

        //声明代理对象的Class对象

    Class proxyClass = null;

 

    String[] interfaceNames = new String[interfaces.length];

 

    Set interfaceSet = new HashSet();

        // 遍历目标类所实现的接口 

    for (int i = 0; i < interfaces.length; i++) {

       // 拿到目标类实现的接口的名称 

        String interfaceName = interfaces[i].getName();

        Class interfaceClass = null;

        try {

               // 加载目标类实现的接口到内存中 

        interfaceClass = Class.forName(interfaceName, false, loader);

        catch (ClassNotFoundException e) {

        }

        if (interfaceClass != interfaces[i]) {

        throw new IllegalArgumentException(

            interfaces[i] + " is not visible from class loader");

        }

 

        /*

         * JDK里规定了:动态代理 只能针对接口生成代理,不能只针对某一个类生成代理

这也算是一个缺点吧,如果需要对一个类生成代理则可用第三方库

         */

        if (!interfaceClass.isInterface()) {

        throw new IllegalArgumentException(

            interfaceClass.getName() + " is not an interface");

        }

           // 把目标类实现的接口代表的Class对象放到Set中

        interfaceSet.add(interfaceClass);

 

        interfaceNames[i] = interfaceName;

    }

 

    // 把目标类实现的接口名称作为缓存(Map)中的key 

    Object key = Arrays.asList(interfaceNames);

 

    Map cache;

    synchronized (loaderToCache) {

           // 从缓存中获取cache 

        cache = (Map) loaderToCache.get(loader);

        if (cache == null) {

               // 如果获取不到,则新建地个HashMap实例 

        cache = new HashMap();

        loaderToCache.put(loader, cache);

        }

    }

 

    synchronized (cache) {

        do {

                //根据接口的名称从缓存中获取对象 

        Object value = cache.get(key);

        if (value instanceof Reference) {

            proxyClass = (Class) ((Reference) value).get();

        }

        if (proxyClass != null) {

            // 如果代理对象的Class实例已经存在,则直接返回 

            return proxyClass;

        else if (value == pendingGenerationMarker) {

            // proxy class being generated: wait for it

            try {

            cache.wait();

            catch (InterruptedException e) {

            }

            continue;

        else {

            cache.put(key, pendingGenerationMarker);

            break;

        }

        while (true);

    }

....................省略代码

try{

               // 这里就是动态生成代理对象的最关键的地方:利用ProxyGenerator为我们生成了最终代理类的字节码文件

        byte[] proxyClassFile =ProxyGenerator.generateProxyClass(proxyName,Interfaces);

        try {

               // 根据代理类的字节码生成代理类的实例

            proxyClass = defineClass0(loader, proxyName,

            proxyClassFile, 0, proxyClassFile.length);

        catch (ClassFormatError e) {

            throw new IllegalArgumentException(e.toString());

        }

        }

        proxyClasses.put(proxyClass, null);

 

    finally {

    return proxyClass;

    }       

4.3 其中ProxyGenerator.generateProxyClass()的方法是最终生成代理类的字节码.

ProxyGenerator是sun.misc包中的类,它没有开源,不过我们可以根据它将生成的代理类的字节码保存在本地上,然后反编译查看生成的代理类。

具体请参照地址:http://blog.csdn.net/mhmyqn/article/details/48474815

4.4 反编译生成的$Proxy0.class代理类文件

下面从网上copy的一个代理类的反编译文件,对比可以看一下:

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

package com.sun.proxy; 

   

import com.mikan.proxy.HelloWorld; 

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; 

  //这个就是 上面newInstance()方法中传入的代理实现类MyInvocationHandler,而这个类在代理类中的变量名为this.h

  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 就代表MyInvocationHandler类,所以执行的就是我们代理实现类中的invoke方法。

      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("com.mikan.proxy.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()); 

    

  

}

 由此总结一下动态代理实现过程。

1.通过 Proxy.newProxyInstance() 方法,返回一个继承Proxy类,并且最终实现了指定接口的代理类的实例。

在这里分为两个大的步骤:

  1. 通过getProxyClass0()方法生成代理类。在这个方法里面,
  • ProxyGenerator.generateProxyClass()的方法是最终生成代理类的字节码.
  • defineClass0()方法把相应的字节码生成代理类

         2. 调用 newInstance(Constructor cons, InvocationHandler h)方法 创建一个新的代理类实例,创建对象时,传入我们定义好的代理处理类,InvocationHandle类。 

2. 调用新实例的方法,即此例中的add(), update()方法,即原InvocationHandler类中的invoke()方法。

5.动态代理的优点

1、最直观的,类少了很多
2、代理内容也就是InvocationHandler接口的实现类可以复用,可以给A接口用、也可以给B接口用,A接口用了InvocationHandler接口实现类A的代理,不想用了,可以方便地换成InvocationHandler接口实现B的代理
3、最重要的,用了动态代理,就可以在不修改原来代码的基础上,就在原来代码的基础上做操作,这就是AOP即面向切面编程

6.动态代理的缺点

动态代理的缺点,就是前面我们读源代码的时候遇到的。它只能针对接口生成代理,不能只针对某一个类生成代理。

如果需要为某一个单独的类实现一个代理的话,考虑使用CGLIB等第三方字节码(一种字节码增强技术)。

 

参考地址:http://blog.csdn.net/zhangerqing/article/details/42504281/

http://www.cnblogs.com/xrq730/p/4907999.html

http://blog.csdn.net/mhmyqn/article/details/4847481516:23:20

转载: https://www.cnblogs.com/haitaofeiyang/p/7724263.html

你可能感兴趣的:(java技术,底层,设计模式)