spring AOP源码分析（一）
对于springAOP的源码分析，我打算分三部分来讲解：1.配置文件的解析，解析为BeanDefination和其他信息然后注册到BeanFactory中；2.为目标对象配置增强行为以及代理对象的生成，可以理解为AOP的准备阶段；3.代理对象调用方法，增强行为的触发执行，此时是AOP生效的阶段。我们可以把1,2理解为IOC阶段；2,3理解为AOP阶段。
我们先看第一部分：BeanDefination的解析注册过程
由一个demo进入源码分析，创建一个接口UserDao
public interface UserDao { void addUser(); void deleteUser(); }
创建UserDaoImpl类
public class UserDaoImpl implements UserDao{ public void addUser() { System.out.println("add user "); } public void deleteUser() { System.out.println("delete user "); } }
创建一个Logger类
public class Logger { public void recordBefore(){ System.out.println("recordBefore"); } public void recordAfter(){ System.out.println("recordAfter"); } }
在aop.xml中添加配置信息
<bean id="userDao" class="com.demo.aop.sourcecode.UserDaoImpl"/> <bean id="logger" class="com.demo.aop.sourcecode.Logger" /> <!-- 切面：切入点和通知 --> <aop:config> <aop:aspect id="logger" ref="logger"> <aop:pointcut expression="execution(* com.demo.aop.sourcecode..*.*(..))" id="udpateUserMethod" /> <aop:before method="recordBefore" pointcut-ref="udpateUserMethod" /> <aop:after method="recordAfter" pointcut-ref="udpateUserMethod" /> </aop:aspect> </aop:config>
写测试方法
@Test public void testAop(){ ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("aop.xml");//BeanDefination的解析注册，代理对象的生成 UserDao userDao = (UserDao) applicationContext.getBean("userDao");//可以看到userDao类型是以$Proxy开头的，说明是通过JDK动态代理的方式获取的 userDao.addUser();//增强行为发生的时刻 }
进入到AbstractApplicationContext类中的refresh方法
public void refresh() throws BeansException, IllegalStateException { synchronized (this.startupShutdownMonitor) { // Prepare this context for refreshing. prepareRefresh(); // Tell the subclass to refresh the internal bean factory.
//BeanDefination的解析注册在这个方法中发生，进入这个方法 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // Prepare the bean factory for use in this context. prepareBeanFactory(beanFactory); try { // Allows post-processing of the bean factory in context subclasses. postProcessBeanFactory(beanFactory); // Invoke factory processors registered as beans in the context. invokeBeanFactoryPostProcessors(beanFactory); // Register bean processors that intercept bean creation. 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) { if (logger.isWarnEnabled()) { logger.warn("Exception encountered during context initialization - " + "cancelling refresh attempt: " + ex); } // Destroy already created singletons to avoid dangling resources. destroyBeans(); // Reset 'active' flag. cancelRefresh(ex); // Propagate exception to caller. throw ex; } finally { // Reset common introspection caches in Spring's core, since we // might not ever need metadata for singleton beans anymore... resetCommonCaches(); } } }
通过一步步追踪，我们可以进入DefaultBeanDefinitionDocumentReader类中的parseBeanDefinitions方法
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
//判断是否是默认的命名空间，默认的命名空间是 http://www.springframework.org/schema/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; if (delegate.isDefaultNamespace(ele)) {
//在aop.xml文件中，对userDao和logger的定义将在这里处理 parseDefaultElement(ele, delegate); } else {
//对<aop:config>的定义在这里处理，因为它的命名空间是 http://www.springframework.org/schema/aop 进入该方法 delegate.parseCustomElement(ele); } } } } else { delegate.parseCustomElement(root); } }
进入parseCustomElement方法，然后可以追踪到以下方法
public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) { String namespaceUri = getNamespaceURI(ele);
//此处的handler为AopNamespaceHandler，接下来将用它对<aop:config>进行解析 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)); }
进入NamespaceHandlerSupport类中的parse方法
public BeanDefinition parse(Element element, ParserContext parserContext) { return findParserForElement(element, parserContext).parse(element, parserContext); }
由于<aop:config>的解析是由ConfigBeanDefinitionParser类来完成的，所以进入该类的parse方法，看解析过程
@Override public BeanDefinition parse(Element element, ParserContext parserContext) { CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), parserContext.extractSource(element)); parserContext.pushContainingComponent(compositeDef); configureAutoProxyCreator(parserContext, element); //获取子节点，根据aop.xml文件中的配置，子节点为<aop:aspect> 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)) {
//进入该方法，解析<aop:aspect> parseAspect(elt, parserContext); } } parserContext.popAndRegisterContainingComponent(); return null; }
进入parseAspect方法
private void parseAspect(Element aspectElement, ParserContext parserContext) {
//获取定义的切面ID和ref String aspectId = aspectElement.getAttribute(ID); String aspectName = aspectElement.getAttribute(REF); try {
//将获取到的切面ID和ref封装到AspectEntry这个类中 this.parseState.push(new AspectEntry(aspectId, aspectName));
//把<aop:before>等通知相关的信息封装到AspectJPointcutAdvisor中，然后放到该集合里 List<BeanDefinition> beanDefinitions = new ArrayList<BeanDefinition>();
//把ref相关的信息如aop.xml中的logger，updateUserMethod等封装到RunTimeBeanReference中，然后放到这个集合中 List<BeanReference> beanReferences = new ArrayList<BeanReference>(); 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)); } // We have to parse "advice" and all the advice kinds in one loop, to get the // ordering semantics right. NodeList nodeList = aspectElement.getChildNodes(); boolean adviceFoundAlready = false;
//循环切面的子节点，然后判断是否是通知，然后进行对应的处理 for (int i = 0; i < nodeList.getLength(); i++) { Node node = nodeList.item(i); 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; }
//封装ref信息 beanReferences.add(new RuntimeBeanReference(aspectName)); }
//把通知相关信息封装到AspectJPointcutAdvisor这个类中，同时封装ref信息然后放到BeanReferences中
//这个是解析通知的方法，可以进入看看 AbstractBeanDefinition advisorDefinition = parseAdvice( aspectName, i, aspectElement, (Element) node, parserContext, beanDefinitions, beanReferences); beanDefinitions.add(advisorDefinition); } } //把切面信息和通知信息封装到这个类中 AspectComponentDefinition aspectComponentDefinition = createAspectComponentDefinition( aspectElement, aspectId, beanDefinitions, beanReferences, parserContext); parserContext.pushContainingComponent(aspectComponentDefinition); //解析切入点，然后封装信息 List<Element> pointcuts = DomUtils.getChildElementsByTagName(aspectElement, POINTCUT); for (Element pointcutElement : pointcuts) {
//这个是具体解析切入点的方法 parsePointcut(pointcutElement, parserContext); } parserContext.popAndRegisterContainingComponent(); } finally { this.parseState.pop(); } }
其实我们可以看到，这个方法的目的就是解析<aop:aspect>中的配置信息然后封装到类中，最终都存放在了containingComponents这个栈中，方便后面使用，这就是整个解析过程。
在接下来的一篇博文中，我们讲解代理对象的生成，如何给目标对象配置增强行为的，也就是第二个阶段。
