spring源码aop解析xml生成bean定义信息

spring面向切面编程是咱们工作中使用比较频繁的一项技术，比如：日志、事务、表单重复提交等
了解aop之前需要先了解几个概念

1. 什么是aspect ：切面
2. 什么是连接点：切面方法参数
3. 切入点表达式：用于过滤目标方法的过滤器
4. 什么是织入：通知方法的总称
5. 什么是目标方法：被代理的对象方法

看下AOP处理器 ConfigBeanDefinitionParser
总结下：
Advice有五个类别：AspectJMethodBeforeAdvice、AspectJAfterAdvice、AspectJAfterReturningAdvice、AspectJAfterThrowingAdvice、AspectJAroundAdvice；这5个类别都需要三个构造方法，（Method aspectJAroundAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aif），并且需要pointcut的支持去拦截目标对象方法；所有的通知最后会被包装成Advisor

public class AopNamespaceHandler extends NamespaceHandlerSupport {
	@Override
	public void init() {
		registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
		registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
		registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());
		registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
	}
}

xml配置

<bean id="bookServiceImpl" class="com.msgqu.debug.aop.service.BookServiceImpl"></bean>
<!-- 配置切面的bean -->
<bean id="logAspect" class="com.msgqu.debug.aop.log.LogAspect"></bean>
<!-- 配置AOP -->
<aop:config>
	<!-- 配置切点表达式 -->
	<aop:pointcut id="pointcut" expression="execution(* com.msgqu.debug.aop.service.*.*(..))"/>
	<!-- 配置切面及通知 -->
	<aop:aspect ref="logAspect">
		<aop:before method="before" pointcut-ref="pointcut"/>
		<aop:around method="around" pointcut-ref="pointcut"/>
		<aop:after-returning method="afterReturning" pointcut-ref="pointcut" returning="result"/>
		<aop:after-throwing method="afterThrowing" pointcut-ref="pointcut" throwing="e"/>
		<aop:after method="after" pointcut-ref="pointcut"/>
	</aop:aspect>
</aop:config>

解析自定义标签

public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
		// 获取到命名空间url，aop的在spring-aop服务下的 META-INF文件夹下的spring.handlers文件中配置
		String namespaceUri = getNamespaceURI(ele);
		if (namespaceUri == null) {
			return null;
		}
		// 根据namespaceUri找到对应的处理器
		NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
		if (handler == null) {
			error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
			return null;
		}
		// 使用对应命名空间解析器执行解析
		return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
	}

获取对应的解析器，并进行解析

public BeanDefinition parse(Element element, ParserContext parserContext) {
	BeanDefinitionParser parser = findParserForElement(element, parserContext);
	return (parser != null ? parser.parse(element, parserContext) : null);
}

获取bean定义信息的解析器

private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
	// 获取标签名称 如：aop：config解析成config
	String localName = parserContext.getDelegate().getLocalName(element);
	// 根据标签名称获取对应解析器
	BeanDefinitionParser parser = this.parsers.get(localName);
	if (parser == null) {
		parserContext.getReaderContext().fatal("Cannot locate BeanDefinitionParser for element [" + localName + "]", element);
	}
	return parser;
}

ConfigBeanDefinitionParser.parse 根据标签解析bean定义信息

// parserContext包含三个重点信息：1、xml上下文读取器2、bean定义信息的解析委托器3、一个栈
public BeanDefinition parse(Element element, ParserContext parserContext) {
	// 创建一个复合的组件定义信息
	CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), parserContext.extractSource(element));
	// 把当前标签的定义信息放入栈中
	parserContext.pushContainingComponent(compositeDef);
	// 现在parserContext中包含了解析后bean定义信息
	// 配置自动代理创建器
	configureAutoProxyCreator(parserContext, element);
	// 获取到aop:config下的子标签
	List<Element> childElts = DomUtils.getChildElements(element);
	for (Element elt: childElts) {
		String localName = parserContext.getDelegate().getLocalName(elt);
		if (POINTCUT.equals(localName)) {
			parsePointcut(elt, parserContext);
		}
		else if (ADVISOR.equals(localName)) {
			parseAdvisor(elt, parserContext);
		}
		else if (ASPECT.equals(localName)) {
			parseAspect(elt, parserContext);
		}
	}

	parserContext.popAndRegisterContainingComponent();
	return null;
}

