Spring- SpringAOP流程解析

一，解析和注册

DefaultBeanDefinitionDocumentReader

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
    // 如果Element元素是默认的命名空间
    // 默认的命名空间即为Beans命名空间
    if (delegate.isDefaultNamespace(root)) {
        NodeList nl = root.getChildNodes();
        // 循环遍历子元素
        for (int i = 0; i < nl.getLength(); i++) {
            Node node = nl.item(i);
            if (node instanceof Element) {
                Element ele = (Element) node;
                // 再次判断子元素Element是否为默认的命名空间
                if (delegate.isDefaultNamespace(ele)) {
                    parseDefaultElement(ele, delegate);
                }
                else {
                    // 如果不是默认的命名空间
                    delegate.parseCustomElement(ele);
                }
            }
        }
    }
    else {
		// 如果不是默认的命名空间
        delegate.parseCustomElement(root);
    }
}

DefaultNamespaceHandlerResolver

public NamespaceHandler resolve(String namespaceUri) {
    // 根据资源文件解析出handlerMappings
    Map<String, Object> handlerMappings = getHandlerMappings();
    // 再根据namespaceUri从handlerMappings获取对应的NamespaceHandler
    Object handlerOrClassName = handlerMappings.get(namespaceUri);
    if (handlerOrClassName == null) {
        return null;
    }
    else if (handlerOrClassName instanceof NamespaceHandler) {
        return (NamespaceHandler) handlerOrClassName;
    }
    else {
        String className = (String) handlerOrClassName;
        try {
            // 获取Class对象（类似JDK中Class.forName）
            Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
            // 确定Class的类或接口是否与函数参数所表示的类或接口相同，或者是其超类或父接口
            if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) {
                throw new FatalBeanException("Class [" + className + "] for namespace [" + namespaceUri +
                                             "] does not implement the [" + NamespaceHandler.class.getName() + "] interface");
            }
            // 创建NamespaceHandler实例对象
            NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);
            // NamespaceHandler初始化方法
            namespaceHandler.init();
            // 命值对保存到handlerMappings
            handlerMappings.put(namespaceUri, namespaceHandler);
            return namespaceHandler;
        }
        catch (ClassNotFoundException ex) {
            throw new FatalBeanException("NamespaceHandler class [" + className + "] for namespace [" +
                                         namespaceUri + "] not found", ex);
        }
        catch (LinkageError err) {
            throw new FatalBeanException("Invalid NamespaceHandler class [" + className + "] for namespace [" +
                                         namespaceUri + "]: problem with handler class file or dependent class", err);
        }
    }
}

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());
}

二，创建代理类

AbstractBeanFactory

public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
	Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");
    this.beanPostProcessors.remove(beanPostProcessor);
    this.beanPostProcessors.add(beanPostProcessor);
    // 判断BeanPostProcessor类型是否为InstantiationAwareBeanPostProcessor
    // 创建AOP关键代码之一
    if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
        this.hasInstantiationAwareBeanPostProcessors = true;
    }
    if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
        this.hasDestructionAwareBeanPostProcessors = true;
    }
}

AbstractAutowireCapableBeanFactory

protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
    // 遍历BeanPostProcessor
    for (BeanPostProcessor bp : getBeanPostProcessors()) {
        // BeanPostProcessor是否为InstantiationAwareBeanPostProcessor
        if (bp instanceof InstantiationAwareBeanPostProcessor) {
            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
            // 完成AOP切面及Spring事务注册的关键点
            Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
            if (result != null) {
                return result;
            }
        }
    }
    return null;
}

AbstractAutoProxyCreator

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

    if (beanName == null || !this.targetSourcedBeans.contains(beanName)) {
        if (this.advisedBeans.containsKey(cacheKey)) {
            return null;
        }
        // 判断条件1：Bean是否为AOP基础类（Advice、Pointcut等）不应该被代理
        // 判断条件2：是否应该跳过
        if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return null;
        }
    }

    // 创建自定义TargetSource（实现了TargetSource接口）
    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;
}

