Tutorial on implementing dynamic proxy in Java

The following content is partially based on content on the Internet. I would like to express my gratitude to the original author!

The key to realizing dynamic proxy in Java is these two things: Proxy and InvocationHandler. Let’s start with the invoke method in the InvocationHandler interface and briefly explain how Java implements dynamic proxy. N i First, the integrity of the Invoke method is as follows: java code

Public Object Invoke (Object Proxy, Method Method, Object [] ARGS)

Throws Throwable

{

1. method.invoke(obj, args);      

   return 
null;                                      ， First of all, guess that Method is the method of calling, that is, the method that needs to be executed; ARGS is the parameter of the method; proxy, what is this parameter? The above implementation of the invoke() method is a relatively standard form. We see that the proxy parameter is not used here. View the description of Proxy in the JDK documentation, as follows:

4. Java code

6. A method invocation on a proxy instance through one of its pr oxy interfaces will be dispatched to the invoke method of the instance’s invocation handler, passing the proxy instance, a java.lang.reflect.Method object identifying the method that was invoked, and an array of type Object containing the arguments.

by From this we can know that the above guess is correct, and we also know that the proxy parameter is passed an instance of the proxy class.

For the convenience of explanation, here is a simple example to implement dynamic proxy.
                                                                                                                                
public interface Subject {

public
1. void request();

}

Java code

1. //Real role: Implemented the Subject’s request() method

2. public class RealSubject implements Subject{

4. public void request(){

5. System.out.println("From real subject.");

6. }

7. }

Java code

//Implemented InvocationHandler

1. public
class DynamicSubject
2. implements In vocationHandler

   {

3. private Object obj;
//This is the benefit of dynamic proxy. The encapsulated object is of Object type and accepts any type of object.
6. }

public DynamicSubject(Object obj)
9. {

10. this.obj = ob j;

11. }

// This method is not what we explicitly call

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

    throws Throwable

15. {

16. System.out.println( "before calling " + method);

18. method.invoke(obj, args); //-----> See the next article for details on this step. Java calls a certain function through the reflection mechanism You will understand the methods of each class after reading them.

19. System.out.println(
"after calling " + method);
22. return

    null;

23. }

24. )

25. 1. //Client: generated a proxy instance and called the request() method

    2. public class Client {

    4. public static void main(String [] args) throws Throwable{

    5.                                                          Subject rs=new RealSubject();//Specify the proxy here Class

    InvocationHandler ds=
    7. new DynamicSubject(rs);

       Class> cls=rs.getClass();

    ​​​​​
    9. //The following is a one-time use Generate proxy

    11.                                                                                                                                                                                   Interfaces(), ds);

    /Here it can be proved through the running results that the subject is an instance of Proxy. This instance implements the Subject interface
    14. System.out.println(subject

        instanceof Proxy);

    16.        //Here It can be seen that the subject's Class class is $Proxy0. This $Proxy0 class inherits Proxy and implements the Subject interface.

    17. toString());

    19. System.out.print("The attributes in subject are: "); [] field=subject.getClass() .getDeclaredFields();

    20.                                                                 

    21.             System.out.print(
    "n"+
    22. " The methods in subject are: "); ().getDeclaredMethods( );

                                                                   
    System.out.println(
    26. "n"+

        "subject’s parent class is: "+subject.getClass().getSuperclass());

    28. System. out.print(

        "n"+
    "The interface implemented by subject is: ");

    30. Class>[] interfaces=subject.getClass().getInterfaces();

        ​​​

    32. }

    34. System.out.println("nn"+"The operation result is: "); Subject.request();

    }
    )

    37. The running results are as follows: the package name is omitted here, * **Instead of

true subject’s Class class is: class $Proxy0 The attributes in
subject are: m1, m3, m0, m2, methods in subject are: request , hashCode, equals, toString,

subject’s parent class is: class java.lang.reflect.Proxy

subject implements the interface: cn.edu.ustc.dynamicproxy.Subject,

1. The running result is:

2. before calling public abstract void ***.Subject.request()

3. From real subject.

4. after calling public abstract void ***.Subject.re quest( )
8. PS: The information of this result is very important, at least to me. Because the root cause of my confusion about dynamic proxy is that I misunderstood the subject.request() above. At least I was confused by the surface. I did not find the connection between the subject and Proxy. I was entangled in the last call of request( ) is connected with invoke(), and how does invoke know that request exists. In fact, the above true and class $Proxy0 can solve many questions. Together with the source code of $Proxy0 mentioned below, it can completely solve the doubts about dynamic proxy.

As you can see from the above code and results, we did not explicitly call the invoke() method, but this method was indeed executed. Let’s analyze the whole process:

9. From the code in the Client, we can use the newProxyInstance method as a breakthrough. Let’s first take a look at the source code of the newProxyInstance method in the Proxy class:

Java code

1. public static Object newProxyInstance(ClassLoader loader,  

2.         Class>[] interfaces,  

3.         InvocationHandler h)  

4. throws IllegalArgumentException  

