使用Spring AOP

添加注解@EnableAspectJAutoProxy

  1. @EnableAspectJAutoProxy

添加pom

  1. <dependency>
  2.   <groupId>org.springframework</groupId>
  3.   <artifactId>spring-aop</artifactId>
  4.   <version>5.2.2.RELEASE</version>
  5. </dependency>
  6. <dependency>
  7.   <groupId>org.aspectj</groupId>
  8.   <artifactId>aspectjrt</artifactId>
  9.   <version>1.8.9</version>
  10. </dependency>
  11. <dependency>
  12.   <groupId>org.aspectj</groupId>
  13.   <artifactId>aspectjweaver</artifactId>
  14.   <version>1.8.9</version>
  15. </dependency>

添加 Aspect

  1. @Component
  2. @Aspect
  3. public class TestAop {
  4.     @Before("pointCut()")
  5.     public void methodBefore() {
  6.         System.out.println("方法调用前1");
  7.     }
  9.     //    @Pointcut("execution(* com.mkb.service.UserService.*.*(..))")
  10.     @Pointcut("execution(public * *(..))")
  11.     public void pointCut() {
  12.     }
  14.     @Around("pointCut()")
  15.     public Object processMethod(ProceedingJoinPoint jp) throws Throwable {
  16.         System.out.println("方法调用前processMethod");
  17.         return jp.proceed();
  18.     }
  21.     @After("pointCut()")
  22.     public void methodAfter() {
  23.         System.out.println("方法调用后1");
  24.     }
  25. }

要学习Spring AOP 最好先把spring ioc学习清楚

在ioc中我们知道springbean是怎么初始化的，下面是初始化中的一个方法

  1. protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
  2.     throws BeanCreationException {
  4.     // Instantiate the bean.
  5.     BeanWrapper instanceWrapper = null;
  6.     if (mbd.isSingleton()) {
  7.         instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
  8.     }
  9.     if (instanceWrapper == null) {
  10.         instanceWrapper = createBeanInstance(beanName, mbd, args);
  11.     }
  12.     final Object bean = instanceWrapper.getWrappedInstance();
  13.     Class<?> beanType = instanceWrapper.getWrappedClass();
  14.     if (beanType != NullBean.class) {
  15.         mbd.resolvedTargetType = beanType;
  16.     }
  18.     // Allow post-processors to modify the merged bean definition.
  19.     synchronized (mbd.postProcessingLock) {
  20.         if (!mbd.postProcessed) {
  21.             try {
  22.                 applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
  23.             }
  24.             catch (Throwable ex) {
  25.                 throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  26.                                                 "Post-processing of merged bean definition failed", ex);
  27.             }
  28.             mbd.postProcessed = true;
  29.         }
  30.     }
  32.     // Eagerly cache singletons to be able to resolve circular references
  33.     // even when triggered by lifecycle interfaces like BeanFactoryAware.
  34.     boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
  35.                                       isSingletonCurrentlyInCreation(beanName));
  36.     if (earlySingletonExposure) {
  37.         if (logger.isTraceEnabled()) {
  38.             logger.trace("Eagerly caching bean '" + beanName +
  39.                          "' to allow for resolving potential circular references");
  40.         }
  41.         addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
  42.     }
  44.     // Initialize the bean instance.
  45.     Object exposedObject = bean;
  46.     try {
  47.         populateBean(beanName, mbd, instanceWrapper);
  48.         exposedObject = initializeBean(beanName, exposedObject, mbd);
  49.     }
  50.     catch (Throwable ex) {
  51.         if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
  52.             throw (BeanCreationException) ex;
  53.         }
  54.         else {
  55.             throw new BeanCreationException(
  56.                 mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
  57.         }
  58.     }
  60.     if (earlySingletonExposure) {
  61.         Object earlySingletonReference = getSingleton(beanName, false);
  62.         if (earlySingletonReference != null) {
  63.             if (exposedObject == bean) {
  64.                 exposedObject = earlySingletonReference;
  65.             }
  66.             else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
  67.                 String[] dependentBeans = getDependentBeans(beanName);
  68.                 Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
  69.                 for (String dependentBean : dependentBeans) {
  70.                     if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
  71.                         actualDependentBeans.add(dependentBean);
  72.                     }
  73.                 }
  74.                 if (!actualDependentBeans.isEmpty()) {
  75.                     throw new BeanCurrentlyInCreationException(beanName,
  76.                                                                "Bean with name '" + beanName + "' has been injected into other beans [" +
  77.                                                                StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
  78.                                                                "] in its raw version as part of a circular reference, but has eventually been " +
  79.                                                                "wrapped. This means that said other beans do not use the final version of the " +
  80.                                                                "bean. This is often the result of over-eager type matching - consider using " +
  81.                                                                "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
  82.                 }
  83.             }
  84.         }
  85.     }
  87.     // Register bean as disposable.
  88.     try {
  89.         registerDisposableBeanIfNecessary(beanName, bean, mbd);
  90.     }
  91.     catch (BeanDefinitionValidationException ex) {
  92.         throw new BeanCreationException(
  93.             mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
  94.     }
  96.     return exposedObject;
  97. }

