Java dynamic proxy (design pattern) code explanation

Foundation: need to have the idea of object-oriented design, polymorphism and reflection;

With the emergence of Java dynamic proxy mechanism, Java developers do not need to write proxy classes manually. As long as they simply specify a set of interfaces and delegate class objects, they can dynamically obtain proxy classes. The proxy class is responsible for dispatching all method calls to the delegate object for reflection execution. In the process of dispatching execution, developers can also adjust the delegate object and its functions as needed. This is a very flexible and flexible proxy framework. By reading this article, readers will have a deeper understanding of Java dynamic proxy mechanism. Firstly, starting from the running mechanism and characteristics of Java Dynamic agent, this paper analyzes its code and deduces the internal implementation of dynamically generated classes.

Basic concept and classification of agent pattern

Proxy mode: provide a proxy for other objects to control access to this object. The proxy object acts as an intermediary. It can remove services or add additional services, or quote others: "the proxy class is responsible for preprocessing messages for the delegate class, filtering messages and forwarding messages, as well as subsequent processing after the messages are executed by the delegate class."

Application scenario of agent pattern in development

Remote proxy: provide LAN representative objects for objects in different geographical areas.

Virtual agent: delay objects that consume a lot of resources as needed and create them when they are really needed. For example, in a web page, text is displayed first and then pictures are displayed.

Protection agent: control the access rights of different users. For example, you can add, delete, modify, and query only after the customer is registered successfully.

Smart reference agent: provides additional services to the target agent.

Implementation of agent mode

Which is better to implement dynamic proxy using inheritance and aggregation!

Implement proxy by inheritance

Moveablecar2=newCar2(); car2. move();

Implement proxy by aggregation

Carcar=newCar(); Moveablem=newCar3(car); m.move();

summary

The inheritance method is not flexible enough. When the functions are superimposed, you can only expand the agent class; Using aggregation, agents can transfer to each other and combine agents flexibly;

JDK dynamic proxy and cglib dynamic proxy

JDK dynamic agent

Proxy implementation

What should I do if different objects want to implement proxy classes with the same function?

At this time, you can try to integrate it into the same agent class - dynamic agent: implement agents for different classes / methods;

The general process is as follows:

The Java dynamic proxy class is located in Java Lang.reflect package generally involves the following two classes:

(1) Interfaceinvocationhandler: only one method publicobjectinvoke (objectobj, methodmethod, object [] args) is defined in this interface

Obj: generally refers to the proxy class

Method: is the proxy method

Args is the parameter array of the method.

This abstract method is dynamically implemented in the proxy class.

(2) Proxy: this class is a dynamic proxy class

statixObjectnewProxyInstance(ClassLoaderloader,Class[]interfaces,InvocationHandlerh)

Return an instance of the proxy class. The returned proxy class can be used as the proxy class (you can use the methods declared by the proxy class in the interface);

Implementation example:

@Testing

&&Test results

Combing and summarizing

The dynamicproxy is such a class:

It is a class generated at runtime. This class needs to implement a set of interfaces. When using a dynamic proxy class, it must implement the invocationhandler interface.

General steps of JDK dynamic agent

1. Create a class that implements the interface invocationhandler. It must implement invoke()

2. Create the proxy class and interface

3. Call the static method of proxy to create a proxy class

newProxyInstance(ClassLoaderloader,InvocationHandlerh)

4. Call method through proxy

Implementation of cglib dynamic proxy

Proxy implementation

@Introduce cglib-node-2.2 Jar package

@Cglibproxy interception class implements interface methodinterceptor: override intercept interception method

@Proxied train

@Test class

##Test results:

Combing and summarizing

General steps for implementing dynamic proxy using cglibproxy

1. Create a class to implement the interface methodinterceptor and override the intercept method

2. Create proxied class

3. Call the custom method of the proxy class to get a proxy instance

4. Call the method to be executed by the proxy class through the proxy instance

Comparative summary

JDK dynamic agent

1. Only classes that implement interfaces can be proxied

2. Classes that do not implement interfaces cannot implement the dynamic proxy of JDK

Cglib dynamic proxy

1. Implement proxies for classes

2. Generate a subclass of the execution target class, and intercept the calls of all parent class methods through method interception technology.

Simulation agent generation steps

Idea:

Implementation function: return proxy object through proxy's newproxyinstance

1. Declare a source code (dynamically generate an agent)

2. Compile the source code (jdkcompiler API) to generate a new class (proxy class)

3. Load this class into memory to generate a new object (proxy object)

4. Return proxy object

Perfect dynamic agent implementation

First, we get the system compiler, get the file manager through the compiler, then get the file, then the compiler performs the compilation task. After compiling, we load the class file into the class loader, get the instance through the construction method, and then call newInstance () to receive an instance of an object.

(1) Get the compiler javacompilercompiler = toolprovider. Getsystemjavacompiler();

(2) File manager standardjavafilemanagerfilemgr = compiler.getstandardfilemanager (null, null, null);

(3) Get the file iterableinits = filemgr.getjavafileobjects (filename);

(4) Compilation task compilationtask t = compiler.gettask (null, filemgr, units);

(5) Load to memory

ClassLoadercl=ClassLoader. getSystemClassLoader();

Classc=cl.loadClass(”com.imooc.proxy.$Proxy0”);

(6) Construct the instance through the constructor of the proxy object

Constructorctr=c.getConstructor(infce);

ctr. newInstance(newCar());

-------

As mentioned above, the internal business logic is hard coded. How to realize the real dynamic agent and dynamically specify the business logic?

1. To create a transaction processor, first create an interface, that is, invocationhandler. In order to simulate JDK, the name of the interface is the same as that of the JDK transaction processor, and a method called invoke () is also written here to represent the business processing of a method of an object, Therefore, you need to pass in an object and its method as parameters of the invoke () method. Invoke (objectobj, methodmethod) uses java reflection as parameters. You need to introduce this package. This completes the invocationhandler interface.

2. Create a transaction processing implementation class, such as timerproxy, and implement the invocationhandler interface, so the structure becomes

The target object needs to be passed in. If there are no parameters, you can not write parameters. Create the construction method of the proxy object and initialize the target object

3. In the newproxyinstance () method of proxy class, in addition to taking the target class interface as a parameter, you also need to pass in the invocationhandler of the transaction processor, and then change the hard coded part of the instance creation object and replace it with the transaction processor method. The difficulty is string splicing.

summary

In our project, the proxy mode has its own practical significance. For example, if we want to call a class under a jar package, we can add some special business logic before and after calling this class. This method is also called AOP aspect oriented programming. (add additional functions without changing the original functions.)

The above is all about the detailed explanation of Java Dynamic agent (design pattern) code in this article. I hope it will be helpful to you. Interested friends can continue to refer to other relevant topics of this site. If there are deficiencies, please leave a message and point out them. Thank you for your support to this site!