Spring Aop底层原理详解

/**
  * 处理我们的@Import注解，注意我们的@Import注解传入的参数，可能有三种类型
  * 1，传入一个class类，直接解析
  * 2，传入一个registrar,需要解析这个registrar
  * 3，传入一个ImporterSelector,这时候会去解析ImporterSelector的实现方法中返回的数组的class
  *   
  */
 private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
   Collection<SourceClass> importCandidates, boolean checkForCircularImports) {

  if (importCandidates.isEmpty()) {
   return;
  }

  if (checkForCircularImports && isChainedImportOnStack(configClass)) {
   this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
  }
  else {
   this.importStack.push(configClass);
   try {
    for (SourceClass candidate : importCandidates) {
     //处理我们的ImportSelector
     if (candidate.isAssignable(ImportSelector.class)) {
      // Candidate class is an ImportSelector -> delegate to it to determine imports
      Class<?> candidateClass = candidate.loadClass();
      ImportSelector selector = BeanUtils.instantiateClass(candidateClass, ImportSelector.class);
      ParserStrategyUtils.invokeAwareMethods(
        selector, this.environment, this.resourceLoader, this.registry);
      if (this.deferredImportSelectors != null && selector instanceof DeferredImportSelector) {
       this.deferredImportSelectors.add(
         new DeferredImportSelectorHolder(configClass, (DeferredImportSelector) selector));
      }
      else {
       String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
       Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames);
       //注意可能我们ImportSelector传入的类上还有可能会Import，所以这里，spring采用了
       //一个递归调用，解析所有的import
       processImports(configClass, currentSourceClass, importSourceClasses, false);
      }
     }
     //处理我们的Registrar
     else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
      // Candidate class is an ImportBeanDefinitionRegistrar ->
      // delegate to it to register additional bean definitions
      Class<?> candidateClass = candidate.loadClass();
      ImportBeanDefinitionRegistrar registrar =
        BeanUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class);
      ParserStrategyUtils.invokeAwareMethods(
        registrar, this.environment, this.resourceLoader, this.registry);
      //添加的一个和Importselector方式不同的map中，sprig对两种方式传入的类注册方式不同
      configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
     }
     else {
      // Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
      // process it as an @Configuration class
      
      //最后如果是普通类，传入importStack后交由processConfigurationClass进行注册处理
      this.importStack.registerImport(
        currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
      processConfigurationClass(candidate.asConfigClass(configClass));
     }
    }
   }
   catch (BeanDefinitionStoreException ex) {
    throw ex;
   }
   catch (Throwable ex) {
    throw new BeanDefinitionStoreException(
      "Failed to process import candidates for configuration class [" +
      configClass.getMetadata().getClassName() + "]", ex);
   }
   finally {
    this.importStack.pop();
   }
  }
 }

/**
 * 描述:
 *  自定义数据结构
 *
 * @author baomw
 * @create 2018-11-19 下午 4:56
 */
public class ProxyBeanHolder {
 //通知类名称
    private volatile String className;
    //通知方法名称
    private volatile String methodName;
    //注解类名称
    private volatile String annotationName;
 ...
 < get and setter>
}

 /**
     * 描述:
     *
     * @author baomw
     * @create 2018-11-19 下午 1:48
     */
    public class ConfigurationUtil {
    
        /**
         * aop标识注解类
         */
        public static final String AOP_POINTCUT_ANNOTATION
                                                = "com.baomw.annotation.AopJ";
        /**
         * 前置通知注解类
         */
        public static final String BEFORE
                                                = "com.baomw.annotation.BeforeBaomw";
        /**
         * 后置通知注解类
         */
        public static final String AFTER
                                                = "com.baomw.annotation.AfterBaomw";
        /**
         * 环绕通知注解类
         */
        public static final String AROUND
                                                = "com.baomw.annotation.AroundBaomw";
        /**
         * 存放需代理的全部目标对象类
         */
        public static volatile Map<String,List<ProxyBeanHolder>> classzzProxyBeanHolder = new ConcurrentHashMap<>();
    
    }

/**
 * 描述:
 *
 * @author baomw
 * @create 2018-11-19 下午 1:59
 */
@Component
public class RegisterBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    /**
     * 存放需要代理的相关信息类
     */
    public static volatile List<ProxyBeanHolder> roxyBeanHolderList = new Vector<>();

    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        //获取所有的bdName
        String[] beanDefinitionNames = configurableListableBeanFactory.getBeanDefinitionNames();
        for (String beanDefinitionName:beanDefinitionNames){
            BeanDefinition beanDefinition
                    = configurableListableBeanFactory.getBeanDefinition(beanDefinitionName);
            //判断bd是否是一个注解bd
            if (beanDefinition instanceof AnnotatedBeanDefinition) {
                //取得bd上的所有注解
                AnnotationMetadata metadata = ((AnnotatedBeanDefinition) beanDefinition).getMetadata();
                Set<String> Annotations = metadata.getAnnotationTypes();
                //循环所有注解，找到aop切面注解类
                for (String annotation:Annotations)
                    if (annotation.equals(ConfigurationUtil.AOP_POINTCUT_ANNOTATION))
                        doScan((GenericBeanDefinition)beanDefinition);
            }
        }
    }

/**
 * 描述:
 * aop实现核心处理类
 *
 * @author baomw
 * @create 2018-11-18 下午 11:24
 */
public class RealizedAopBeanPostProcessor implements BeanPostProcessor {


    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        String targetClass = bean.getClass().getName();
        Object object = bean;
        if (ConfigurationUtil.classzzProxyBeanHolder.containsKey(targetClass)){
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(object.getClass());
            enhancer.setCallback(new CustomizedProxyInterceptor(ConfigurationUtil.classzzProxyBeanHolder.get(targetClass)));
            object =  enhancer.create();
        }
        return object;
    }

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

}

/**
 * 描述:
 * 自定义aop实现，提交给spring处理的类
 *
 * @author baomw
 * @create 2018-11-18 下午 11:29
 */
public class CustomizedAopImportSelector implements ImportSelector {

    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        return new String[]{RealizedAopBeanPostProcessor.class.getName(),RegisterBeanFactoryPostProcessor.class.getName()};
    }
}
/**
 * 描述:
 * aop开关注解
 *
 * @author baomw
 * @create 2018-11-18 下午 11:21
 */
@Retention(RetentionPolicy.RUNTIME)
@Import(CustomizedAopImportSelector.class)
public @interface EnableAop {
}

@Override
 public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
  Object cacheKey = getCacheKey(beanClass, beanName);

  if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
   if (this.advisedBeans.containsKey(cacheKey)) {
    return null;
   }
   if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    return null;
   }
  }

  // Create proxy here if we have a custom TargetSource.
  // Suppresses unnecessary default instantiation of the target bean:
  // The TargetSource will handle target instances in a custom fashion.
  TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
  if (targetSource != null) {
   if (StringUtils.hasLength(beanName)) {
    this.targetSourcedBeans.add(beanName);
   }
   Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
   Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
   this.proxyTypes.put(cacheKey, proxy.getClass());
   return proxy;
  }

  return null;
 }