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
-
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: -
Java code
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 class RealSubject implements Subject{
-
public void request(){
System.out.println("From real subject.");
}
}
Java code
//Implemented InvocationHandler
-
public
class DynamicSubject - implements In vocationHandler
{
-
private Object obj; //This is the benefit of dynamic proxy. The encapsulated object is of Object type and accepts any type of object.
- }
-
public DynamicSubject(Object obj) - {
-
this.obj = ob j;
- }
-
// This method is not what we explicitly call -
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable
-
{
-
System.out.println( "before calling " + method);
- 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.
-
System.out.println(
"after calling " + method); - return
null;
}
)
public class Client {
public static void main(String [] args) throws Throwable{
Subject rs=//Specify the proxy here Class
- new DynamicSubject(rs);
Class> cls=rs.getClass();
- //The following is a one-time use Generate proxy
Interfaces(), ds);
- System.out.println(subject
instanceof Proxy);
//Here It can be seen that the subject's Class class is $Proxy0. This $Proxy0 class inherits Proxy and implements the Subject interface.
toString());
System.out.print(
-
-
System.out.print(
"n"+- " The methods in subject are: "); ().getDeclaredMethods( );
-
- "n"+
"subject’s parent class is: "+subject.getClass().getSuperclass());
-
System. out.print(
"n"+ "The interface implemented by subject is: ");
-
Class>[] interfaces=subject.getClass().getInterfaces();
-
}
System.out.println("nn"+"The operation result is: "); Subject.request();
-
) -
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
-
The running result is:
-
before calling public abstract void ***.Subject.request()
-
From real subject.
-
after calling public abstract void ***.Subject.re quest( )
- 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: - 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
public static Object newProxyInstance(ClassLoader loader,
Class>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
if (h == null) {
throw new NullPointerException();
}
Class cl = getProxyClass(loader, interfaces);
try {
Constructor cons = cl.getConstructor(constructorParams);
return (Object) cons.newInstance(new Object[] { h });
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString());
} catch (IllegalAccessException e) {
throw new InternalError(e.toString());
} catch (InstantiationException e) {
throw new InternalError(e.toString());
} catch (InvocationTargetException e) {
throw new InternalError(e.toString());
}
}
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:
-
class Proxy{
InvocationHandler h=null;
protected Proxy(InvocationHandler h) {
}
...
-
}
Let’s take a look at the source code of $Proxy0 which inherits Proxy:
Java code
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!
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