configureAutoProxyCreator 配置自动代理创建器

private void configureAutoProxyCreator(ParserContext parserContext, Element element) {
	//如果需要注册Aspectj自动代理创建器
	AopNamespaceUtils.registerAspectJAutoProxyCreatorIfNecessary(parserContext, element);
}
// xml和注解底层处理逻辑基本是一致的
// @Import(AspectJAutoProxyRegistrar.class)
// public @interface EnableAspectJAutoProxy {
// 咱们springboot 使用的这个注解@EnableAspectJAutoProxy底层也是调用的这个方法
public static void registerAspectJAutoProxyCreatorIfNecessary(ParserContext parserContext, Element sourceElement) {
	// 这里主要是注册了一个AspectJAwareAdvisorAutoProxyCreator的bean定义信息
	BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAutoProxyCreatorIfNecessary(parserContext.getRegistry(), parserContext.extractSource(sourceElement));
	// 设置配置的属性，未配置，默认为false，不进行设置 proxy-target-class、expose-proxy
	useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
	// 注册到复合组件中 （CompositeComponentDefinition aop:config中）
	registerComponentIfNecessary(beanDefinition, parserContext);
}

// 向工厂中注册一个org.springframework.aop.config.internalAutoProxyCreator的bean定义信息
public static BeanDefinition registerAspectJAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, @Nullable Object source) {
	//实际干活的方法
	return registerOrEscalateApcAsRequired(AspectJAwareAdvisorAutoProxyCreator.class, registry, source);
}

private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {
	Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
	//如果bean定义信息Map中存在org.springframework.aop.config.internalAutoProxyCreator
	if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
		BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
		// 如果class信息不一致，重新设置下优先级
		if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
			int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
			int requiredPriority = findPriorityForClass(cls);
			if (currentPriority < requiredPriority) {
				apcDefinition.setBeanClassName(cls.getName());
			}
		}
		// 已经存在bean定义信息了，无需走下面的流程了
		return null;
	}
	// 创建一个bean定义信息
	RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
	beanDefinition.setSource(source);
	// 设置最高的优先级
	beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
	// 设置bean定义信息的角色为内部使用的bean
	beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
	// 注册到工厂中
	registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
	return beanDefinition;
}

parsePointcut 解析pointcut

private AbstractBeanDefinition parsePointcut(Element pointcutElement, ParserContext parserContext) {
	// 获取标签id
	String id = pointcutElement.getAttribute(ID);
	// 获取标签表达式
	String expression = pointcutElement.getAttribute(EXPRESSION);
	AbstractBeanDefinition pointcutDefinition = null;
	try {
		// 把pointcut的id放到队列
		this.parseState.push(new PointcutEntry(id));
		// 创建pointcut定义信息 class=AspectJExpressionPointcut.class
		// 这里比较有意思的是原型模式
		pointcutDefinition = createPointcutDefinition(expression);	pointcutDefinition.setSource(parserContext.extractSource(pointcutElement));
		// 注册pointcut bean定义信息
		String pointcutBeanName = id;
		if (StringUtils.hasText(pointcutBeanName)) {
			parserContext.getRegistry().registerBeanDefinition(pointcutBeanName, pointcutDefinition);
		}else {
			pointcutBeanName = parserContext.getReaderContext().registerWithGeneratedName(pointcutDefinition);
		}
		// 前面咱们已经注册了一个AutoProxyCreate，现在又注册了一个pointcut
		parserContext.registerComponent(new PointcutComponentDefinition(pointcutBeanName, pointcutDefinition, expression));
	}finally {
		this.parseState.pop();
	}
	return pointcutDefinition;
}

parseAspect 解析aspect标签

所有的通知advice统称为advisor（顾问）

