A detailed explanation of dynamic agent mechanism in Java

When we learn spring, we know that spring has two main ideas, one is the IOC, the other is AOP, and for IOC, dependency injection doesn't have to be said, and for spring's core AOP, we not only need to know how to satisfy our function through AOP, What we need to learn is how the underlying is a principle, and the principle of AOP is the dynamic agent mechanism of Java, so this essay is a review of the dynamic mechanism of java.

In the dynamic agent mechanism of Java, there are two important classes or interfaces, one is Invocationhandler (Interface), the other is proxy (class), and this class and interface is necessary to implement our dynamic proxy. First, let's take a look at how the Java API Help document describes these two classes:

Invocationhandler:

Invocationhandler is the interface implemented by the invocation handler of a proxy instance. Each proxy instance have an associated invocation handler. When a method was invoked on a proxy instance, the method invocation was encoded and dispatched to the Invoke method of its Invocation handler.

Each dynamic proxy class must implement the Invocationhandler interface, and each instance of the proxy class is associated with a handler, and when we call a method through the proxy object, The invocation of this method is forwarded to the Invoke method of this interface by Invocationhandler. Let's take a look at the only way to invocationhandler this interface. The Invoke method:

Throws Throwable

We see that this method takes three parameters altogether, so what do these three parameters represent?

Throws throwableproxy: refers to the real object method we represent  :  Refers to the method object that we are going to call the real object.  args: refers to the arguments that are accepted when a method of a real object is called    

If not very clear, wait for an example to explain these parameters in more depth.

Next we look at the proxy class:

The role of the proxy class is to dynamically create a class of proxy objects, which provides a number of methods, but the most we use is newproxyinstance this method:

Newproxyinstance (ClassLoader loader, class<?>[] interfaces,  invocationhandler h)  throws IllegalArgumentException

For the specified interfaces This dispatches method invocations to the specified invocation handler.

The function of this method is to get a dynamic proxy object, which receives three parameters, and we take a look at what these three parameters mean:

Throws illegalargumentexceptionloader: A ClassLoader object that defines which ClassLoader object to load on the generated proxy object   Interfaces: An array of interface objects, which means that I'm going to provide a set of interfaces to the object I need to proxy, and if I provide a set of interfaces to it, then this proxy object declares that the interface is implemented (polymorphic) , so I can invoke the method in this set of interfaces  H: a Invocationhandler object, which means that when I call the method in this dynamic proxy object, To which Invocationhandler object will be associated.    

Well, after the introduction of these two interfaces (classes), let's look at an example of what our dynamic proxy pattern looks like:

First we define an interface of type subject and declare two methods for it:

Interface subject{    voidvoid hello (String str);   

Next, define a class to implement this interface, this class is our real object, Realsubject class:

Implements subject{    @Override    void rent () {System.out.println ("I want to rent my house"Void Hello (String str) {System.out.println ("Hello:" + str);}}     

Next, we are going to define a dynamic proxy class, the previous one, each dynamic proxy class must implement Invocationhandler this interface, so we this dynamic proxy class is no exception:

PublicClass DynamicproxyImplementsinvocationhandler{//This is the real object we're going to be acting for.PrivateObject subject;//Constructs a method, assigns the initial value to the real object which we want to proxyPublicDynamicproxy (Object subject) {This.subject =Subject } @Overridepublic object Invoke (Object object, method, Object[] args) throws Throwable {//); System.out.println ("Method:" + method); // When the proxy object invokes the method of the real object, It automatically jumps to the Invoke method of the handler object associated with the proxy object to invoke  Method.invoke (subject, args); //); return null  

Finally, take a look at our client class:

PublicClassclient{PublicStaticvoidMain (string[] args) {//We want the real object of the agent Subject Realsubject =NewRealsubject ();// We're going to proxy which real object, we'll pass the object in, and finally we'll call its method through the real object Invocationhandler handler = new Dynamicproxy (realsubject); /* * To create our proxy object through the Newproxyinstance method of proxy, let's take a look at its three parameters * The first parameter Handler.getclass (). getClassLoader (), here we use the ClassLoader object of the handler class to load our proxy object * second parameter Realsubject.getclass () . Getinterfaces (), the interface that we provide for the proxy object is the interface that the real object implements, which means that I am going to proxy the real object, so that I can invoke the method in this set of interfaces * The third parameter handler, here we associate this proxy object to the top of the Invocationhandler on this object */ Subject Subject = (Subject) proxy.newproxyinstance (Handler.getclass (). getClassLoader (), Realsubject. GetClass (). Getinterfaces (), handler); System.out.println (Subject.getclass (). GetName ()); Subject.rent (); Subject.hello ("World"         

Let's take a look at the console output:

$Proxy 0
Before rent Housemethod:void   com.xiaoluo.dynamicproxy.Subject.rent ()I want to rent my houseafter Rent House
Before rent Housemethod:void   com.xiaoluo.dynamicproxy.Subject.hello (java.lang.String) Hello:worldafter Rent House

Let's start by looking at $Proxy 0 this thing we see, this thing is made by System.out.println (Subject.getclass (). GetName ()); This statement is printed, so why is the class name of the proxy object that we return?

Subject Subject = (Subject) proxy.newproxyinstance (Handler.getclass (). getClassLoader (), Realsubject                . GetClass (). Getinterfaces (), handler);

Maybe I thought the returned proxy object would be an object of type subject or a Invocationhandler object, but the result is not, first we explain why we can convert it to an object of type subject? The reason is that in newproxyinstance the second parameter of this method, we give this proxy object a set of what interface, then I this proxy object will implement this set of interfaces, this Of course we can convert this proxy object coercion type to any of these sets of interfaces, because the interface here is the subject type, so it can be converted to the subject type.

at the same time we must remember that the proxy object created through Proxy.newproxyinstance is an object that is dynamically generated when the JVM is running, not our invocationhandler type, nor the type of interface we define, but the A row is an object that is dynamically generated, and is named in this form, starting with $, proxy is medium, and the last number represents the label of the object .

Then we'll take a look at these two sentences.

Subject.rent ();
Subject.hello ("World");

Here is a proxy object to invoke the implementation of the interface method, this time the program will jump to the proxy object associated with the handler invoke method to execute, and our handler object has accepted a realsubject type of parameters, This is the real object that I want to proxy, so I'm going to call the Invoke method in handler to do it:

Public object Invoke (Object object, method method, object[] args) throws Throwable {// We can add some of our own operation System.out.println ("before Rent House"  method); // When the proxy object invokes the method of the real object, It automatically jumps to the Invoke method of the handler object associated with the proxy object to invoke  Method.invoke (subject, args); //); return null  

We see that we can add some of our own operations before and after the method that actually invokes the real object through the proxy object, and we see that we have a method object like this:

void com.xiaoluo.dynamicproxy.Subject.rent ()void Com.xiaoluo.dynamicproxy.Subject.hello (java.lang.String )

Exactly the two methods in our subject interface, which proves that when I invoke a method through a proxy object, it is actually called by the Invoke method of the handler object to which the delegate is associated, not by itself, but by proxy.

This is our Java Dynamic Agent mechanism.

This essay explains in detail the dynamic agent mechanism in Java, the knowledge point is very important, including our spring AOP is implemented through the mechanism of dynamic proxy, so we must understand the mechanism of dynamic agent.

A detailed explanation of dynamic agent mechanism in Java