Java核心知识体系4：AOP原理和切面应用

@Aspect@Componentpublic class TracesRecordAdvisor {    
    @Pointcut("execution(* spring.action.expend.aop.services.*.*(..))")
    public void expression() {
    }    @Before("expression()")
    public void beforePrint()
    {        System.out.println("进入服务，在服务执行之前,记录日志....");
    }

    @AfterReturning("expression()")    public void afterPrint()
    {        System.out.println("退出服务，在服务执行结束之后,记录日志.....");
    }
}

<aop:aspectj-autoproxy/>

@Servicepublic class PayServiceImpl implements PayService {    public void payMoneyMenthod() {        System.out.println("正在执行付款...");
    }
}

    @Test
    public void springAopTestService() {        ClassPathXmlApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring-aop.xml");        PayService payService= (PayService) applicationContext.getBean("payServiceImpl");
        payService.payMoneyMenthod();
    }

进入服务，在服务执行之前,记录日志....
正在执行付款...
退出服务，在服务执行结束之后,记录日志.....

public interface BeanFactoryPostProcessor {    void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)；
}

    @Override
    public void refresh() throws BeansException, IllegalStateException {        synchronized (this.startupShutdownMonitor) {
            prepareRefresh();            //核心方法1
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
            prepareBeanFactory(beanFactory);            try {
                postProcessBeanFactory(beanFactory);                //核心方法2 执行BeanFactoryPostProcessor
                invokeBeanFactoryPostProcessors(beanFactory);                //核心方法 3 注册BeanPostProcessor
                registerBeanPostProcessors(beanFactory);                // Initialize message source for this context.
                initMessageSource();                // Initialize event multicaster for this context.
                initApplicationEventMulticaster();                // Initialize other special beans in specific context subclasses.
                onRefresh();                // Check for listener beans and register them.
                registerListeners();                // Instantiate all remaining (non-lazy-init) singletons.
                finishBeanFactoryInitialization(beanFactory);                // Last step: publish corresponding event.
                finishRefresh();
            }            catch (BeansException ex) {
                 ............                throw ex;
            }            finally {
                 ............
                resetCommonCaches();
            }
        }
    }

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {   PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
}

@Overridepublic void addBeanFactoryPostProcessor(BeanFactoryPostProcessor beanFactoryPostProcessor) {   this.beanFactoryPostProcessors.add(beanFactoryPostProcessor);
}

private static void invokeBeanFactoryPostProcessors(
  Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {  for (BeanFactoryPostProcessor postProcessor : postProcessors) {    //执行到自定义的BeanFactoryPostProcessor
 postProcessor.postProcessBeanFactory(beanFactory);
   }
}

public interface BeanPostProcessor {        //在bean创建 属性赋值之后  Aware接口执行之后执行
        Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;        //在init-method afterPropertiesSet 执行之后执行
        Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
    }

public interface NamespaceHandler {        void init();        BeanDefinition parse(Element element, ParserContext parserContext);        BeanDefinitionHolder decorate(Node source, BeanDefinitionHolder definition, ParserContext       parserContext);
    }

http://www.springframework.org/schema/aop=org.springframework.aop.config.AopNamespaceHandler

    @Override
    public void init() {        // In 2.0 XSD as well as in 2.1 XSD.
        registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());        registerBeanDefinitionParser("aspectj-autoproxy", new                       AspectJAutoProxyBeanDefinitionParser());        registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());        // Only in 2.0 XSD: moved to context namespace as of 2.1
        registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
    }

@Override
    public BeanDefinition parse(Element element, ParserContext parserContext) {        AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);        extendBeanDefinition(element, parserContext);        return null;
    }

postProcessBeforeInstantiation(Class<?> beanClass, String beanName)postProcessAfterInstantiation(Object bean, String beanName)

postProcessBeforeInitialization(Object bean, String beanName)Object postProcessAfterInitialization(Object bean, String beanName)

postProcessBeforeInstantiation(Class<?> beanClass, String beanName)

