spring-beanFactory三

前两篇简单介绍了XmlBeanFactory如何加载xml以及如何创建bean，这都是完全基于xml配置的，那么注解又是如何处理的呢？以@Component和@Resource为例简单说明。

XmlBeanFactory factory = new XmlBeanFactory(new ClassPathResource("spring/spring-test.xml"));
//BeanFactory不会自动添加BeanPostProcessor（ApplicationContext会），有了CommonAnnotationBeanPostProcessor就可以使用@Resource、@PreDestroy、@AfterConstruct了
CommonAnnotationBeanPostProcessor commonAnnotationBeanPostProcessor = new CommonAnnotationBeanPostProcessor();
commonAnnotationBeanPostProcessor.setBeanFactory(factory);
factory.addBeanPostProcessor(commonAnnotationBeanPostProcessor);
MyBean bean = (MyBean) factory.getBean("myBean");
System.out.println(bean.name());//my bean

@Component("myBean")
public class MyBean {
    @Resource
    private MyBean myBean;
    private String name = "my bean";
    public String name() {
        return myBean.name;
    }
}

<beans
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns="http://www.springframework.org/schema/beans"
        xmlns:context="http://www.springframework.org/schema/context"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">
    <context:component-scan base-package="com.zyong.spring.beanfactory" />
</beans>

之前有提到过，将xml解析成Document后就会注册bean definitions，注册bean definition的过程就是解析Document的过程，之前分析了parseDefaultElement是处理bean标签的主要方法，现在来看delegate.parseCustomElement方法，它会处理一些复杂标签，比如component-scan。

//DefaultBeanDefinitionDocumentReader的parseBeanDefinitions方法，有删减
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
    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)) {
                parseDefaultElement(ele, delegate);
            }
            else {
                delegate.parseCustomElement(ele);
            }
        }
    }
}

public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
    //得到namespace，这里对于context:component-scan就是http://www.springframework.org/schema/context
    String namespaceUri = getNamespaceURI(ele);
    //spring会预注册一些NamespaceHandler，此处就会得到ContextNamespaceHandler
    NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
    if (handler == null) {
        error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
        return null;
    }
    //使用NamespaceHandler解析该DOM节点
    return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}

public class ContextNamespaceHandler extends NamespaceHandlerSupport {
    //init方法会在NamespaceHandler构造完成后回调
    @Override
    public void init() {
        registerBeanDefinitionParser("property-placeholder", new PropertyPlaceholderBeanDefinitionParser());
        registerBeanDefinitionParser("property-override", new PropertyOverrideBeanDefinitionParser());
        registerBeanDefinitionParser("annotation-config", new AnnotationConfigBeanDefinitionParser());
        //NamespaceHandlerSupport中持有BeanDefinitionParser，
        //handler.parse会调用findParserForElement(element, parserContext).parse(element, parserContext)，
        //即将parse任务委托给具体的BeanDefinitionParser，这里就是ComponentScanBeanDefinitionParser
        registerBeanDefinitionParser("component-scan", new ComponentScanBeanDefinitionParser());
        registerBeanDefinitionParser("load-time-weaver", new LoadTimeWeaverBeanDefinitionParser());
        registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
        registerBeanDefinitionParser("mbean-export", new MBeanExportBeanDefinitionParser());
        registerBeanDefinitionParser("mbean-server", new MBeanServerBeanDefinitionParser());
    }
}

//ComponentScanBeanDefinitionParser的parse方法，该方法与解析bean标签类似，最终都会产生bean definition并注册。
public BeanDefinition parse(Element element, ParserContext parserContext) {
    //得到package信息
    String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);
    //进一步分析package路径
    basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);
    String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,
            ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);

    // Actually scan for bean definitions and register them.
    ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
    //doScan会遍历package下的类，通过filters检查是否应该将类注册为bean，如果检查通过则注册该bean definition。
    //filters就会包含AnnotationTypeFilter，其annotationType为org.springframework.stereotype.Component，如果被检查类有@Compenent注解则将其视为bean
    Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);

    registerComponents(parserContext.getReaderContext(), beanDefinitions, element);

    return null;
}

至此就将使用注解声明的bean注册进beanFactory了（还未实例化），由于此时在bean中使用了注解@Resource进行注入，故与xml注入有所差异。
由下表可知，beanFactory不会自动注册BeanPostProcessor，而通过文档发现注解的注入其实就是通过BeanPostProcessor完成的，所以测试代码中才会显示添加CommonAnnotationBeanPostProcessor，有了CommonAnnotationBeanPostProcessor就可以使用@Resource、@PreDestroy、@AfterConstruct了。

Feature	BeanFactory	ApplicationContext
Bean instantiation/wiring	Yes	Yes
Automatic BeanPostProcessor registration	No	Yes
Automatic BeanFactoryPostProcessor registration	No	Yes
Convenient MessageSource access (for i18n)	No	Yes
ApplicationEvent publication	No	Yes

CommonAnnotationBeanPostProcessor是一个InstantiationAwareBeanPostProcessor，这里我们只关注其postProcessPropertyValues方法。

//CommonAnnotationBeanPostProcessor的postProcessPropertyValues方法
public PropertyValues postProcessPropertyValues(
        PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {

    InjectionMetadata metadata = findResourceMetadata(beanName, bean.getClass(), pvs);
    try {
        //注入，注入逻辑无非就是遍历可注入属性（字段、方法），进行反射调用。
        metadata.inject(bean, beanName, pvs);
    }
    catch (Throwable ex) {
        throw new BeanCreationException(beanName, "Injection of resource dependencies failed", ex);
    }
    return pvs;
}

附：