Spring源码分析～AOP如何生成代理对象

注意：各个版本可能有些不一致，我看的版本：4.3.17

看源码肯定需要一个入口，我们准备了一个demo，很简单，一个main方法，一个config类，一个对象（需要被代理的对象），一个日志切面类；

一个对象：

package com.anotation.aop;

import org.springframework.stereotype.Service;

@Service
public class MathCalculator {
	
	public int divide(int i,int j){
		System.out.println("MathCalculator...div...");
		return i/j;	
	}
}

切面类：用于给上面的对象增强日志功能

package com.anotation.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Service;

import java.util.Arrays;

/**
 * 切面类 @Aspect
 */
@Aspect
@Service
public class LogAspects {

	@Pointcut("execution(public int com.anotation.aop.MathCalculator.*(..))")
	public void pointCut(){};

	@Before("pointCut()")
	public void logStart(JoinPoint joinPoint){
		Object[] args = joinPoint.getArgs();
		System.out.println(""+joinPoint.getSignature().getName()+"方法运行，@Before:{"+Arrays.asList(args)+"}");
	}
	
	@After("com.anotation.aop.LogAspects.pointCut()")
	public void logEnd(JoinPoint joinPoint){
		System.out.println(""+joinPoint.getSignature().getName()+"方法运行，@After");
	}
	
	@AfterReturning(value="pointCut()",returning="result")
	public void logReturn(JoinPoint joinPoint,Object result){
		System.out.println(""+joinPoint.getSignature().getName()+"@AfterReturning："+"{"+result+"}");
	}

	//JoinPoint一定要出现在参数的第一位
	@AfterThrowing(value="pointCut()",throwing="exception")
	public void logException(JoinPoint joinPoint,Exception exception){
		System.out.println(""+joinPoint.getSignature().getName()+"方法运行产生异常，@AfterThrowing："+"{"+exception+"}");
	}

}

config类：

package com.anotation.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@EnableAspectJAutoProxy
@Configuration
@ComponentScan(value = "com.anotation.aop")
public class MainConfigOfAOP {

}

重点看@EnableAspectJAutoProxy的作用，它是一个注解，主要作用是引入：@Import(AspectJAutoProxyRegistrar.class)

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {
	boolean proxyTargetClass() default false;
	boolean exposeProxy() default false;
}

而AspectJAutoProxyRegistrar.java的作用主要是注册：AnnotationAwareAspectJAutoProxyCreator.java，这个类是一个后置处理器BeanPostProcessor，这个AnnotationAwareAspectJAutoProxyCreator是实现aop功能的核心，因为他会在它的方法postProcessAfterInitialization()中对目标对象进行增强（实现AOP），后面会细说。

main函数：

package com.atguigu.test;

import com.anotation.aop.MathCalculator;
import com.anotation.config.MainConfigOfAOP;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class IOCTest_AOP {
	@Test
	public void test01() throws InterruptedException {
		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfAOP.class);
		MathCalculator mathCalculator = applicationContext.getBean(MathCalculator.class);
		mathCalculator.divide(4, 2);
		Thread.sleep(2000);
		applicationContext.close();
	}
}

先看运行结果：

divide方法运行，@Before:{[4, 2]}
MathCalculator...div...
divide方法运行，@After
divide@AfterReturning：{2}

可以看到，增强已经生效，下面现在开始分析源码；分析MathCalculator是何时被增强的(生成代理对象)，因为MathCalculator没有实现接口，那它应该无法用jdk动态代理来实现，而必须用CGLIB来实现？源码会解释一切。

先看第一行：new AnnotationConfigApplicationContext(MainConfigOfAOP.class)，这是一个构建方法，代码如下：

public AnnotationConfigApplicationContext(Class... annotatedClasses) {
	this();
	register(annotatedClasses);
	refresh();
}

重度看refresh()方法里面的操作；

@Override
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        try {
            // Instantiate all remaining (non-lazy-init) singletons.
            finishBeanFactoryInitialization(beanFactory);
        }
    }
}

我们要看的MathCalculator是如何被增强处理的，看主要代码finishBeanFactoryInitialization(beanFactory)中，进入方法：

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // Initialize conversion service for this context.
    if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
            beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
        beanFactory.setConversionService(
                beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
    }

    // Register a default embedded value resolver if no bean post-processor
    // (such as a PropertyPlaceholderConfigurer bean) registered any before:
    // at this point, primarily for resolution in annotation attribute values.
    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
            @Override
            public String resolveStringValue(String strVal) {
                return getEnvironment().resolvePlaceholders(strVal);
            }
        });
    }

    // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    for (String weaverAwareName : weaverAwareNames) {
        getBean(weaverAwareName);
    }

    // Stop using the temporary ClassLoader for type matching.
    beanFactory.setTempClassLoader(null);

    // Allow for caching all bean definition metadata, not expecting further changes.
    beanFactory.freezeConfiguration();

    // Instantiate all remaining (non-lazy-init) singletons.
    beanFactory.preInstantiateSingletons();
}

我们要看的在最后一行：beanFactory.preInstantiateSingletons()，该beanFactory是DefaultListableBeanFactory，继续进入preInstantiateSingletons方法：

@Override
public void preInstantiateSingletons() throws BeansException {
    if (this.logger.isDebugEnabled()) {
        this.logger.debug("Pre-instantiating singletons in " + this);
    }

    // Iterate over a copy to allow for init methods which in turn register new bean definitions.
    // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
    List beanNames = new ArrayList(this.beanDefinitionNames);

    // Trigger initialization of all non-lazy singleton beans...
    for (String beanName : beanNames) {
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            if (isFactoryBean(beanName)) {
                final FactoryBean factory = (FactoryBean) getBean(FACTORY_BEAN_PREFIX + beanName);
                boolean isEagerInit;
                if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                    isEagerInit = AccessController.doPrivileged(new PrivilegedAction() {
                        @Override
                        public Boolean run() {
                            return ((SmartFactoryBean) factory).isEagerInit();
                        }
                    }, getAccessControlContext());
                }
                else {
                    isEagerInit = (factory instanceof SmartFactoryBean &&
                            ((SmartFactoryBean) factory).isEagerInit());
                }
                if (isEagerInit) {
                    getBean(beanName);
                }
            }
            else {
                getBean(beanName);
            }
        }
    }

    // Trigger post-initialization callback for all applicable beans...
    for (String beanName : beanNames) {
        Object singletonInstance = getSingleton(beanName);
        if (singletonInstance instanceof SmartInitializingSingleton) {
            final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged(new PrivilegedAction