就是 instanceWrapper = createBeanInstance(beanName, mbd, args); 这个方法实例化了bean对象，这个获取的是原生的bean，并没有产生代理，那么代理肯定是在后面的代码中初始化完成。

进入exposedObject = initializeBean(beanName, exposedObject, mbd);

  1. protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
  2.     if (System.getSecurityManager() != null) {
  3.         AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
  4.             invokeAwareMethods(beanName, bean);
  5.             return null;
  6.         }, getAccessControlContext());
  7.     }
  8.     else {
  9.         invokeAwareMethods(beanName, bean);
  10.     }
  12.     Object wrappedBean = bean;
  13.     if (mbd == null || !mbd.isSynthetic()) {
  14.         //前置处理器
  15.         wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
  16.     }
  18.     try {
  19.         invokeInitMethods(beanName, wrappedBean, mbd);
  20.     }
  21.     catch (Throwable ex) {
  22.         throw new BeanCreationException(
  23.             (mbd != null ? mbd.getResourceDescription() : null),
  24.             beanName, "Invocation of init method failed", ex);
  25.     }
  26.     if (mbd == null || !mbd.isSynthetic()) {
  27.         //后置处理器
  28.         wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
  29.     }
  31.     return wrappedBean;
  32. }

继续进入wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

  1. public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
  2.     throws BeansException {
  4.     Object result = existingBean;
  5.     for (BeanPostProcessor processor : getBeanPostProcessors()) {
  6.         Object current = processor.postProcessAfterInitialization(result, beanName);
  7.         if (current == null) {
  8.             return result;
  9.         }
  10.         result = current;
  11.     }
  12.     return result;
  13. }

Object current = processor.postProcessAfterInitialization(result, beanName); 这个后置处理器有很多实现，只有添加了 @EnableAspectJAutoProxy 这个注解才会初始化AbstractAutoProxyCreator 这个处理器来产生代理对象

继续进入postProcessAfterInitialization 找到 AbstractAutoProxyCreator实现

继续进入 wrapIfNecessary

  1. protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
  2.         if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
  3.             return bean;
  4.         }
  5.         if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
  6.             return bean;
  7.         }
  8.         if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
  9.             this.advisedBeans.put(cacheKey, Boolean.FALSE);
  10.             return bean;
  11.         }
  13.         // Create proxy if we have advice.
  14.         Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
  15.         if (specificInterceptors != DO_NOT_PROXY) {
  16.             this.advisedBeans.put(cacheKey, Boolean.TRUE);
  17.             Object proxy = createProxy(
  18.                     bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
  19.             this.proxyTypes.put(cacheKey, proxy.getClass());
  20.             return proxy;
  21.         }
  23.         this.advisedBeans.put(cacheKey, Boolean.FALSE);
  24.         return bean;
  25.     }

继续进入Object proxy = createProxy(
bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));

  1. protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
  2.                              @Nullable Object[] specificInterceptors, TargetSource targetSource) {
  4.     if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
  5.         AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
  6.     }
  8.     ProxyFactory proxyFactory = new ProxyFactory();
  9.     proxyFactory.copyFrom(this);
  11.     if (!proxyFactory.isProxyTargetClass()) {
  12.         if (shouldProxyTargetClass(beanClass, beanName)) {
  13.             proxyFactory.setProxyTargetClass(true);
  14.         }
  15.         else {
  16.             evaluateProxyInterfaces(beanClass, proxyFactory);
  17.         }
  18.     }
  20.     Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
  21.     proxyFactory.addAdvisors(advisors);
  22.     proxyFactory.setTargetSource(targetSource);
  23.     customizeProxyFactory(proxyFactory);
  25.     proxyFactory.setFrozen(this.freezeProxy);
  26.     if (advisorsPreFiltered()) {
  27.         proxyFactory.setPreFiltered(true);
  28.     }
  30.     return proxyFactory.getProxy(getProxyClassLoader());
  31. }

继续进入proxyFactory.getProxy(getProxyClassLoader());

  1. public Object getProxy(@Nullable ClassLoader classLoader) {
  2.     return createAopProxy().getProxy(classLoader);
  3. }

getProxy 这个方法可能有两个实现
image.png
可以看到取决于我们再注入 @EnableAspectJAutoProxy 注解的时候使用了什么代理，CGlib 还是 jdk自带的根据我们的选择来通过不同的方法实现代理对象。

总结：spring内部实现aop就是，在原生的bean产生后，通过后置处理器来生成一个新的代理bean存放在缓存中。然后调用代理类的方法，就是会调用handlerr的invoke，这样就实现了动态代理，也是aop的实现原理。