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

This article mainly introduces what the agent model in Java means, has a certain reference value, interested friends can refer to, I hope you can learn a lot after reading this article, the following let the editor take you to understand it.

I. Agent mode

What is the agent mode?

Let's start with a common example of life: if you want to buy a ticket, you don't have to go to the station to buy it; instead, you can go to a sales agency, which is a simple agency model.

The main solution: the problem caused by direct access to the object, for example, the object to be accessed is on the remote machine. In object-oriented systems, direct access to some objects will bring a lot of trouble to consumers or system structures for some reasons (such as high overhead in object creation, or some operations require security control, or out-of-process access). We can add an access layer to this object when we access this object.

Summary: when we access the instance object, we access it through the proxy object, which is more flexible and can also add some additional operations.

Second, static agent

As the name implies, static, written by the programmer, the program interface, proxy class and proxied class have been written when compiling! It has been generated before the program runs!

Let's take a simple example:

Design the common interface Person:

Public interface Person {public void handinWork ();}

Student:

Public class Student implements Person {private String name; public Student (String name) {this.name=name;} public void setName (String name) {this.name=name;} public void handinWork () {System.out.println (name+ "submit Job");}}

Proxy class StudentProxy:

Public class StudentProxy implements Person {/ / proxy who Student student; / / prevent duplicate names, make sure that only the object public StudentProxy (Student student) {if (student.getClass ()) = Student.class) {this.student = (Student) student is the proxy. }} public void handinWork () {/ / when handing in the homework, the agent (monitor) wants to do something for the student System.out.println ("the teacher copied the homework"); student.handinWork ();}}

Test:

Public class StaticProxy {public static void main (String [] args) {/ / create two objects, proxy and delegated Student student = new Student ("Zhang San"); StudentProxy monitor = new StudentProxy (student); / / Agent class to hand in homework! Monitor.handinWork ();}}

It can be found that the essence of the program is for students to hand in homework, but it is realized through an intermediate layer monitor (monitor), and then this agent layer can also add some other operational functions before or after submitting the homework!

Third, dynamic agent

Static proxies are generated before the program runs, and it is obvious that dynamic proxies add a proxy layer during the program run to achieve the effect. Agent classes are generated dynamically!

There are two classes you need to know: Proxy proxy and InvocationHandler

Proxy: proxy class, dynamically generated when in use

InvocationHandler: mainly executes methods that require proxies, using invoke to execute

For example: easy to understand, with the above example we will transform it into a dynamic!

The first step is to create a class that implements the InvocationHandler interface and uses it to build proxy classes and proxy methods:

Public class ProxyInvocation implements InvocationHandler {/ / proxied interface, the real object private Person person; / / generated proxy class public void setPerson (Person person) {this.person = person } / / create a proxy object through the newProxyInstance method of the Proxy class. Let's take a look at the parameter / / * the first parameter in the method: people.getClass (). GetClassLoader (), use the classloader object of the handler object to load our proxy object / / * the second parameter: people.getClass (). GetInterfaces (), where the interface provided for the proxy class is the interface implemented by the real object In this way, the proxy object can call all the methods in the interface like a real object. The third parameter: handler, we associate the proxy object with public Object getProxy () {return Proxy.newProxyInstance (this.getClass (). GetClassLoader (), person.getClass (). GetInterfaces (), this) on the above InvocationHandler object. } / / process the proxy instance and return the result public Object invoke (Object proxy, Method method, Object [] args) throws Throwable {Object result = method.invoke (person, args); return result;}}

With reference to the static proxy, we need a proxy object, but the proxy object in the static proxy is created manually, so in the dynamic proxy, we use the newProxyInstance method of jdk's own proxy class Proxy to dynamically generate a proxy class, which can be dynamically changed according to the parameters we pass.

Test:

/ / the real role student Student student = new Student ("Zhang San"); / / get the inherited class of InvocationHandler ProxyInvocation pih = new ProxyInvocation (); / / get the interface pih.setPerson (student) of the proxy; / / dynamically generate the proxy proxy class Person proxy = (Person) pih.getProxy (); / / the proxy class executes method proxy.handinWork ()

Improved to tool class: the interface part will be replaced by parameters.

Private Object target; / / generated proxy class public void setPerson (Object target) {this.target= target } / / create a proxy object through the newProxyInstance method of the Proxy class. Let's take a look at the parameter / / * the first parameter in the method: people.getClass (). GetClassLoader (), use the classloader object of the handler object to load our proxy object / / * the second parameter: people.getClass (). GetInterfaces (), where the interface provided for the proxy class is the interface implemented by the real object In this way, the proxy object can call all the methods in the interface like a real object. The third parameter: handler, we associate the proxy object with public Object getProxy () {return Proxy.newProxyInstance (this.getClass (). GetClassLoader (), target.getClass (). GetInterfaces (), this) on the above InvocationHandler object. } / / process the proxy instance and return the result public Object invoke (Object proxy, Method method, Object [] args) throws Throwable {Object result = method.invoke (person, args); return result;}

Just change the interface type and parameters! The use of proxy mode on Spring will be added later.

Thank you for reading this article carefully. I hope the article "what is the meaning of agent mode in Java" shared by the editor will be helpful to everyone? at the same time, I also hope that you will support us 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.