// 对Bean进行包装（有资格被代理的）
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;
    }
    // 是否基础Bean，是否需要跳过
    if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }

    // 如果有Advice则创建Proxy代理类
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
    // 不等于DO_NOT_PROXY表示需要代理
    if (specificInterceptors != DO_NOT_PROXY) {
        // 放入advisedBeans缓存，true表示已经处理过Advice
        this.advisedBeans.put(cacheKey, Boolean.TRUE);
        // 创建代理对象
        Object proxy = createProxy(
            bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
        this.proxyTypes.put(cacheKey, proxy.getClass());
        // 返回代理对象
        return proxy;
    }

    // 没有Advice表示不需要Advice
    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    return bean;
}

AspectJAwareAdvisorAutoProxyCreator

protected boolean shouldSkip(Class<?> beanClass, String beanName) {
    // TODO: Consider optimization by caching the list of the aspect names
    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);
}

 三，执行调用链

DefaultAdvisorChainFactory

该函数主要用于获取Interceptor 调用链

@Override
public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
    Advised config, Method method, Class<?> targetClass) {

    List<Object> interceptorList = new ArrayList<Object>(config.getAdvisors().length);
    // 如果targetClass为空，则获取目标类
    Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
    // 判断是否存在引入增强（IntroductionAdvisor）
    boolean hasIntroductions = hasMatchingIntroductions(config, actualClass);
    // Advisor适配注册器，该类用于跟踪单个实例，在后面还会返回需要的MethodInterceptor
    AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();

    // 遍历Advisor
    for (Advisor advisor : config.getAdvisors()) {
        // 如果是PointcutAdvisor
        if (advisor instanceof PointcutAdvisor) {
            // Add it conditionally.
            PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
            // 如果提前进行过切点匹配或者Advisor与目标类匹配
            if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
                MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
                if (MethodMatchers.matches(mm, method, actualClass, hasIntroductions)) {
                    // 将Advisor转换成MethodInterceptor
                    MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
                    // MethodMatcher中的切点分为两种：静态和动态
                    // 如果是动态切点，则每次方法的调用都要进行匹配。否则直接返回缓存里的匹配结果
                    if (mm.isRuntime()) {
                        // 如果是动态切点，则创建新的InterceptorAndDynamicMethodMatcher
                        for (MethodInterceptor interceptor : interceptors) {
                            interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
                        }
                    }
                    else {
                        // 添加到缓存列表。用于静态直接返回
                        interceptorList.addAll(Arrays.asList(interceptors));
                    }
                }
            }
        }
        // 如果是IntroductionAdvisor
        else if (advisor instanceof IntroductionAdvisor) {
            IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
            if (config.isPreFiltered() || ia.getClassFilter().matches(actualClass)) {
                Interceptor[] interceptors = registry.getInterceptors(advisor);
                interceptorList.addAll(Arrays.asList(interceptors));
            }
        }
        // 其他Advisor
        else {
            Interceptor[] interceptors = registry.getInterceptors(advisor);
            interceptorList.addAll(Arrays.asList(interceptors));
        }
    }

    return interceptorList;
}

ReflectiveMethodInvocation

该函数主要用来进行代理类的Invoke和执行Interceptor调用链上的下一个Interceptor。

public Object proceed() throws Throwable {
    //	下面索引判断条件相等，则表示Interceptor调用链执行完毕，接着要调用被代理的方法
    if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
        return invokeJoinpoint();
    }

    // 获取调用链其中的一个Advice（注意参数的++操作，currentInterceptorIndex初始值为-1）
    Object interceptorOrInterceptionAdvice =
        this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
    if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
        InterceptorAndDynamicMethodMatcher dm =
            (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
        // 动态切点进行方法匹配，符合则执行
        if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
            return dm.interceptor.invoke(this);
        }
        else {
            // 如果匹配失败，则执行下一个Interceptor
            return proceed();
        }
    }
    else {
        // 静态直接调用执行
        return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
    }
}