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

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.

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 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

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!