5. {  

6.     if (h == null) {  

7.         throw new NullPointerException();  

8.     }  

10.     /* 

11.      * Look up or generate the designated proxy class. 

12.      */  

13.     Class cl = getProxyClass(loader, interfaces);  

15.     /* 

16.      * Invoke its constructor with the designated invocation handler. 

17.      */  

18.     try {  

19.            /* 

20.             * Proxy源码开始有这样的定义： 

21.             * private final static Class[] constructorParams = { InvocationHandler.class }; 

22.             * cons即是形参为InvocationHandler类型的构造方法 

23.            */  

24.         Constructor cons = cl.getConstructor(constructorParams);  

25.         return (Object) cons.newInstance(new Object[] { h });  

26.     } catch (NoSuchMethodException e) {  

27.         throw new InternalError(e.toString());  

28.     } catch (IllegalAccessException e) {  

29.         throw new InternalError(e.toString());  

30.     } catch (InstantiationException e) {  

31.         throw new InternalError(e.toString());  

32.     } catch (InvocationTargetException e) {  

33.         throw new InternalError(e.toString());  

34.     }  

35. }  

Proxy.newProxyInstance(ClassLoader loader, Class>[] interfaces, InvocationHandler h) does the following things.
(1) According to the parameters loader and interfaces calling method getProxyClass(loader, interfaces) creates the proxy class $Proxy0. The $Proxy0 class implements the interfaces interface and inherits the Proxy class.
                                (2) Instantiate $Proxy0 and pass the DynamicSubject in the constructor, and then call $Proxy0 The constructor of the parent class Proxy assigns a value to h as follows:

Java code

1. class Proxy{

2. InvocationHandler h=null;

3. protected Proxy(InvocationHandler h) {

4. }

5. ...

6. }

Let’s take a look at the source code of $Proxy0 which inherits Proxy:


Java code

​

1. public final class $Proxy0 extends Proxy implements Subject {  

2.     private static Method m1;  

3.     private static Method m0;  

4.     private static Method m3;  

5.     private static Method m2;  

7.     static {  

8.         try {  

9.             m1 = Class.forName("java.lang.Object").getMethod("equals",  

10.                     new Class[] { Class.forName("java.lang.Object") });  

12.             m0 = Class.forName("java.lang.Object").getMethod("hashCode",  

13.                     new Class[0]);  

15.             m3 = Class.forName("***.RealSubject").getMethod("request",  

16.                     new Class[0]);  

18.             m2 = Class.forName("java.lang.Object").getMethod("toString",  

19.                     new Class[0]);  

21.         } catch (NoSuchMethodException nosuchmethodexception) {  

22.             throw new NoSuchMethodError(nosuchmethodexception.getMessage());  

23.         } catch (ClassNotFoundException classnotfoundexception) {  

24.             throw new NoClassDefFoundError(classnotfoundexception.getMessage());  

25.         }  

26.     } //static  

28.     public $Proxy0(InvocationHandler invocationhandler) {  

29.         super(invocationhandler);  

30.     }  

32.     @Override  

33.     public final boolean equals(Object obj) {  

34.         try {  

35.             return ((Boolean) super.h.invoke(this, m1, new Object[] { obj })) .booleanValue();  

36.         } catch (Throwable throwable) {  

37.             throw new UndeclaredThrowableException(throwable);  

38.         }  

39.     }  

41.     @Override  

42.     public final int hashCode() {  

43.         try {  

44.             return ((Integer) super.h.invoke(this, m0, null)).intValue();  

45.         } catch (Throwable throwable) {  

46.             throw new UndeclaredThrowableException(throwable);  

47.         }  

48.     }  

50.     public final void request() {  

51.         try {  

52.             super.h.invoke(this, m3, null);  

53.             return;  

54.         } catch (Error e) {  

55.         } catch (Throwable throwable) {  

56.             throw new UndeclaredThrowableException(throwable);  

57.         }  

58.     }  

60.     @Override  

61.     public final String toString() {  

62.         try {  

63.             return (String) super.h.invoke(this, m2, null);  

64.         } catch (Throwable throwable) {  

65.             throw new UndeclaredThrowableException(throwable);  

66.         }  

67.     }  

68. }  

Then cast the obtained $Proxy0 instance into Subject and assign the reference to subject. When the subject.request() method is executed, the request() method in the $Proxy0 class is called, and then the invoke() method of h in the parent class Proxy is called. That is, InvocationHandler.invoke().

PS: 1. One thing that needs to be explained is that the getProxyClass method in the Proxy class returns the Proxy Class class. The reason why I explain this is because I made a low-level mistake at the beginning, thinking that what was returned was the "Class of the proxied class" - -! It is recommended to take a look at the source code of getProxyClass, it is very long =. =
2. It can be seen from the source code of $Proxy0 that the dynamic proxy class not only proxies the methods in the explicitly defined interface, but also proxies the inherited equals() and hashcode() in the java root class Object. , toString(), and only these three methods.

Q: Until now, there is still a question. The first parameter in the invoke method is an instance of Proxy (to be precise, the instance of $Proxy0 is ultimately used), but what is its use? In other words, how does the program show its effect?
A: From my current level, this proxy parameter has no effect. In the entire dynamic proxy mechanism, the proxy parameter of the invoke method in InvocationHandler is not used. The parameter passed in is actually an instance of the proxy class. I think it may be to allow programmers to use reflection in the invoke method to obtain some information about the proxy class.

The above is the detailed content of Tutorial on implementing dynamic proxy in Java. For more information, please follow other related articles on the PHP Chinese website!