Java Dynamic Agent

Proxy mode : The common Java design pattern, characterized by the same interface between the proxy class and the delegate class, the proxy class is responsible for preprocessing the information, filtering information, transferring the message to the delegate class and processing the message afterwards. There is usually an association between a proxy class and a delegate class, and the object of the proxy class does not actually implement the service, but rather the method that invokes the object of the delegate class.

By the time the agent was created, the proxy classes were divided into:

Static proxy: The source code is generated automatically by the programmer or a specific tool, and then compiled. The. class file for the proxy classes already exists before the program runs.

Dynamic Agent: When the program is running, it is created dynamically using the reflection mechanism.

First look at the static proxy:

1, Count.java

　　Package Net.battier.dao;

1. Public interface Count {
2. View account Methods
3. Public void Querycount ();
4. Modify Account Method
5. Public void Updatecount ();
6. }

2, Countimpl.java

2. Package Net.battier.dao.impl;
6. Import Net.battier.dao.Count;
10. /**
12. * Delegate Class (Contains business logic)
14. *
16. * @author Administrator
18. *
20. */
22. Public class Countimpl implements Count {
26. @Override
28. public void Querycount () {
30. System.out.println ("View account Method ...");
34. }
38. @Override
40. public void Updatecount () {
42. System.out.println ("Modify Account Method ...");
46. }
50. }
54. , Countproxy.java
56. Package Net.battier.dao.impl;
60. Import Net.battier.dao.Count;
64. /**
66. * This is a proxy class (Enhanced Countimpl implementation Class)
68. *
70. * @author Administrator
72. *
74. */
76. Public class Countproxy implements Count {
78. private Countimpl Countimpl;
82. /** 
84. * Override the default constructor
86. *
88. * @param Countimpl
90. */
92. Public Countproxy (Countimpl countimpl) {
94. This.countimpl = Countimpl;
96. }
100. @Override
102. public void Querycount () {
104. System.out.println ("before transaction processing");
106. //method of invoking the delegate class;
108. Countimpl.querycount ();
110. System.out.println ("after transaction processing");
112. }
116. @Override
118. public void Updatecount () {
120. System.out.println ("before transaction processing");
122. //method of invoking the delegate class;
124. Countimpl.updatecount ();
126. System.out.println ("after transaction processing");
130. }
134. }

3, Testcount.java

2. Package net.battier.test;
6. Import Net.battier.dao.impl.CountImpl;
8. Import Net.battier.dao.impl.CountProxy;
12. /**
14. * Test Count class
16. *
18. * @author Administrator
20. *
22. */
24. Public class Testcount {
26. public static void Main (string[] args) {
28. Countimpl Countimpl = new Countimpl ();
30. Countproxy countproxy = new Countproxy (Countimpl);
32. Countproxy.updatecount ();
34. Countproxy.querycount ();
38. }
40. }

As can be seen from the above, the disadvantage of static proxy is that each proxy class can only serve an interface, so that the program development, will inevitably generate too many agents, duplicate code appears. The best way to solve this problem is to complete the proxy function through a proxy class, which must be done using dynamic proxy.

Then look at the dynamic agent:

The JDK dynamic agent contains a class and an interface:
Invocationhandler Interface:
Public interface Invocationhandler {
public object Invoke (Object Proxy,method method,object[] args) throws Throwable;
}
Parameter description:
Object proxy: Refers to the objects being proxied.
Method: Methods to invoke
object[] args: Parameters required for method invocation

The subclass of the Invocationhandler interface can be imagined as a proxy's final operation class, replacing the Proxysubject.

Proxy class:
The proxy class is an action class that specifically completes the proxy, which can be used to dynamically generate an implementation class for one or more interfaces, which provides the following operations:
public static Object newproxyinstance (ClassLoader loader, class<?>[] interfaces,
Invocationhandler h)
Throws IllegalArgumentException
Parameter description:
ClassLoader Loader: Class loader
Class<?>[] Interfaces: Get all the interfaces
Invocationhandler h: Get subclass instance of Invocationhandler interface

1.Person class

Package cn.itcast.proxy;

Public interface Person {

public abstract string Sing (string name);

Public abstract string Dance (string name);

}

2.Liming class

Package cn.itcast.proxy;

