"reprint" Java Dynamic Agent

Transferred from: http://blog.csdn.net/heyutao007/article/details/49738887

The interception capabilities of AOP are implemented by dynamic proxies in Java. To be blunt, it is to increase the tangent logic on the basis of the target class, to generate an enhanced target class (which is either before the target class function executes, or after the target class function executes, or when the target class function throws an exception). Different cut-in times correspond to different types of interceptor, such as Beforeadviseinterceptor,afteradviseinterceptor and throwsadviseinterceptor, etc.).

So how does the dynamic agent implement the advise to weave the facet logic into the target class method? Let's go through the details and implement the two dynamic proxies used in Aop.

The source code of AOP uses two kinds of dynamic agents to realize interception and cut-in function: JDK Dynamic agent and Cglib dynamic Agent. Both methods exist at the same time, each has its merits and demerits. the JDK Dynamic Agent is implemented by the reflection mechanism inside java, and the Cglib dynamic agent is implemented by Asm. In general, the reflection mechanism is more efficient in generating classes, and ASM is more efficient in the execution of the class after it is generated (you can cache the asm-generated classes to solve the asm-generated class-process inefficiencies). It is also important to note that the application premise of the JDK dynamic agent must be the target class based on the unified Interface. The JDK dynamic agent cannot be applied without the above Premise. It can be seen that the JDK dynamic agent has certain limitations, Cglib this Third-party class library implementation of dynamic proxy application more extensive, and more efficient Advantages.

1. Define interfaces and implementations [java]View Plaincopy print?

1. Package com.meituan.hyt.test3.service;
4. Public interface UserService {
5. public String getName (int id);
7. public Integer getage (int id);
8. }

[java]View Plaincopy print?

2. Package com.meituan.hyt.test3.service.impl;
6. Import com.meituan.hyt.test3.service.UserService;
12. Public class Userserviceimpl implements UserService {
14. @Override
16. public String getName (int Id) {
18. System.out.println ("------getName------");
20. return "Tom";
22. }
26. @Override
28. public Integer getage (int Id) {
30. System.out.println ("------getage------");
32. return 10;
34. }
36. }

2, JDK Dynamic Agent implementation [java]View Plaincopy print?

2. Package com.meituan.hyt.test3.jdk;
6. Import java.lang.reflect.InvocationHandler;
8. Import java.lang.reflect.Method;
14. Public class Myinvocationhandler implements Invocationhandler {
16. Private Object target;
20. Myinvocationhandler () {
22. Super ();
24. }
28. Myinvocationhandler (Object Target) {
30. Super ();
32. This.target = target;
34. }
38. @Override
40. public Object Invoke (object o, method method, object[] Args) throws throwable {
42. if ("getName". equals (method.getname ())) {
44. System.out.println ("++++++before" + method.getname () + "++++++");
46. Object result = Method.invoke (target, args);
48. System.out.println ("++++++after" + method.getname () + "++++++");
50. return result;
52. }else{
54. Object result = Method.invoke (target, args);
56. return result;
58. }
62. }
64. }

[java]View Plaincopy print?

2. Package com.meituan.hyt.test3.jdk;
6. Import com.meituan.hyt.test3.service.UserService;
8. Import com.meituan.hyt.test3.service.impl.UserServiceImpl;
12. Import java.lang.reflect.InvocationHandler;
14. Import java.lang.reflect.Proxy;
20. Public class Main1 {
22. public static void main (string[] Args) {
24. UserService userservice = new Userserviceimpl ();
26. Invocationhandler Invocationhandler = new Myinvocationhandler (userservice);
28. UserService userserviceproxy = (userservice) proxy.newproxyinstance (userservice.getclass (). getClassLoader (),
30. Userservice.getclass (). getinterfaces (), invocationhandler);
32. System.out.println (userserviceproxy.getname (1));
34. System.out.println (userserviceproxy.getage (1));
36. }
38. }

Run results

++++++before getname++++++
------getName------
++++++after getname++++++
Tom
------getage------
10

3, cglib Dynamic Agent implementation

Cglib is an excellent dynamic proxy framework, which uses ASM to dynamically generate the subclass of the proxy class in memory, using Cglib to implement dynamic proxy functionality even if the proxy class does not implement any Interfaces. Cglib is easy to use, and it runs much faster than the JDK proxy dynamic agent:

Core classes of Cglib:
net.sf.cglib.proxy.enhancer– Major Enhancement classes
net.sf.cglib.proxy.methodinterceptor– The Main method interception class, which is a sub-interface of the callback interface, requires the user to implement
The proxy class of the Java.lang.reflect.Method class of NET.SF.CGLIB.PROXY.METHODPROXY–JDK can easily implement the invocation of the source object method, such as Using:
Object o = Methodproxy.invokesuper (proxy, args);//although The first parameter is a proxy object, there is no problem with the dead loop.

The Net.sf.cglib.proxy.MethodInterceptor interface is the most common type of callback (callback), and it is often used by proxy-based AOP to implement a call to intercept (intercept) METHODS. This interface only defines a method
public object intercept (object object, java.lang.reflect.Method Method,
object[] args, methodproxy Proxy) throws throwable;

The first parameter is the proxy pair image, the second and third parameters are the parameters of the intercepted method and method, Respectively. The original method may be called by using the general reflection of the Java.lang.reflect.Method object, or by using the Net.sf.cglib.proxy.MethodProxy Object. Net.sf.cglib.proxy.MethodProxy is usually preferred because it is faster.

[java]View Plaincopy print?

2. Package com.meituan.hyt.test3.cglib;
8. Import net.sf.cglib.proxy.MethodInterceptor;
10. Import net.sf.cglib.proxy.MethodProxy;
14. Import java.lang.reflect.Method;
20. Public class Cglibproxy implements Methodinterceptor {
22. @Override
24. public Object Intercept (object o, method method, object[] args, methodproxy methodproxy) throws Throwable {
26. System.out.println ("++++++before" + methodproxy.getsupername () + "++++++");
28. System.out.println (method.getname ());
30. Object O1 = Methodproxy.invokesuper (o, args);
32. System.out.println ("++++++before" + methodproxy.getsupername () + "++++++");
34. return o1;
36. }
38. }

[java]View Plaincopy print?

2. Package com.meituan.hyt.test3.cglib;
6. Import com.meituan.hyt.test3.service.UserService;
8. Import com.meituan.hyt.test3.service.impl.UserServiceImpl;
10. Import net.sf.cglib.proxy.Enhancer;
18. Public class Main2 {
20. public static void main (string[] Args) {
22. Cglibproxy cglibproxy = new Cglibproxy ();
26. Enhancer enhancer = New Enhancer ();
28. Enhancer.setsuperclass (userserviceimpl.   class);
30. Enhancer.setcallback (cglibproxy);
34. UserService o = (userservice) enhancer.create ();
36. O.getname (1);
38. O.getage (1);
40. }
42. }

Running Result: ++++++before cglib$getname$0++++++
GetName
------getName------
++++++before cglib$getname$0++++++
++++++before cglib$getage$1++++++
Getage
------getage------
++++++before cglib$getage$1++++++

"reprint" Java Dynamic Agent