Object postProcessAfterInitialization(Object bean, String beanName)

    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {        //构建一个缓存key
        Object cacheKey = getCacheKey(beanClass, beanName);        if (beanName == null || !this.targetSourcedBeans.contains(beanName)) {            //如果当前beanClass的缓存key 存在于Class为Advise的缓存中，表示当前的beanClass是Adivse类
            //而且不需要生成代理。
            if (this.advisedBeans.containsKey(cacheKey)) {                return null;
            }            //核心校验：1 当前类是否是AOP的基础类 2、当前类是否应该跳过不生成代理
            if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {                this.advisedBeans.put(cacheKey, Boolean.FALSE);                return null;
            }
        }        //这部分主要是用于实现了TargetSource接口的bean，然后从getTarget中获取对象 创建代理
        if (beanName != null) {
            TargetSource targetSource = getCustomTargetSource(beanClass, beanName);            if (targetSource != null) {                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;
    }

@Overrideprotected boolean isInfrastructureClass(Class<?> beanClass) {//调用父类的isInfrastructureClass判断是否是aop基础类//校验当前类是否使用@Aspect注解return (super.isInfrastructureClass(beanClass) || this.aspectJAdvisorFactory.isAspect(beanClass));
}

    protected boolean isInfrastructureClass(Class<?> beanClass) {        boolean retVal = Advice.class.isAssignableFrom(beanClass) ||
                Advisor.class.isAssignableFrom(beanClass) ||
                AopInfrastructureBean.class.isAssignableFrom(beanClass);        if (retVal && logger.isTraceEnabled()) {
            logger.trace("Did not attempt to auto-proxy infrastructure class [" + beanClass.getName() + "]");
        }        return retVal;
    }

    @Override
    protected boolean shouldSkip(Class<?> beanClass, String beanName) {        //查找当前已经生成的所有Advisor切面类  不展开分析
        List<Advisor> candidateAdvisors = findCandidateAdvisors();        for (Advisor advisor : candidateAdvisors) {            if (advisor instanceof AspectJPointcutAdvisor) {                if (((AbstractAspectJAdvice) advisor.getAdvice()).getAspectName().equals(beanName)) {                    return true;
                }
            }
        }        return super.shouldSkip(beanClass, beanName);
    }

@Overrideprotected List<Advisor> findCandidateAdvisors() {   //通过父类的方法查找所有容器中的Advisor类，也就是基于xml配置的<aop:before/>生成的
   List<Advisor> advisors = super.findCandidateAdvisors();   //查找通过注解的方式生成Advisor类
   advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());   return advisors;
}

    public List<Advisor> buildAspectJAdvisors() {
        List<String> aspectNames = null;
        synchronized (this) {
            aspectNames = this.aspectBeanNames;            if (aspectNames == null) {
                List<Advisor> advisors = new LinkedList<Advisor>();
                aspectNames = new LinkedList<String>();                //从beanDefinitions中获取所有的beanName
                String[] beanNames =
                        BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.beanFactory, Object.class, true, false);                for (String beanName : beanNames) {                    //如果beanName不符合配置的 <aop:include name="***"/>
                    //忽略这个bean上所有的切面方法
                    if (!isEligibleBean(beanName)) {                        continue;
                    }
                    Class<?> beanType = this.beanFactory.getType(beanName);                    if (beanType == null) {                        continue;
                    }                    //如果当前beanType是一个切面类 则将该切面类相关信息封装起来
                    if (this.advisorFactory.isAspect(beanType)) {
                        aspectNames.add(beanName);
                        AspectMetadata amd = new AspectMetadata(beanType, beanName);                        if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {                            // 将切面信息放入到分装到MetadataAwareAspectInstanceFactory 生成一个AspectMetadata
                            MetadataAwareAspectInstanceFactory factory = new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);                            // 获取容器中所有Advisor类 需要进入这个方法详细分析
                            List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);                            if (this.beanFactory.isSingleton(beanName)) {                                //单例加入缓存
                                this.advisorsCache.put(beanName, classAdvisors);
                            } else {                                //非单例  将工厂加入缓存
                                this.aspectFactoryCache.put(beanName, factory);
                            }
                            advisors.addAll(classAdvisors);
                        } else {                            // 非单例  将生成Advisor的工厂类加入到缓存
                            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;
            }
        }
        ..............
    }

@Override
    public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {        //获取切面类Class
        Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();        //获取切面类的beanName
        String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();
        validate(aspectClass);        //进一步对AspectMetadata封装 里面包含了切面类的信息
        MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =
                new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);
        List<Advisor> advisors = new LinkedList<Advisor>();        //获取切面类中没有使用Pointcut注解的方法
        for (Method method : getAdvisorMethods(aspectClass)) {            //检查该方法是否是切面方法， 如果是成Advisor类返回
            Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName);            if (advisor != null) {
                advisors.add(advisor);
            }
        }        //如果没有切面方法 设置一个空的
        if (!advisors.isEmpty() && lazySingletonAspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {            Advisor instantiationAdvisor = new SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory);
            advisors.add(0, instantiationAdvisor);
        }        //处理属性字段 Spring支持到了属性的增强
        for (Field field : aspectClass.getDeclaredFields()) {            Advisor advisor = getDeclareParentsAdvisor(field);            if (advisor != null) {
                advisors.add(advisor);
            }
        }        return advisors;
    }