private void parseAspect(Element aspectElement, ParserContext parserContext) {
	String aspectId = aspectElement.getAttribute(ID);
	// 获取到切面引用id
	String aspectName = aspectElement.getAttribute(REF);
	try {
		// 标识解析到哪个标签
		this.parseState.push(new AspectEntry(aspectId, aspectName));
		List<BeanDefinition> beanDefinitions = new ArrayList<>();
		List<BeanReference> beanReferences = new ArrayList<>();
		// 这里可以忽略，一般不会配置
		List<Element> declareParents = DomUtils.getChildElementsByTagName(aspectElement, DECLARE_PARENTS);
		for (int i = METHOD_INDEX; i < declareParents.size(); i++) {
			Element declareParentsElement = declareParents.get(i);
			beanDefinitions.add(parseDeclareParents(declareParentsElement, parserContext));
		}
		// 获取到aspect的子标签通知
		NodeList nodeList = aspectElement.getChildNodes();
		boolean adviceFoundAlready = false;
		for (int i = 0; i < nodeList.getLength(); i++) {
			Node node = nodeList.item(i);
			// 验证是这些标签才会解析（before、after、after-returning、after-throwing、around）
			if (isAdviceNode(node, parserContext)) {
				if (!adviceFoundAlready) {
					adviceFoundAlready = true;
					if (!StringUtils.hasText(aspectName)) {
						parserContext.getReaderContext().error("<aspect> tag needs aspect bean reference via 'ref' attribute when declaring advices.",aspectElement, this.parseState.snapshot());
						return;
					}
					beanReferences.add(new RuntimeBeanReference(aspectName));
				}
				// 创建advisor定义信息
				AbstractBeanDefinition advisorDefinition = parseAdvice(aspectName, i, aspectElement, (Element) node, parserContext, beanDefinitions, beanReferences);
				// 添加到容器
				beanDefinitions.add(advisorDefinition);
			}
		}
		// 创建aspect组件定义信息
		AspectComponentDefinition aspectComponentDefinition = createAspectComponentDefinition(aspectElement, aspectId, beanDefinitions, beanReferences, parserContext);
		// 注册到aop:config定义信息的嵌套组件集合中
		parserContext.pushContainingComponent(aspectComponentDefinition);
		List<Element> pointcuts = DomUtils.getChildElementsByTagName(aspectElement, POINTCUT);
		for (Element pointcutElement : pointcuts) {
			parsePointcut(pointcutElement, parserContext);
		}
		// 注册到
		parserContext.popAndRegisterContainingComponent();
	}
	finally {
		this.parseState.pop();
	}
}

parseAdvice 解析通知生成bean定义信息

private AbstractBeanDefinition parseAdvice(
			String aspectName, int order, Element aspectElement, Element adviceElement, ParserContext parserContext,
			List<BeanDefinition> beanDefinitions, List<BeanReference> beanReferences) {

	try {
		// 记录解析栈
		this.parseState.push(new AdviceEntry(parserContext.getDelegate().getLocalName(adviceElement)));

		// create the method factory bean
		// 创建MethodLocatingFactoryBean的定义信息
		RootBeanDefinition methodDefinition = new RootBeanDefinition(MethodLocatingFactoryBean.class);
		methodDefinition.getPropertyValues().add("targetBeanName", aspectName);
		methodDefinition.getPropertyValues().add("methodName", adviceElement.getAttribute("method"));
		methodDefinition.setSynthetic(true);

		// create instance factory definition
		// 准备AOP的实例工厂，工厂是一个BeanFactoryAware
		RootBeanDefinition aspectFactoryDef = new RootBeanDefinition(SimpleBeanFactoryAwareAspectInstanceFactory.class);
		aspectFactoryDef.getPropertyValues().add("aspectBeanName", aspectName);
		aspectFactoryDef.setSynthetic(true);
		// register the pointcut
		// advice对应的class AspectJMethodBeforeAdvice、AspectJAfterAdvice、AspectJAfterReturningAdvice、AspectJAfterThrowingAdvice、AspectJAroundAdvice
		AbstractBeanDefinition adviceDef = createAdviceDefinition(adviceElement, parserContext, aspectName, order, methodDefinition, aspectFactoryDef,beanDefinitions, beanReferences);
		// configure the advisor
		// 创建顾问定义信息
		RootBeanDefinition advisorDefinition = new RootBeanDefinition(AspectJPointcutAdvisor.class);
		advisorDefinition.setSource(parserContext.extractSource(adviceElement));
		advisorDefinition.getConstructorArgumentValues().addGenericArgumentValue(adviceDef);
		if (aspectElement.hasAttribute(ORDER_PROPERTY)) {
			advisorDefinition.getPropertyValues().add(ORDER_PROPERTY, aspectElement.getAttribute(ORDER_PROPERTY));
		}
		// register the final advisor
		// 通知的定义信息并没有进行注册，只注册了advisor到容器中
		parserContext.getReaderContext().registerWithGeneratedName(advisorDefinition);
		return advisorDefinition;
	}
	finally {
		this.parseState.pop();
	}
}

