Spring AOP原理

@EnableAspectJAutoProxy　

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

AspectJAutoProxyRegistrar　　

AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

　　创建Bean（AnnotationAwareAspectJAutoProxyCreator）的定义

RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
beanDefinition.setSource(source);
beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
// AUTO_PROXY_CREATOR_BEAN_NAME=org.springframework.aop.config.internalAutoProxyCreator
registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
return beanDefinition;

AnnotationAwareAspectJAutoProxyCreator　

 

 　　实现setBeanFactory方法　　

@Override
public void setBeanFactory(BeanFactory beanFactory) {
	super.setBeanFactory(beanFactory);
	if (!(beanFactory instanceof ConfigurableListableBeanFactory)) {
		throw new IllegalArgumentException(
				"AdvisorAutoProxyCreator requires a ConfigurableListableBeanFactory: " + beanFactory);
	}
	initBeanFactory((ConfigurableListableBeanFactory) beanFactory);
}

　　重写initBeanFactory方法

@Override
protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	super.initBeanFactory(beanFactory);
	if (this.aspectJAdvisorFactory == null) {
		this.aspectJAdvisorFactory = new ReflectiveAspectJAdvisorFactory(beanFactory);
	}
	this.aspectJAdvisorsBuilder =
			new BeanFactoryAspectJAdvisorsBuilderAdapter(beanFactory, this.aspectJAdvisorFactory);
}

　　流程　　

　　1）、传入配置类，创建IOC容器

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(TxConfig.class);
		

　　2）、注册配置类调用refresh方法刷新容器

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

　　3）、注册Bean的后置处理器

// Register bean processors that intercept bean creation.
// 注册拦截bean创建的bean后置处理器
registerBeanPostProcessors(beanFactory);

　　3.1）、获取IOC容器中已有的BeanPostProcessor的定义Bean

String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

　　3.2）、添加一些其他的BeanPostProcessor

beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

　　3.3）、分离实现了PriorityOrdered接口、实现了Ordered接口、普通的BeanPostProcessor，并创建对象

// Separate between BeanPostProcessors that implement PriorityOrdered,Ordered, and the rest.
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);

　　参见创建Bean实例的步骤

　　3.4）、注册BeanPostProcessor

private static void registerBeanPostProcessors(
		ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {

	for (BeanPostProcessor postProcessor : postProcessors) {
		beanFactory.addBeanPostProcessor(postProcessor);
	}
}　　

创建Bean实例的步骤　　

　　1）、ConfigurableListableBeanFactory

<T> T getBean(String name, Class<T> requiredType) throws BeansException;

　　2）、AbstractBeanFactory

@Override
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
	return doGetBean(name, requiredType, null, false);
}

　　3）、AbstractBeanFactory的doGetBean方法获取单例对象

// Create bean instance.
if (mbd.isSingleton()) {
	sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
		@Override
		public Object getObject() throws BeansException {
			try {
				return createBean(beanName, mbd, args);
			}
			catch (BeansException ex) {
				// Explicitly remove instance from singleton cache: It might have been put there
				// eagerly by the creation process, to allow for circular reference resolution.
				// Also remove any beans that received a temporary reference to the bean.
				destroySingleton(beanName);
				throw ex;
			}
		}
	});
	bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}

　　4）、AbstractAutowireCapableBeanFactory的creatBean方法，在IOC容器中未找到Bean则创建Bean实例

// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
// 给BeanPostProcessors一个机会去创建代理对象代替Bean实例
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
	return bean;
}
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
return beanInstance;

　　5）、AbstractAutowireCapableBeanFactory的doCreateBean方法

// 实例化Bean，创建Bean对象
if (instanceWrapper == null) {
	instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 为Bean对象的属性赋初始值
populateBean(beanName, mbd, instanceWrapper);
// 初始化Bean，可能调用类的init方法或afterPropertiesSet方法
if (exposedObject != null) {
	exposedObject = initializeBean(beanName, exposedObject, mbd);
}

　　6）、AbstractAutowireCapableBeanFactory的initializeBean方法

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
	if (System.getSecurityManager() != null) {
		AccessController.doPrivileged(new PrivilegedAction<Object>() {
			@Override
			public Object run() {
				invokeAwareMethods(beanName, bean);
				return null;
			}
		}, getAccessControlContext());
	}
	else {
		// 如果Bean实现了xxxAware接口的话则调用setXXX方法注入相应对象
		invokeAwareMethods(beanName, bean);
	}

	Object wrappedBean = bean;
	if (mbd == null || !mbd.isSynthetic()) {
		// 执行初始化的前置操作
		wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
	}

	try {
		// 如果bean实现了InitializingBean接口则调用afterPropertiesSet方法
		invokeInitMethods(beanName, wrappedBean, mbd);
	}
	catch (Throwable ex) {
		throw new BeanCreationException(
				(mbd != null ? mbd.getResourceDescription() : null),
				beanName, "Invocation of init method failed", ex);
	}

	if (mbd == null || !mbd.isSynthetic()) {
		// 执行初始化的后置操作
		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
	}
	return wrappedBean;
}

　　　

来源：https://www.cnblogs.com/BINGJJFLY/p/12252569.html