public class Liming implements person {

@Override
public string Sing (string name) {
System.out.println ("Li Ming Sings" +name+ "Song!! ");
Return "Thank you";
}


@Override
public string Dance (string name) {
System.out.println ("Li Ming jumps" +name+ "Dance!! ");
Return "Kiss";
}
}

3. Dynamic proxy class

Package cn.itcast.proxy;

Import Java.lang.reflect.InvocationHandler;
Import Java.lang.reflect.Method;
Import Java.lang.reflect.Proxy;

public class Limingproxy {
Private person liming=new liming ();

Public Person Createproxy () {
return (person) proxy.newproxyinstance (LimingProxy.class.getClassLoader (), Liming.getclass (). Getinterfaces (), New Invocationhandler () {

@Override
/**
* Proxy: Pass in the agent object itself
* Method: Represents the methods currently called
* Args: Parameters of the Calling method
*/
public object invoke (object proxy, Method method, object[] args)
Throws Throwable {
String Methosname=method.getname ();
if (Methosname.equals ("Sing")) {
System.out.println ("Get 10,000 bucks!! ");
Return Method.invoke (Liming,args);
}else if (Methosname.equals ("Dance")) {
System.out.println ("Get 20,000 bucks!! ");
Return Method.invoke (liming, args);
}else{
System.out.println ("Li Ming does not support this feature!! ");
}
return null;
}
});
}
}

However, the dynamic proxy of the JDK relies on the interface, and if some classes do not implement the interface, then the JDK proxy cannot be used, which will use the Cglib dynamic proxy.

Cglib Dynamic Agent
The dynamic agent mechanism of JDK can only implement the class of the interface, and the class that cannot implement the interface cannot implement the dynamic proxy of the JDK, the cglib is to implement the proxy for the class, his principle is to generate a subclass for the target class, and overwrite the method implementation enhancement, but because inherit is adopted, Therefore, the final decorated class cannot be proxied.
Example

1, Bookfacadecglib.java

1. Package Net.battier.dao;
3. Public interface Bookfacade {
4. public void Addbook ();
5. }

2, Bookcadeimpl1.java

1. PACKAGE&NBSP;NET.BATTIER.DAO.IMPL;&NBSP;&NBSP;
2.   
3. /** 
4.  *   This is an implementation class   that does not implement an interface;
5.  *  
6.  *  @author  student 
7.  *  
8.  */  
9. public < span class= "keyword" >class bookfacadeimpl1 {  
10.      public void addbook ()  {  
11.         system.out.println (
12.     }  
13. }  

3, Bookfacadeproxy.java

2. Package net.battier.proxy;
6. Import Java.lang.reflect.Method;
10. Import Net.sf.cglib.proxy.Enhancer;
12. Import Net.sf.cglib.proxy.MethodInterceptor;
14. Import Net.sf.cglib.proxy.MethodProxy;
18. /**
20. * Use Cglib dynamic agent
22. *
24. * @author Student
26. *
28. */
30. Public class Bookfacadecglib implements Methodinterceptor {
32. private Object target;
36. /** 
38. * Create proxy object
40. *
42. * @param target
44. * @return
46. */
48. Public Object GetInstance (object target) {
50. this.target = target;
52. Enhancer enhancer = new enhancer ();
54. Enhancer.setsuperclass (this.target.getClass ());
56. //callback method
58. Enhancer.setcallback (this);
60. //Create proxy object
62. return enhancer.create ();
64. }
68. @Override
70. //callback method
72. Public Object Intercept (Object obj, Method method, object[] args,
74. Methodproxy proxy) throws Throwable {
76. System.out.println ("things start");
78. Proxy.invokesuper (obj, args);
80. System.out.println ("End of Thing");
82. return null;
88. }
92. }

4, Testcglib.java

2. Package net.battier.test;
6. Import NET.BATTIER.DAO.IMPL.BOOKFACADEIMPL1;
8. Import Net.battier.proxy.BookFacadeCglib;
12. Public class Testcglib {
16. public static void Main (string[] args) {
18. Bookfacadecglib cglib=New Bookfacadecglib ();
20. BOOKFACADEIMPL1 bookcglib= (BOOKFACADEIMPL1) cglib.getinstance (new BookFacadeImpl1 ());
22. Bookcglib.addbook ();
24. }
26. }

Java Dynamic Agent