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

This article mainly introduces "how to achieve AOP in Spring". In daily operation, I believe many people have doubts about how to achieve AOP in Spring. The editor consulted all kinds of materials and sorted out simple and easy-to-use methods of operation. I hope it will be helpful to answer the doubts about "how to achieve AOP in Spring". Next, please follow the editor to study!

1. Find the corresponding core class from the annotations

In my recent work, I have implemented AOP functions based on annotations. The common annotation to open AOP is @ EnableAspectJAutoProxy, so let's start with it.

The process of the above dynamic diagram is as follows:

@ EnableAspectJAutoProxy

-> AspectJAutoProxyRegistrar

-- > AopConfigUtils .registerAspectJAnnotationAutoProxyCreatorIfNecessary

-> AnnotationAwareAspectJAutoProxyCreator.class

AnnotationAwareAspectJAutoProxyCreator looks at its Chinese comments (below) to make sure it is the core class of AOP! -- Wen Anshi 20191020

A subclass of / * * 1.AspectJAwareAdvisorAutoProxyCreator, which is used to deal with annotation aspect 2 in the current application context. Any classes annotated by AspectJ will be automatically recognized. 3. If the SpringAOP proxy mode is recognizable, the Spring proxy mode is preferred. 4. It covers the method execution join point 5. 5. If you use elements, only @ aspectj bean whose names match the include pattern are considered facets and are automatically proxied by spring. 6. For Spring Advisors processing, please refer to org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator * / @ SuppressWarnings ("serial") public class AnnotationAwareAspectJAutoProxyCreator extends AspectJAwareAdvisorAutoProxyCreator {/ /. Omit the realization} annotation section

Although I found the core class, I didn't find the core method! Let's try to draw a class diagram to determine the core method.

two。 Draw the core class diagram and guess the core method

Part of the class diagram of AnnotationAwareAspectJAutoProxyCreator.

You can see from the class diagram that AnnotationAwareAspectJAutoProxyCreator implements BeanPostProcessor, while the AOP function should be executed after the Bean is created. It is speculated that the postProcessAfterInitialization (instantiation bean post-processing) of AnnotationAwareAspectJAutoProxyCreator implementing BeanPostProcessor is the core method. Look at the postProcessAfterInitialization method implemented by AnnotationAwareAspectJAutoProxyCreator, which is actually in its parent class, AbstractAutoProxyCreator.