//切面类的切面方法  这里可能就是 beforePrint()Method  candidateAdviceMethod 
//获取AspectMetadata的实例工厂(可以获取切面的类所有信息)MetadataAwareAspectInstanceFactory aspectInstanceFactory//切面的排序int declarationOrderInAspect//切面类的beanName 这里是tracesRecordAdvisor
 String aspectName

@Overridepublic Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory,      int declarationOrderInAspect, String aspectName) {

   validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());   //获取pointCut,这里实际上获得的是 expression()这个方法对应了pointCut的内容
   AspectJExpressionPointcut expressionPointcut = getPointcut(
         candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());   if (expressionPointcut == null) {      return null;
   }    //创建advisor
   return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,         this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
}

private AspectJExpressionPointcut getPointcut(Method candidateAdviceMethod, Class<?> candidateAspectClass) {   //
   AspectJAnnotation<?> aspectJAnnotation =
         AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);   if (aspectJAnnotation == null) {      return null;
   }

   AspectJExpressionPointcut ajexp =         new AspectJExpressionPointcut(candidateAspectClass, new String[0], new Class<?>[0]);   //将上面生成的AspectJAnnotation 解析出的expression方法放入到表达式中
   //
   ajexp.setExpression(aspectJAnnotation.getPointcutExpression());   return ajexp;
}

protected static AspectJAnnotation<?> findAspectJAnnotationOnMethod(Method method) {    //看到了我们熟悉的切面方法注解，这里的beforePrint使用@Before注解
   Class<?>[] classesToLookFor = new Class<?>[] {
         Before.class, Around.class, After.class, AfterReturning.class, AfterThrowing.class, Pointcut.class};   for (Class<?> c : classesToLookFor) {
      AspectJAnnotation<?> foundAnnotation = findAnnotation(method, (Class<Annotation>) c);      if (foundAnnotation != null) {         return foundAnnotation;
      }
   }   return null;
}

