Spring AOP Implementation Principles

What is AOPAOP (aspect-orientedprogramming, aspect-oriented programming), can be said to be the complement and refinement of OOP (object-oriented programing, object-oriented programming). OOP introduces concepts such as encapsulation, inheritance, and polymorphism to create an object hierarchy that simulates a collection of public behavior. When we need to introduce public behavior to scattered objects, oop seems powerless. In other words, OOP allows you to define relationships from top to bottom, but it is not appropriate to define left-to-right relationships. such as logging capabilities. Log code is often spread horizontally across all object hierarchies, and has nothing to do with the core functionality of the objects it spreads to. This is true for other types of code, such as security, exception handling, and transparent persistence. This irrelevant code scattered around is called crosscutting (cross-cutting) code, and in OOP design, it leads to a lot of duplication of code, rather than the reuse of individual modules.    encapsulates the logic or responsibility that is not related to the business but is invoked by the business modules, which facilitates the reduction of repetitive code, reduces the coupling between modules, and facilitates future operability and maintainability. One feature of   crosscutting concerns is that they often occur in a number of core areas of concern and are essentially similar across the site. such as permission authentication, logging, transaction processing. The core idea of &NBSP;AOP is to "decouple the business logic in the application from the generic services that support it." &NBSP;AOP uses scenario AOP to encapsulate crosscutting concerns, which can be used in the following scenarios:  authentication permissions Caching Cache context passing content delivery error handling fault handling lazy Loading lazy load Debugging debug logging, tracing, profiling and monitoring record tracking optimization calibration performance Optimization performance optimization persistence persistence Resource pooling resource pool synchronization synchronous transactions transaction implementation of AOP technology is divided into two major categories: first, the use of dynamic Agent technology, the use of interception of messages, the message is decorated to replace the original object behavior of the execution The second is to use static weaving in a way that introduces a specific syntax to create "facets" that allow the compiler to weave code about "aspects" during compilation.   How to use spring AOP can use Spring AOP in a configuration file or programmatically. Configuration can be done through an XML file to, there are about four ways: 1.         Configure Proxyfactorybean, explicitly set advisors, advice, target, etc. 2.         Configure Autoproxycreator, in this way, using the defined bean as before, but what you get from the container is already a proxy object 3.         Configure 4 with <aop:config>.         Configure with <aop:aspectj-autoproxy>, use ASPECTJ annotations to identify notifications and pointcuts   You can also use Spring AOP in a programmatic way using proxyfactory, and Proxyfactory provides a way to set the target object, advisor and other related configurations, and finally get the proxy object through the GetProxy () method  spring the generation of AOP proxy objects Spring provides two ways to generate proxy objects: Jdkproxy and Cglib, which are generated by aopproxyfactory depending on the configuration of the Advisedsupport object. The default policy is to use the JDK dynamic Agent technology if the target class is an interface, otherwise use Cglib to generate the proxy.   Specific generated code in Jdkdynamicaopproxy this class   gets the interface to be implemented by the proxy class, in addition to the advised object configured, will also add Springproxy, advised (Opaque=false)   Check the interface above to get an interface that defines equals or hashcode   calls Proxy.newproxyinstance to create proxy objects      public Object GetProxy (ClassLoader ClassLoader) {        if (logger.isdebugenabled ()) {   & nbsp        logger.debug ("Creating JDK dynamic ProXY:target source is "+this.advised.gettargetsource ());         }         class[] Proxiedinterfaces = Aopproxyutils.completeproxiedinterfaces (this.advised);         finddefinedequalsandhashcodemethods (proxiedinterfaces);         return proxy.newproxyinstance (ClassLoader, proxiedinterfaces, this);  }  invocationhandler is a method invocation of a proxy object generated by the core of the JDK dynamic agent is delegated to the Invocationhandler.invoke () method.

2. public Object invoke(Object proxy,Method method,Object[] args) throwsThrowable {
4. MethodInvocation invocation =null;
6. Object oldProxy =null;
8. boolean setProxyContext =false;
12. TargetSource targetSource =this.advised.targetSource;
14. Class targetClass =null;
16. Object target =null;
20. try{
22. //eqauls()方法，具目标对象未实现此方法
24. if(!this.equalsDefined &&AopUtils.isEqualsMethod(method)){
26. return(equals(args[0])?Boolean.TRUE :Boolean.FALSE);
28. }
32. //hashCode()方法，具目标对象未实现此方法
34. if(!this.hashCodeDefined &&AopUtils.isHashCodeMethod(method)){
36. return newInteger(hashCode());
38. }
42. //Advised接口或者其父接口中定义的方法,直接反射调用,不应用通知
44. if(!this.advised.opaque &&method.getDeclaringClass().isInterface()
46. &&method.getDeclaringClass().isAssignableFrom(Advised.class)){
48. // Service invocations onProxyConfig with the proxy config...
50. returnAopUtils.invokeJoinpointUsingReflection(this.advised,method, args);
52. }
56. Object retVal =null;
60. if(this.advised.exposeProxy){
62. // Make invocation available ifnecessary.
64. oldProxy =AopContext.setCurrentProxy(proxy);
66. setProxyContext =true;
68. }
72. //获得目标对象的类
74. target = targetSource.getTarget();
76. if(target !=null){
78. targetClass = target.getClass();
80. }
84. //获取可以应用到此方法上的Interceptor列表
86. List chain =this.advised.getInterceptorsAndDynamicInterceptionAdvice(method,targetClass);
90. //如果没有可以应用到此方法的通知(Interceptor)，此直接反射调用 method.invoke(target, args)
92. if(chain.isEmpty()){
94. retVal =AopUtils.invokeJoinpointUsingReflection(target,method, args);
96. }else{
98. //创建MethodInvocation
100. invocation = newReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
102. retVal = invocation.proceed();
104. }
108. // Massage return value if necessary.
110. if(retVal !=null&& retVal == target &&method.getReturnType().isInstance(proxy)
112. &&!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())){
114. // Special case: it returned"this" and the return type of the method
116. // is type-compatible. Notethat we can‘t help if the target sets
118. // a reference to itself inanother returned object.
120. retVal = proxy;
122. }
124. return retVal;
126. }finally{
128. if(target !=null&&!targetSource.isStatic()){
130. // Must have come fromTargetSource.
132. targetSource.releaseTarget(target);
134. }
136. if(setProxyContext){
138. // Restore old proxy.
140. AopContext.setCurrentProxy(oldProxy);
142. }
144. }
146. }

The main process can be described as: Get a chain of notifications that can be applied to this method (Interceptor Chain), apply notifications if there is one, and execute joinpoint; If not, the direct reflection executes the joinpoint. And the key here is How the notification chain is obtained and how it is executed。 Reference article Spring AOP implementation principle: http://blog.csdn.net/moreevan/article/details/11977115

Spring AOP Implementation Principles