createAdviceDefinition 创建通知的定义信息

private AbstractBeanDefinition createAdviceDefinition(
			Element adviceElement, ParserContext parserContext, String aspectName, int order,
			RootBeanDefinition methodDef, RootBeanDefinition aspectFactoryDef,
			List<BeanDefinition> beanDefinitions, List<BeanReference> beanReferences) {
	// 创建advice定义信息
	// 这里class可能为AspectJMethodBeforeAdvice、AspectJAfterAdvice、AspectJAfterReturningAdvice、AspectJAfterThrowingAdvice、AspectJAroundAdvice
	RootBeanDefinition adviceDefinition = new RootBeanDefinition(getAdviceClass(adviceElement, parserContext));
	adviceDefinition.setSource(parserContext.extractSource(adviceElement));
	//设置切面的名称
	adviceDefinition.getPropertyValues().add(ASPECT_NAME_PROPERTY, aspectName);
	// 设置优先级
	adviceDefinition.getPropertyValues().add(DECLARATION_ORDER_PROPERTY, order);
	// 设置returning
	if (adviceElement.hasAttribute(RETURNING)) {
		adviceDefinition.getPropertyValues().add(RETURNING_PROPERTY, adviceElement.getAttribute(RETURNING));
	}
	// 设置throwing
	if (adviceElement.hasAttribute(THROWING)) {
		adviceDefinition.getPropertyValues().add(THROWING_PROPERTY, adviceElement.getAttribute(THROWING));
	}
	// 设置参数名称
	if (adviceElement.hasAttribute(ARG_NAMES)) {
		adviceDefinition.getPropertyValues().add(ARG_NAMES_PROPERTY, adviceElement.getAttribute(ARG_NAMES));
	}
	// 获取构造方法参数，并按照参数下标赋值
	// 构造方法在AbstractAspectJAdvice中有定义
	// Method aspectJAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aspectInstanceFactory
	// aspectJAdviceMethod当前的通知方法，pointcut是切入点表达式，aspectInstanceFactory实例工厂
	ConstructorArgumentValues cav = adviceDefinition.getConstructorArgumentValues();
	// 设置当前通知
	cav.addIndexedArgumentValue(METHOD_INDEX, methodDef);
	// 设置切入点表达式
	Object pointcut = parsePointcutProperty(adviceElement, parserContext);
	if (pointcut instanceof BeanDefinition) {
		cav.addIndexedArgumentValue(POINTCUT_INDEX, pointcut);
		beanDefinitions.add((BeanDefinition) pointcut);
	}
	else if (pointcut instanceof String) {
		RuntimeBeanReference pointcutRef = new RuntimeBeanReference((String) pointcut);
		cav.addIndexedArgumentValue(POINTCUT_INDEX, pointcutRef);
		beanReferences.add(pointcutRef);
	}
	// 设置实例工厂
	cav.addIndexedArgumentValue(ASPECT_INSTANCE_FACTORY_INDEX, aspectFactoryDef);
	// 返回定义信息
	return adviceDefinition;
}

以上是个人观点，有错误的地方还请指出，谢谢了