public InstantiationModelAwarePointcutAdvisorImpl(AspectJExpressionPointcut declaredPointcut,
      Method aspectJAdviceMethod, AspectJAdvisorFactory aspectJAdvisorFactory,
      MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {   this.declaredPointcut = declaredPointcut;   this.aspectJAdviceMethod = aspectJAdviceMethod;   this.aspectJAdvisorFactory = aspectJAdvisorFactory;   this.aspectInstanceFactory = aspectInstanceFactory;   this.declarationOrder = declarationOrder;   this.aspectName = aspectName;    //切面类是否是懒加载
   if (aspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {      // Static part of the pointcut is a lazy type.
      Pointcut preInstantiationPointcut = Pointcuts.union(
            aspectInstanceFactory.getAspectMetadata().getPerClausePointcut(), this.declaredPointcut);      // Make it dynamic: must mutate from pre-instantiation to post-instantiation state.
      // If it's not a dynamic pointcut, it may be optimized out
      // by the Spring AOP infrastructure after the first evaluation.
      this.pointcut = new PerTargetInstantiationModelPointcut(            this.declaredPointcut, preInstantiationPointcut, aspectInstanceFactory);      this.lazy = true;
   }   else {      this.pointcut = this.declaredPointcut;      this.lazy = false;       //最终会执行到这里获取一个advice
      this.instantiatedAdvice = instantiateAdvice(this.declaredPointcut);
   }
}

    @Override
    public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut,
                            MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {        //获取切面类对象，这里是TracesRecordAdvisor
        Class<?> candidateAspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
        validate(candidateAspectClass);        //核心点1：获取切面注解，这里得方法是 beforePrint 使用了@Before注解
        AspectJAnnotation<?> aspectJAnnotation =
                AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);        if (aspectJAnnotation == null) {            return null;
        }
            ....................
        AbstractAspectJAdvice springAdvice;        //核心点2：根据注解转换后的 将注解生成不同的Advice类。
        switch (aspectJAnnotation.getAnnotationType()) {            case AtBefore:
                springAdvice = new AspectJMethodBeforeAdvice(
                        candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);                break;            case AtAfter:
                springAdvice = new AspectJAfterAdvice(
                        candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);                break;            case AtAfterReturning:
                springAdvice = new AspectJAfterReturningAdvice(
                        candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);                AfterReturning afterReturningAnnotation = (AfterReturning) aspectJAnnotation.getAnnotation();                if (StringUtils.hasText(afterReturningAnnotation.returning())) {
                    springAdvice.setReturningName(afterReturningAnnotation.returning());
                }                break;            case AtAfterThrowing:
                springAdvice = new AspectJAfterThrowingAdvice(
                        candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);                AfterThrowing afterThrowingAnnotation = (AfterThrowing) aspectJAnnotation.getAnnotation();                if (StringUtils.hasText(afterThrowingAnnotation.throwing())) {
                    springAdvice.setThrowingName(afterThrowingAnnotation.throwing());
                }                break;            case AtAround:
                springAdvice = new AspectJAroundAdvice(
                        candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);                break;            case AtPointcut:                //这里对PointCut不做处理
                if (logger.isDebugEnabled()) {
                    logger.debug("Processing pointcut '" + candidateAdviceMethod.getName() + "'");
                }                return null;            default:                throw new UnsupportedOperationException(                        "Unsupported advice type on method: " + candidateAdviceMethod);
        }        // 将切面类信息配置到SpringAdvice中
        springAdvice.setAspectName(aspectName);
        springAdvice.setDeclarationOrder(declarationOrder);
        String[] argNames = this.parameterNameDiscoverer.getParameterNames(candidateAdviceMethod);        if (argNames != null) {
            springAdvice.setArgumentNamesFromStringArray(argNames);
        }
        springAdvice.calculateArgumentBindings();        return springAdvice;
    }

protected static AspectJAnnotation<?> findAspectJAnnotationOnMethod(Method method) {    //看到了我们熟悉的切面方法注解，这里的beforePrint使用@Before注解
   Class<?>[] classesToLookFor = new Class<?>[] {
         Before.class, Around.class, After.class, AfterReturning.class, AfterThrowing.class, Pointcut.class};   for (Class<?> c : classesToLookFor) {
      AspectJAnnotation<?> foundAnnotation = findAnnotation(method, (Class<Annotation>) c);      if (foundAnnotation != null) {         return foundAnnotation;
      }
   }   return null;
}

static {   //会将注解转换成后面的AspectJAnnotationType枚举的类。 
   annotationTypes.put(Pointcut.class,AspectJAnnotationType.AtPointcut);
   annotationTypes.put(After.class,AspectJAnnotationType.AtAfter);
   annotationTypes.put(AfterReturning.class,AspectJAnnotationType.AtAfterReturning);
   annotationTypes.put(AfterThrowing.class,AspectJAnnotationType.AtAfterThrowing);
   annotationTypes.put(Around.class,AspectJAnnotationType.AtAround);
   annotationTypes.put(Before.class,AspectJAnnotationType.AtBefore);
}

//切面方法 这里可能是beforePrintMethod aspectJAroundAdviceMethod//切入点表达式匹配器 这里指封装了exression的匹配器AspectJExpressionPointcut pointcut//切面类  这里指TracesRecordAdvisorAspectInstanceFactory aif

	@Override
	public Object invoke(MethodInvocation mi) throws Throwable {		try {             //调用是实现了MethodInvocation方法的类 这个其实是个链式调用
			return mi.proceed();
		}		finally {            //最终执行后置增强方法
			invokeAdviceMethod(getJoinPointMatch(), null, null);
		}
	}

@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;
}

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {    //如果bean是通过TargetSource接口获取 则直接返回
   if (beanName != null && this.targetSourcedBeans.contains(beanName)) {      return bean;
   }    //如果bean是切面类 直接返回
   if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {      return bean;
   }    //如果bean是Aspect 而且允许跳过创建代理， 加入advise缓存 返回
   if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {      this.advisedBeans.put(cacheKey, Boolean.FALSE);      return bean;
   }   //如果前面生成的advisor缓存中存在能够匹配到目标类方法的Advisor 则创建代理
   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;
}