Tutorial on implementing dynamic proxy in Java-javaTutorial-php.cn

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

Tutorial on implementing dynamic proxy in Java

{

method.invoke(obj, args);
return
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 {

void request();

}

Java code

//Real role: Implemented the Subject’s request() method
public class RealSubject implements Subject{
public void request(){
System.out.println("From real subject.");
}
}

Java code

//Implemented InvocationHandler

public
implements In vocationHandler
{
private Object obj;
}
{
this.obj = ob j;
}
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(
return
null;
}
)
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
7. new DynamicSubject(rs);
  Class> cls=rs.getClass();
9. //The following is a one-time use Generate proxy
11. Interfaces(), ds);
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();
21. System.out.print(
22. " The methods in subject are: "); ().getDeclaredMethods( );
26. "n"+
  "subject’s parent class is: "+subject.getClass().getSuperclass());
28. System. out.print(
  "n"+
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,

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.
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();
}
/*
* Look up or generate the designated proxy class.
*/
Class cl = getProxyClass(loader, interfaces);
/*
* Invoke its constructor with the designated invocation handler.
*/
try {
/*
* Proxy源码开始有这样的定义：
* private final static Class[] constructorParams = { InvocationHandler.class };
* cons即是形参为InvocationHandler类型的构造方法
*/
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:

Java code

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

public final class $Proxy0 extends Proxy implements Subject {
private static Method m1;
private static Method m0;
private static Method m3;
private static Method m2;
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals",
new Class[] { Class.forName("java.lang.Object") });
m0 = Class.forName("java.lang.Object").getMethod("hashCode",
new Class[0]);
m3 = Class.forName("***.RealSubject").getMethod("request",
new Class[0]);
m2 = Class.forName("java.lang.Object").getMethod("toString",
new Class[0]);
} catch (NoSuchMethodException nosuchmethodexception) {
throw new NoSuchMethodError(nosuchmethodexception.getMessage());
} catch (ClassNotFoundException classnotfoundexception) {
throw new NoClassDefFoundError(classnotfoundexception.getMessage());
}
} //static
public $Proxy0(InvocationHandler invocationhandler) {
super(invocationhandler);
}
@Override
public final boolean equals(Object obj) {
try {
return ((Boolean) super.h.invoke(this, m1, new Object[] { obj })) .booleanValue();
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
@Override
public final int hashCode() {
try {
return ((Integer) super.h.invoke(this, m0, null)).intValue();
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
public final void request() {
try {
super.h.invoke(this, m3, null);
return;
} catch (Error e) {
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
@Override
public final String toString() {
try {
return (String) super.h.invoke(this, m2, null);
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
}

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!