PostProcessAfterInitialization implementation in AbstractAutoProxyCreator @ Overridepublic Object postProcessAfterInitialization (Object bean, String beanName) throws BeansException {if (bean! = null) {Object cacheKey = getCacheKey (bean.getClass (), beanName); if (! this.earlyProxyReferences.contains (cacheKey)) {return wrapIfNecessary (bean, beanName, cacheKey);} return bean;}

Find the suspected method wrapIfNecessary, check its source code as follows, find the createProxy method. Make sure you're in the right place.

Protected Object wrapIfNecessary (Object bean, String beanName, Object cacheKey) {if (beanName! = null & & this.targetSourcedBeans.contains (beanName)) {return bean;} if (Boolean.FALSE.equals (this.advisedBeans.get (cacheKey) {return bean;} if (isInfrastructureClass (bean.getClass ()) | shouldSkip (bean.getClass (), beanName)) {this.advisedBeans.put (cacheKey, Boolean.FALSE) Return bean;} / / create agent Object [] specificInterceptors = getAdvicesAndAdvisorsForBean (bean.getClass (), beanName, null); if (specificInterceptors! = DO_NOT_PROXY) {this.advisedBeans.put (cacheKey, Boolean.TRUE); Object proxy = createProxy (bean.getClass (), beanName, specificInterceptors, new SingletonTargetSource (bean)); this.proxyTypes.put (cacheKey, proxy.getClass ()); return proxy } this.advisedBeans.put (cacheKey, Boolean.FALSE); return bean;}

That is, AnnotationAwareAspectJAutoProxyCreator implements the postProcessAfterInitialization method of BeanPostProcessor, in which the function of AOP is realized by wrapIfNecessary. There are two and core methods in wrapIfNecessary

GetAdvicesAndAdvisorsForBean gets the current bean matching enhancer

CreateProxy creates a proxy for the current bean

These two methods need to be analyzed in order to understand the core process.

3. Read the key method, manage the core flow 3.1 getAdvicesAndAdvisorsForBean to get the current bean matching enhancer

Check the source code as follows, and the default implementation is in AbstractAdvisorAutoProxyCreator.

Override@Nullableprotected Object [] getAdvicesAndAdvisorsForBean (Class beanClass, String beanName, @ Nullable TargetSource targetSource) {List advisors = findEligibleAdvisors (beanClass, beanName); if (advisors.isEmpty ()) {return DO_NOT_PROXY;} return advisors.toArray ();}

Look up the findEligibleAdvisors method and do three things

Find all the enhancers, that is, the Bean of all @ Aspect annotations

Find the matching enhancer, that is, based on the expression on the @ Before,@After and other annotations, match with the current bean, exposing the match.

The matching enhancers are extended and sorted by the data values of @ Order or PriorityOrdered's getOrder. The smaller the enhancers are, the higher they are.

Protected List findEligibleAdvisors (Class beanClass, String beanName) {/ / find all enhancers List candidateAdvisors = findCandidateAdvisors (); / / find all matching enhancers List eligibleAdvisors = findAdvisorsThatCanApply (candidateAdvisors, beanClass, beanName); extendAdvisors (eligibleAdvisors); if (! eligibleAdvisors.isEmpty ()) {/ / sort eligibleAdvisors = sortAdvisors (eligibleAdvisors);} return eligibleAdvisors;}

AnnotationAwareAspectJAutoProxyCreator rewrote findCandidateAdvisors. Let's take a look at what has been implemented.

3.1.1findCandidateAdvisors looks for all enhancers, that is, Bean@Overrideprotected List findCandidateAdvisors () {/ / Add all the Spring advisors found according to superclass rules of all @ Aspect annotations. List advisors = super.findCandidateAdvisors (); / / Build Advisors for all AspectJ aspects in the bean factory. The classes annotated by if (this.aspectJAdvisorsBuilder! = null) {/ / @ Aspect are here except advisors.addAll (this.aspectJAdvisorsBuilder.buildAspectJAdvisors ());} return advisors;}

From this method, we can see that the way to handle the bean of the @ Aspect annotation is: this.aspectJAdvisorsBuilder.buildAspectJAdvisors (). This method is as follows:

Public List buildAspectJAdvisors () {List aspectNames = this.aspectBeanNames; if (aspectNames = = null) {synchronized (this) {aspectNames = this.aspectBeanNames; if (aspectNames = = null) {List advisors = new ArrayList (); aspectNames = new ArrayList (); / / find all BeanName String [] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors (this.beanFactory, Object.class, true, false) For (String beanName: beanNames) {if (! isEligibleBean (beanName)) {continue;} / / it must be noted that bean is exposed ahead of time and cached by the Spring container, but cannot be woven into it at this time. Class beanType = this.beanFactory.getType (beanName); if (beanType = = null) {continue;} if (this.advisorFactory.isAspect (beanType)) {/ / find all classes annotated by @ Aspect aspectNames.add (beanName); AspectMetadata amd = new AspectMetadata (beanType, beanName) If (amd.getAjType (). GetPerClause (). GetKind () = = PerClauseKind.SINGLETON) {MetadataAwareAspectInstanceFactory factory = new BeanFactoryAspectInstanceFactory (this.beanFactory, beanName); / / return List classAdvisors = this.advisorFactory.getAdvisors (factory) when parsed as Advisor If (this.beanFactory.isSingleton (beanName)) {this.advisorsCache.put (beanName, classAdvisors);} else {this.aspectFactoryCache.put (beanName, factory);} advisors.addAll (classAdvisors) } else {/ / Per target or per this. If (this.beanFactory.isSingleton (beanName)) {throw new IllegalArgumentException ("Bean with name'" + beanName + "'is a singleton, but aspect instantiation model is not singleton");} MetadataAwareAspectInstanceFactory factory = new PrototypeAspectInstanceFactory (this.beanFactory, beanName) This.aspectFactoryCache.put (beanName, factory); advisors.addAll (this.advisorFactory.getAdvisors (factory));} this.aspectBeanNames = aspectNames; return advisors;}} if (aspectNames.isEmpty ()) {return Collections.emptyList () } List advisors = new ArrayList (); for (String aspectName: aspectNames) {List cachedAdvisors = this.advisorsCache.get (aspectName); if (cachedAdvisors! = null) {advisors.addAll (cachedAdvisors);} else {MetadataAwareAspectInstanceFactory factory = this.aspectFactoryCache.get (aspectName); advisors.addAll (this.advisorFactory.getAdvisors (factory));} return advisors;}

This method can be summarized as follows:

Find all the BeanName

Filter out the classes annotated by @ Aspect according to BeanName

For the methods annotated by Around.class, Before.class, After.class, AfterReturning.class, AfterThrowing.class, sort by the above annotation order and then sort by the method name, each method corresponds to an Advisor.

3.2 createProxy creates a proxy for the current bean. 3.2.1 two ways to create an agent

As we all know, there are two common ways to create an agent: JDK creation and CGLIB. Let's take a look at the examples of creating an agent in these two.

3.2.1. 1 example of jdk creating an agent import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;public class JDKProxyMain {public static void main (String [] args) {JDKProxyTestInterface target = new JDKProxyTestInterfaceImpl () / / create a proxy object JDKProxyTestInterface proxy = (JDKProxyTestInterface) Proxy .newProxyInstance (target.getClass (). GetClassLoader (), target.getClass (). GetInterfaces (), new JDKProxyTestInvocationHandler (target)) based on the target object; / / call the proxy object method proxy.testProxy ();} interface JDKProxyTestInterface {void testProxy () } static class JDKProxyTestInterfaceImpl implements JDKProxyTestInterface {@ Override public void testProxy () {System.out.println ("testProxy");}} static class JDKProxyTestInvocationHandler implements InvocationHandler {private Object target; public JDKProxyTestInvocationHandler (Object target) {this.target=target } @ Override public Object invoke (Object proxy, Method method, Object [] args) throws Throwable {System.out.println (before execution); Object result= method.invoke (this.target,args); System.out.println (after execution); return result } 3.2.1. 2 example of cglib creating an agent import org.springframework.cglib.proxy.Enhancer;import org.springframework.cglib.proxy.MethodInterceptor;import org.springframework.cglib.proxy.MethodProxy;import java.lang.reflect.Method;public class CglibProxyTest {static class CglibProxyService {public CglibProxyService () {} void sayHello () {System.out.println ("hello!") }} static class CglibProxyInterceptor implements MethodInterceptor {@ Override public Object intercept (Object sub, Method method, Object [] objects, MethodProxy methodProxy) throws Throwable {System.out.println ("before hello"); Object object = methodProxy.invokeSuper (sub, objects); System.out.println ("after hello") Return object;}} public static void main (String [] args) {/ / the process of getting the proxy object through the CGLIB dynamic proxy Enhancer enhancer = new Enhancer (); / / sets the parent class enhancer.setSuperclass (CglibProxyService.class) of the enhancer object; / / sets the callback object enhancer.setCallback (new CglibProxyInterceptor ()) of the enhancer / / create a proxy object CglibProxyService proxy= (CglibProxyService) enhancer.create (); System.out.println (CglibProxyService.class); System.out.println (proxy.getClass ()); / / call the target method proxy.sayHello () through the proxy object } 3.2.1. 3 the difference between jdk creation agent and cglib creation agent jdk creation dynamic proxy cglib creation dynamic proxy principle java dynamic proxy uses reflection mechanism to generate an anonymous class that implements the proxy interface. Calling InvokeHandler before calling a specific method is to use asm open source package to load the class file of the proxy object class. By modifying its bytecode to generate a subclass to deal with the core class Proxy creation agent uses the reflection mechanism to generate an anonymous class InvocationHandler method interceptor interface that implements the proxy interface, it is necessary to implement the invoke method net.sf.cglib.proxy.Enhancer: the main enhanced class, dynamically create subclass instances of delegated classes through bytecode technology net.sf.cglib.proxy.MethodInterceptor: method interceptor interface Need to implement intercept method limitations only classes that implement interfaces cannot proxy classes modified by final, nor can they deal with methods modified by final 3.2.2 how does Spring choose which way to use

The choice of Spring is in DefaultAopProxyFactory when choosing how to delegate.

Public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {@ Override public AopProxy createAopProxy (AdvisedSupport config) throws AopConfigException {if (config.isOptimize () | | config.isProxyTargetClass () | | hasNoUserSuppliedProxyInterfaces (config)) {Class targetClass = config.getTargetClass () If (targetClass = = null) {throw new AopConfigException ("TargetSource cannot determine target class:" + "Either an interface or a target" + "is required for proxy creation.");} if (targetClass.isInterface () | | Proxy.isProxyClass (targetClass)) {return new JdkDynamicAopProxy (config) } return new ObjenesisCglibAopProxy (config);} else {return new JdkDynamicAopProxy (config);}} / /.}

When config.isOptimize () looks at the source comments, he finds that this is whether to configure whether or not to use an active policy when using the cglib proxy. This value is generally not recommended!

Config.isProxyTargetClass () is the proxyTargetClass attribute in @ EnableAspectJAutoProxy.

/ / exposeProxy=true AopContext can be accessed, proxyTargetClass=true CGLIB generation agent @ EnableAspectJAutoProxy (exposeProxy=true,proxyTargetClass=true)

Does hasNoUserSuppliedProxyInterfaces have an interface that can be proxied

Summarize how Spring chose how to create an agent:

If proxyTargetClass=true is set, it must be a CGLIB proxy

If proxyTargetClass=false, the target object implements the interface, go to the JDK proxy

If you do not implement the interface, go to the CGLIB proxy

4. Summary

How does Spring implement AOP? You can say:

AnnotationAwareAspectJAutoProxyCreator is the core processing class of AOP

AnnotationAwareAspectJAutoProxyCreator implements BeanProcessor, where postProcessAfterInitialization is the core method.

The core implementation is divided into two steps.

GetAdvicesAndAdvisorsForBean gets the current bean matching enhancer createProxy to create a proxy for the current bean

The core logic of getAdvicesAndAdvisorsForBean is as follows

a. Find all the enhancers, that is, the Bean of all @ Aspect annotations

b. Find the matching enhancer, that is, based on the expression on the @ Before,@After and other annotations, match with the current bean, exposing the match.

c. The matching enhancers are extended and sorted by the data values of @ Order or PriorityOrdered's getOrder. The smaller the enhancers are, the higher they are.

There are two ways to create createProxy, JDK proxy or CGLIB

a. If proxyTargetClass=true is set, it must be a CGLIB proxy

b. If proxyTargetClass=false, the target object implements the interface, go to the JDK proxy

c. If you do not implement the interface, go to the CGLIB proxy

At this point, the study on "how to achieve AOP in Spring" is over. I hope to be able to solve your doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

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.