A detailed explanation of dynamic agent mechanism in Java

Transferred from: http://www.cnblogs.com/xiaoluo501395377/p/3383130.html

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

Object Invoke (Object proxy, Method method, object[] args) throws Throwable

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

Object Invoke (Object proxy, method, object[] args) throws Throwableproxy: refers to the real object we represent. method: refers to the method object that we are going to call the real object of a way. 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:

public static Object newproxyinstance (ClassLoader loader, class<?>[] interfaces,  Invocationhandler h)  Throws IllegalArgumentException

Returns an instance of a proxy class for the specified interfaces, dispatches method invocations to the specified INVO cation 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:

public static Object newproxyinstance (ClassLoader loader, class<?>[] interfaces, Invocationhandler h) 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 that represents the Invocationhandler object to which the dynamic proxy object will be associated when it calls the method. 

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:

Public interface subject{public    void rent ();        public void Hello (String str);

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

public class Realsubject implements subject{    @Override public    void rent ()    {        System.out.println ("I Want to rent my house ");        @Override public    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:

public class Dynamicproxy implements invocationhandler{    //This is what we want to proxy the real object of    private objects subject;    constructs the method, assigns the real object which we want the proxy to assign the initial value public    dynamicproxy (object subject)    {        this.subject = subject;    }        @Override 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") before acting on the real object.                System.out.println ("Method:" + method);    when a contemporary object invokes a method of a real object, it automatically jumps to the proxy object's associated handler object's Invoke method to invoke        Method.invoke (subject, args);                We can also add some of our own operation        System.out.println ("After the Rent house") when acting on the real object.                return null;}    }

Finally, take a look at our client class:

public class client{public    static void Main (string[] args)    {        //    The real object we want to proxy        Subject realsubject = New Realsubject ();    we want to proxy which real object, the object is passed in, and finally through the real object to invoke its method of        Invocationhandler handler = new Dynamicproxy (realsubject);        /*         * Using Proxy's Newproxyinstance method to create our proxy object, 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         * The 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, where 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: publicabstract void  com.xiaoluo.dynamicproxy.Subject.rent ()I want to rent my Houseafter Rent House
Before rent Housemethod: publicabstract 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 to provide a set of what interface, then I this proxy object will implement this set of interfaces, this time we can of course, this proxy object coercion type into any of the set 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, it is not our invocationhandler type, nor is it the type of the set of interfaces we define. Instead, the run is a dynamically generated object, and the naming method is 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") before acting on the real object.                System.out.println ("Method:" + method);    when a contemporary object invokes a method of a real object, it automatically jumps to the proxy object's associated handler object's Invoke method to invoke        Method.invoke (subject, args);                We can also add some of our own operation        System.out.println ("After the Rent house") when acting on the real object.                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:

public abstract void Com.xiaoluo.dynamicproxy.Subject.rent () public abstract 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