Shulou(Shulou.com)06/01 Report--

This article mainly introduces what is the dynamic agent in the development of big data, which has a certain reference value. Interested friends can refer to it. I hope you will gain a lot after reading this article. Let the editor take you to know it.

I. the significance of dynamic agent

First of all, it is clear that dynamic proxies are used to generate proxy objects. We know that in the traditional proxy model, we usually define a proxy class first, which needs to hold the target object (also called the proxied object, I think). Suppose we have 1000 different target objects (these 1000 objects are not the same class), then we need to define 1000 proxy classes in advance, which we cannot tolerate. As a result, a dynamic proxy appears, which essentially generates a proxy object that looks the same as the target object, and then when we call the method of the proxy object, in fact, it calls the corresponding method of the target object with the same name in his method.

Second, the core idea of dynamic agent design.

In fact, do not think how noble of these designs, if I am the author of dynamic proxy design, from the meaning of dynamic proxy, we know that we are going to do everything we can to generate a proxy object from the target object. then let the method call of the proxy object act on the method call of the target object. Yes, the core idea of dynamic agent is that simple. For example, the target class Person,Person has a method called purchase (), which is used for shopping. We expect the purchase () method to have a proxy class to handle, such as recording what is purchased before shopping. We know that before using a class, we need to create an object, and we tamper with it right where it is created. So you've seen the way JDK dynamically Proxy.newInstance (), and you've seen Spring's Enhancer.create (). Personally, I like the elegance, cleanliness and neatness of cglib. Complain that JDK's InvocationHandler looks like a disgusting middleman. The following is a schematic diagram of JDK dynamic agent UML

Third, JDK dynamic agent

1, principle

Before we can learn about dynamic proxies, we need to understand the Java bytecode. If you are not familiar with Java bytecode, you can understand that you can dynamically generate a .java file through the code and then compile it into a class file and load it into memory. The next thing the dynamic agent in JDK does is how to generate a ProxyPerson bytecode file. In fact, when generating bytecode, it holds the InvocationHandler object and then implements the interface corresponding to ProxyPerson. Of all the implementation methods of the interface, only one thing is done is to call the invocationHandler.invoke () method. At the code level, it looks like this:

Public class ProxyPerson implements Purchase {

Static {method of Method method;// interface Object [] args;// interface parameters}

InvocationHandler handler;public ProxyPerson (InvocationHandler handler) {this.handler = handler;}

@ overrdepublic purchage () {this,handler.invoke (this,method,args);}

}

So when was the above code generated?

Proxy.newProxyInstance ()

When we call this method above JDK, the underlying layer generates a ProxyPerson bytecode. Now that we know the principle, let's answer why JDK dynamic agents can only be based on interface proxies and not on classes.

1) due to the way bytecode is generated, JDK itself is a proxy transfer based on InvocationHandler. We see that there is no semi-hairball relationship between the method call of the proxy object and the call to the target object, and the call to the target object is done by ourselves in the invoke method.

2), methods with the same name can only be called by objects with successful upward transformation. For example, there are two classes, Boy and Girl, which implement the interface Purchase. If we first get the purchase () method method of Girl, we will report an error through method.invoke (new Boy ()). But if we get the purchase () method method of the Purchase interface, we are ok through method.invoke (new Boy ()), because new Boy () can be transformed up to Purchase.

2, application

For example, both traditional MVC model and DDD model can not be separated from Service. We know that transaction control can be turned on with @ Transactional in the Service method. So how is this annotated transaction implemented? In fact, when the project starts, we will have a post-processor of Bean to check all Bean once it finds that there are transaction comments on the Bean method, it creates a proxy object through Proxy.newInstance (), returns the proxy object for injection, and discards the object that should have been injected into the container. So it looks like the Service we got through the container is already a proxy object. Just open the programmatic transaction before calling the target object.

4. Cglib dynamic agent

With the above knowledge, we need to have the awareness that cglib is only tampering with the generated bytecode. The following intuitive experience and the generation process

Public static void main (final String [] args) {Enhancer enhancer = new Enhancer (); enhancer.setSuperclass (Boy.class); enhancer.setCallback (new MethodInterceptor () {@ Override public Object intercept (Object o, Method method, Object [] objects, MethodProxy methodProxy) throws Throwable {System.out.println ("proxy method" + method.getName ()) If (method.getAnnotation (Transactional.class)! = null) {System.out.println (method.getName () + "Discovery comments");} return methodProxy.invokeSuper (Olympus ARGs);}}); Boy proxy = (Boy) enhancer.create (); proxy.test () } public static class Boy {public void run () {System.out.println ("run...");} @ Transactional public void walk () {System.out.println ("walk...");} @ Transactional public void test () {System.out.println ("test..."); walk () }}

You can see that cglib generates bytecode dynamically based on inheritance. It simply calls the injected methodIntercptor.interceptor () method in the implementation of the subclass. The details of bytecode implementation are not delved into here. Let's explore here why cglib can validate other transactions with transaction annotations in the same service method. Because the dynamic proxy based on inheritance, the essentially calling proxy object can be transformed upward into the original target object, so it can directly adjust the target object method through the proxy object.

Thank you for reading this article carefully. I hope the article "what is the dynamic Agent in the Development of big data" shared by the editor will be helpful to everyone. At the same time, I also hope that you will support and pay attention to the industry information channel. More related knowledge is waiting for you to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.