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

This article mainly explains "what is the static agent design pattern". Interested friends may wish to take a look. The method introduced in this paper is simple, fast and practical. Let's let the editor take you to learn "what is the static agent design pattern"?

Static agent design pattern

Agent design pattern is the most widely used design pattern in program development. the core of agent design pattern is that there are real business implementation class and agent business implementation class, and the agent class has to complete more processing operations than the real business.

The disadvantages of traditional Agent Design pattern

According to the design requirements, all agent design patterns must be interface-based design, that is to say, the composition of the core interface needs to be defined first.

Example: simulate an agent operation structure for sending a message (traditional agent design)

Public class JavaAPIDemo {public static void main (String [] args) throws Exception {IMessage message=new MessageProxy (new MessageReal ()); message.send ();}} interface IMessage {/ / traditional agent design must have interface public void send (); / / Business method} class MessageReal implements IMessage {@ Overridepublic void send () {System.out.println ("[send message] www.mldn.cn") }} class MessageProxy implements IMessage {/ / proxy class private IMessage message; / / proxy object, must be the business interface instance public MessageProxy (IMessage message) {this.message=message;} @ Overridepublic void send () {if (this.connect ()) {this.message.send (); / / message sending processing this.close () }} public boolean connect () {System.out.println ("[message broker] connects to the message sending channel.") ; return true;} public void close () {System.out.println ("[message Agent] closes the message channel.") ;}}

Execution result:

The above operation code is the most standard agent design, but if we think about it further, we will find that there is a coupling problem between the client interface and the specific subclass, so in terms of actual development, it is best to introduce the factory design pattern to obtain the proxy object.

The above agent design pattern is static proxy design, which involves the following characteristics: a proxy class serves only one interface, and if there are now 3000 business interfaces, then following this approach means that 3000 proxy classes need to be written, and these proxy classes operate in a similar manner.

So the problem that needs to be solved now is how to make a proxy class meet all the operational requirements of the business interface.

Dynamic agent design pattern

Through the defects of the static proxy design pattern, it can be found that the best way is to provide unified proxy processing operations for all functionally consistent business operation interfaces, which can be achieved through the dynamic proxy mechanism. however, the following problems need to be considered in the dynamic proxy mechanism:

Both dynamic and static proxy classes must receive real business implementation subclass objects

Because the dynamic proxy class is no longer bundled with a specific interface, it should be able to obtain the interface information of the class dynamically.

Dynamic agent design pattern

In the operation of dynamic proxy implementation, the first thing to pay attention to is an InvocationHandler interface that specifies the execution of the proxy method.

Public interface InvocationHandler {/ * proxy method call In the end, the methods executed in the proxy body class are all objects to be proxied by this method * @ param proxy * @ param method interface method name * @ param args passed parameter * @ return return value of a method * @ throws Throwable method call error continues to throw * / public Object invoke (Object proxy, Method method, Object [] args) throws Throwable up }

When designing a dynamic agent, the creation of dynamic objects is done by the JVM underlying layer, which mainly relies on the java.lang.reflect.Proxy program class, which provides only one core method:

Proxy object: public static Object newProxyInstance (ClassLoader loader, Class [] interfaces, InvocationHandler h)

ClassLoader loader: gets the ClassLoader of the current real principal class

Class [] interfaces: the proxy revolves around the interface, so be sure to get the interface information of the real principal class

InvocationHandler h: the method of proxy processing

Example: implementing a dynamic proxy mechanism

Import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;public class JavaAPIDemo {public static void main (String [] args) throws Exception {IMessage msg= (IMessage) new MLDNProxy (). Bind (new MessageReal ()); msg.send ();} class MLDNProxy implements InvocationHandler {private Object target / / Save real business objects / * bind real business objects to proxy business objects * @ param target real business objects * @ return Proxy generated proxy business objects * / public Object bind (Object target) {this.target = target;return Proxy.newProxyInstance (target.getClass (). GetClassLoader (), target.getClass (). GetInterfaces (), this) } public boolean connect () {System.out.println ("[message broker] connects to the message sending channel.") ; return true;} public void close () {System.out.println ("[message Agent] closes the message channel.") ;} @ Overridepublic Object invoke (Object pro, Method method, Object [] args) throws Throwable {System.out.println ("* [execution method:]" + method); Object returnData = null;if (this.connect ()) {returnData = method.invoke (this.target, args); this.close ();} return returnData;} interface IMessage {/ / traditional agent design must have interface void send () / / Business method} class MessageReal implements IMessage {@ Overridepublic void send () {System.out.println ("[send message] www.mldn.cn");}}

Execution result:

If we carefully observe the Proxy.newProxyInstance () method provided in the system, we will find that this method will use a large number of underlying mechanisms to dynamically create proxy objects. All proxy classes are operational functional classes that meet all relevant functional requirements, and they no longer represent specific interfaces, so we must rely on class loaders and interfaces for proxy object forgery.

At this point, I believe you have a deeper understanding of "what is a static agent design pattern". You might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow us, continue 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.