zoukankan      html  css  js  c++  java
  • 用伪代码梳理spring源码

    1、第一个spring demo

    BeanFactory bf = new XmlBeanFactory(new ClassPathResource("beanFactoryTest.xml"));
    // 1. new ClassPathResource("beanFactoryTest.xml")
        |-- 配置文件封装 
            |-- interface InputStreamSource  
                |-- InputStream getInputStream();
            |-- interface Resource extends InputStreamSource 
                |-- boolean exists(); // 存在性
                |-- boolean isReadable(); // 可读性
                |-- boolean isOpen(); // 是否处于打开状态
                |-- URL getURL(); // 
                |-- URI getURI();
                |-- File getFile();
                |-- long lastModified();
                |-- Resource createRelative(String relitivePath);
                |-- String getFileName();
                |-- String getDescription();
            |-- ClassPathResource implements Resource {
                    @Override
                    InputStream getInputStream() {
                        if (this.clazz != null){
                            is = this.clazz.getResourceAsStream(this.path);
                        } else {
                            is = this.classLoader.getResourceAsStream(this.path);
                        }
                    }
                }
            |-- FileSystemResource implements Resource {
                    @Override
                    InputStream getInputStream() {
                        return new FileInputStream(this.file);
                    }
                }
            ...

    2、XmlBeanFactory跟踪

    // 2. new XmlBeanFactory(Resource resource)        
    |-- 2.1 XmlBeanFactory(Resource resource) throws BeansException {
    this(resource, null);
    }
    |-- 2.1 XmlBeanFactory(Resource resource, BeanFactory parentFactory) throws BeansException {
    super(parentFactory); // parentFactory为父类BeanFactory,用于factory合并,可以为空
    this.reader.loadBeanDefinitions(resource); // XmlBeanDefinitionReader reader;
    }
    |-- 2.1.1 super(parentFactory) 
    |-- class AbstractAutowrieCapableBeanFactory
    |-- public AbstractAutowrieCapableBeanFactory(){
    super();
    // 忽略给定接口的自动装配
    ignoreDependencyInterface(BeanNameAware.class); 
    ignoreDependencyInterface(BeanFactoryAware.class);
    ignoreDependencyInterface(BeanClassLoaderAware.class);
    }
    |-- 2.1.2 this.reader.loadBeanDefinitions(resource)
    |-- class XmlBeanDefinitionReader
    |-- int loadBeanDefinitions(Resource resource){
    return loadBeanDefinitions(new EncodedResource(resource));
    }
    |-- EncodedResource(Resource resource){
    this.resource = resource;
    }
    Reader getReader(){
    if (this.encoding != null){
    return new InputStreamReader(this.resource.getInputStream(), this.encoding);
    } else {
    return new InputStreamReader(this.resource.getInputStream());
    }
    }
    |-- int loadBeanDefinitions(EncodedResource encodedResource) {
    ...
    // 通过属性来记录已经加载的资源 this.resourceCurrentBeingLoaded -> new ThreadLocal<Set<EncodedResource>>;
    Set<EncodedResource> currentResources = this.resourceCurrentBeingLoaded.get();
    if (currentResource == null) {
    currentResources = new HashSet<EncodedResource>(4);
    this.resourceCurrentBeingLoaded.set(currentResources);
    }
    // 
    if (!currentResource.add(currentResource)){
    throw e;
    }
    try {
    InputStream inputStream = encodedResource.getResource().getInputStream();
    org.xml.sax.InputSource inputSource = new org.xml.sax.InputSource();
    // 设置编码
    if (encodedResource.getEncoding() != null) {
    inputSource.setEncoding(encodedResource.getEncoding());
    }
    // 真正进入业务逻辑处理
    return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
    } catch(e){
    ...
    } finally {
    ...
    }
    }
    |-- doLoadBeanDefinitions(inputSource, encodedResource.getResource())
    |-- int doLoadBeanDefinitions(InputSource inputSource, Resource resource){
    try {
    // 获取xml文件验证模式
    int validationModel = getValidationModeForResource(resource);
    // 加载xml文件得到对应的Document
    Document doc = this.documentLoader.loadDocument(
        inputSource, getEntityResolver(), this.errorHandler, validationModel, isNamespaceAware());
    // 根据返回的Document对象注册Bean信息
    return registerBeanDefinitions(doc, resource);
    } catch (e){
    ...
    }
    }
    |-- 2.1.2.1 获取xml文件验证模式
    |-- DTD
    <? xml version="1.0" encodind="UTF-8">
    <!DOCTYPE beans PUBLIC "-//spring//DTD BEAN 2.0//EN" "http://www.Springframework.org/dtd/Spring-beans-2.0.dtd">
    <beans>
    ...
    </beans>
    <!-- Spring-beans-2.0.dtd -->
    <!ELEMENT beans (
    description?,
    (import | alias | bean)*
    )>
    ... ...
    |-- XSD
    <? xml version="1.0" encodind="UTF-8">    
    <beans xlmns="..." 
    xlmns:xsi="..." 
    xlmns:schemaLocation=".../Spring-beans.xsd">
    ... ...
    </beans>
    <!-- Spring-beans.xsd -->
    <xsd:schema xlmns="..." xlmns:xsd="..." targetNamespace="...">
    <xsd:import namespace="..."/>
    <xsd:annotation>
        ...
    </xsd:annotation>
    </xsd:schema>
    |-- getValidationModeForResource(resource)
    |-- int getValidationModeForResource(Resource resource) {
        int validationModeToUse = getValidationMode();
        // 如果手动指定了验证模式则使用指定的验证模式
        if (validationModeToUse != VALIDATION_AUTO) {
            return validationModeToUse;
        }
        // 如果未指定则使用自动检测
        int detectedMode = dectectValidationMode(resource);
        if (detectedMode != null) {
            return detectedMode;
        }
        return VALIDATION_XSD;
    }
    |-- int dectectValidationMode (Resource resource) {
        if (resource.isOpen()) {
            throw e;
        }
        InputStream inputStream;
        try {
            inputStream = resource.getInputStream();
        } catch(e){
            throw e;
        }
        try {
            return this.validationModeDelector.detectValidationMode(inputStream);
        } catch(e){
            throw e;
        }
    }
    |-- int XmlValidationModeDetector.detectValidationMode(InputStream inputStream) {
        BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
        try {
            boolean isDtdValidated = false;
            String content;
            while ((content = reader.readLine())!= null){
                content = consumeCommentTokens(content);
                // 空行或者注释略过
                if (this.inComment || !StringUtils.hasText(content)){
                    continue
                }
                if (hasDoctype(content)) {
                    isDtdValidated = true;
                    break;
                }
                // 读取到<跳出
                if (hasOpeningTag(content)) {
                    break;
                }
            }
            return (isDtdValidated ? VALIDATION_DTD : VALIDATION_XSD);
        } catch (e){
            throw e;
        } finally {
            reader.close();
        }
    }
    boolean hasDoctype(String content){
        return (content.indexOf(DOCTYPE) > -1);
    }
    |-- 2.1.2.2 获取Document 
    |-- this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler, validationModel, isNamespaceAware())
    |-- DefaultDocumentLoader.loadDocument(InputSource inputSource, EntityResolver entityResolver, ErrorHandler errorHandler, int validationModel, boolean namespaceAware) {
        DocumentBuilderFactory factory = createDocumentBuilderFactory(validationModel, namespaceAware);
        DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);
        return builder.parse(inputSource);
    }
    |-- EntityResolver // 外部实体
    |-- InputSource resolveEntity(String publicId, String systemId)
    <!-- spring-beans.xsd -->
    <beans xsi:schemaLocation="http://www.Springframework.org/schema/beans http://www.Springframework.org/schema/beans/Spring-beans.xsd">
    ... ...
    </beans>
    --> 
        publicId: null,
        systemId: http://www.Springframework.org/schema/beans/Spring-beans.xsd
    <!-- spring-beans-2.0.dtd -->
    <!DOCTYPE beans PUBLIC "-//Spring//DTD BEAN 2.0//EN" "http://www.Springframework.org/dtd/Spring-beans-2.0.dtd">
    <beans>
    ... ... 
    </beans>
    --> 
        publicId: -//Spring//DTD BEAN 2.0//EN,
        systemId: http://www.Springframework.org/dtd/Spring-beans-2.0.dtd
    |-- getEntityResolver() -> DelegatingEntityResolver
    |-- InputSource resolveEntity(String publicId, String systemId) throws e{
            if (systemId != null) {
                if (systemId.endsWith(DTD_SUFFIX)){
                    // 如果是dtd
                    return this.dtdResolver.resolveEntity(publicId, systemId);
                } else if(systemId.endsWith(XSD_SUFFIX)) {
                    // 通过调用META-INF/Spring.schemas解析
                    return this.schemaResolver.resolveEntity(publicId, systemId);
                }
            }
            return null;
        }
    |-- BeansDtdResolver 
        |-- InputSource resolveEntity(String publicId, String systemId) {
                // DTD_EXTENSION=".dtd"
                if (systemId != null && systemId.endsWith(DTD_EXTENSION)){
                    int lastPathSeparator = systemId.lastIndexOf("/");
                    for (String DTD_NAME : DTD_NAMES) {
                        // DTD_NAMES={"Spring-beans-2.0","Spring-beans"}
                        int dtdNameStart = systemId.indexOf(DTD_NAME);
                        if (dtdNameStart > lastPathSeparator) {
                            String dtdFile = systemId.substring(lastPathSeparator);
                            try {
                                Resource resource = new ClassPathReource(dtdFile, getClass());
                                InputSource source = new InputSource(resource.getInputStream());
                                source.setPulicId(publicId);
                                source.setSystemId(systemId);
                                return source;
                            } catch (e) {
                                throw e;
                            }
                        }
                    }
                }
                return null;
            }
    |-- 2.1.2.3 解析及注册BeanDefinitions
    |-- registerBeanDefinitions(doc, resource)
    |-- XmlBeanDefinitionReader {
        public int registerBeanDefinitions(Document doc, Resource resource) {
            // 使用默认的DefaultBeanDefinitionDocumentReader实例化BeanDefinitionDocumentReader
            BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
            // 将环境变量设置其中
            documentReader.setEnvironment(this.getEnvironment());
            // 在实例化BeanDefinitionDocumentReader时会将BeanDefinionRegistry传入,默认使用继承自DefaultListableBeanFactory的子类
            // 记录统计前BeanDefiniton的加载个数
            int countBefore = getRegistry().getBeanDefinitionCount();
            // 加载及注册bean
            documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
            // 记录本次加载的BeanDefinition个数
            return getRegistry().getBeanDefinitionCount() - countBefore;
        }
        
        public int registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
            this.readerContext = readerContext;
            Element root = doc.getElement();
            doRegisterBeanDefinitions(root);
        }
        
        // 核心方法
        protected void doRegisterBeanDefinitions(Element root){
            // 处理profile
            /**
             * <!-- spring.xml -->
             * <beans profiles="dev"> ... </beans>
             * <beans profiles="test"> ... </beans>
             * <beans profiles="prod"> ... </beans>
             * <!-- web.xml -->
             * <context-param> 
             *     <param-name>Spring.profiles.active</param-name>
             *     <param-value>dev|test|prod</param-value>
             * </>
             */
            String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
            if (StringUtils.hasText(profileSpec)) {
                String[] specfiedProfiles = StringUtils.tokenizedToStringArray(profileSpec, ",");
                if (!this.environment.acceptsProfiles(specfiedProfiles)) {
                    return;
                }
            }
            // 专门处理解析
            BeanDefinitionParserDelegate parent = this.delegate;
            this.delegate = createHelper(readerContext, root, parent);
            // begin
            preProcessXml(root); // 钩子方法
            parseBeanDefinitions(root, this.delegate);
            postProcessXml(root); // 钩子方法
            // end
            this.delegate = parent;
        }
        
        // 专门处理解析
        /**
         * 默认标签:<bean id="test" class="test.TestBean"/>
         * 自定义标签:<tx:annotation-driven/>
         */
        protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
            // 对beans的处理 
            if (delegate.isDefaultNamespace(root)) {
                NodeList nl = root.getChildNodes();
                for (int i = 0; i < nl.length(); i++) {
                    Node node = nl.item(i);
                    if (node instanceof Element) {
                        Element ele = (Element) node;
                        // 对bean的处理
                        parseDefaultElement(ele, delegate);
                    } else {
                        // 对bean的处理
                        delegate.parseCustomElement(ele);
                    }
                }
            } else {
                // 对bean的处理
                delegate.parseCustomElement(ele);
            }
        }
    }

    3、默认标签的解析

    |-- 3 默认标签的解析
    |-- private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
    // 对import标签处理
    if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)){
        importBeanDefinitionResource(ele);
    }
    // 对alias标签处理
    else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)){
        processAliasRegistration(ele);
    }
    // 对bean标签处理
    else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)){
        processBeanDefinition(ele, delegate);
    }
    // 对beans标签处理
    else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)){
        doRegisterBeanDefinitions(ele);
    }
    }
    |-- 3.1.1 对beans标签处理
    |-- protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
        // 委托BeanDefinitionParserDelegate类解析,bdHolder实例包含class、name、id、alias之类的属性
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
        if (bdHolder != null) {
            // bdHolder不为空情况下,若存在默认标签的子节点下再有自定义属性,还需要再次注册
            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
            try {
                // 注册操作委托BeanDefinitionReaderUtils.registerBeanDefinition方法
                BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
            } catch (e) {
                throw e;
            }
            // 发出响应事件,通知想关的监听器,这个bean已经加载完成了
            getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
        }
    }
    |-- BeanDefinitionParserDelegate.parseBeanDefinitionElement(Element ele) {
        return parseBeanDefinitionElement(ele, null);
    }
    parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
        // 解析id属性
        String id = ele.getAttribute(ID_ATTRIBUTE);
        // 解析name属性
        String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
        // 分割name属性
        List<String> aliases = new ArrayList<String>();
        if (StringUtils.hasLength(aliases)) {
            String[] nameArr = StringUtils.tokenizedToStringArray(nameAttr, ",");
            aliases.addAll(nameArr);
        }
        
        String beanName = id;
        if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
            beanName = aliases.remove(0); //??
        }
        if (containingBean == null) {
            checkNameUniqueness(beanName, aliases, ele);
        }
        // 进一步解析其他所有属性并统一封装至GenericBeanDefinition
        AbstractBeanparseBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
        if (beanDefinition != null) {
            if (!StringUtils.hasText(beanName)) {
                // 未指定beanName,使用默认规则为此bean生成beanName
                if (containingBean != null) {
                    // 不存在name
                    beanName = BeanDefinitionReaderUtils.generateBeanName(beanDefinition, this.readerContext.getRegistry(), true);
                } else {
                    beanName = this.readerContext.generateBeanName(beanDefinition);
                    String beanClassName = beanDefinition.getBeanClassName();
                    if (beanClassName != null && beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() 
                        && !this.readerContext.getRegistry().IsBeanNameInUse(beanClassName)) {
                            aliases.add(beanClassName);
                    }
                }
            }
            // 将获取到的信息封装到BeanDefinitionHolder中    
            String[] aliasesArray = StringUtils.toStringArray(aliases);
            return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
        }
        return null;
    }
    // 进一步解析其他所有属性并统一封装至GenericBeanDefinition
    AbstractBeanparseBeanDefinition parseBeanDefinitionElement(Element ele, String beanName, BeanDefinition containingBean) {
        try {
            this.parseState.push(new BeanEntry(beanName));
            String className = null;
            // 解析class属性
            if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
                className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
            }
            // 解析parent属性
            String parent = null;
            if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
                parent = ele.getAttribute(PARENT_ATTRIBUTE).trim();
            }
            // 创建用于属性承载的BeanDefinition
            AbstractBeanDefinition bd = createBeanDefinition(className, parent);
            
            // 硬编码解析默认的bean属性
            parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
            // 提取description
            bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
            
            // 解析元数据
            parseMetaElements(ele, bd);
            // 解析lookup-method
            parseLookupOverriedSubElements(ele, bd.getMethodOverries());
            // 解析replacted-method属性
            parseReplactedMethodSubElements(ele, bd.getMethodOverries());
            
            // 解析构造函数参数
            parseConstructorArgElements(ele, bd);
            // 解析property子元素
            parsePropertyElements(ele, bd);
            // 解析qualifier子元素
            parseQualifierElements(ele, bd);
            
            bd.setResource(this.readerContext.getResource());
            bd.setSource(extractSource(ele));
            return bd;
        } catch (e) {
            throw e;
        } finally {
            this.parseState.pop();
        }
        return null;
    }
    // 创建用于属性承载的BeanDefinition
    protected AbstractBeanDefinition createBeanDefinition(String className, String parentName){
        return BeanDefinitionReaderUtils.createBeanDefinition(parentName, className, this.readerContext.getBeanClassLoader());
    }
    // BeanDefinitionReaderUtils-> createBeanDefinition
    public static AbstractBeanDefinition createBeanDefinition(String parentName, String className, ClassLoader classloader) {
        GenericBeanDefinition bd = new GenericBeanDefinition();
        // parentName可能为空
        bd.setParentName(parentName);
        if (className != null) {
            if (classLoader != null) {
                bd.setBeanClass(ClassUtil.forName(className, classLoader));
            } else {
                bd.setBeanClassName(className);
            }
        }
        return bd;
    }
    // 硬编码解析默认的bean属性
    public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName, BeanDefinition containingBean, AbstractBeanDefinition bd) {
        // 解析scope属性
        // 解析singleton属性
        bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE) || ele.getAttribute(SINGLETON_ATTRIBUTE) || containingBean.getScope());
        // 解析abstract属性
        bd.setAbstract(ele.getAttribute(ABSTRACT_ATTRIBUTE));
        // 解析lazy-init属性
        bd.setLazyInit(lazy-init);
        // 解析autowire属性
        // 解析dependency-check属性
        // 解析dependency-on属性
        // 解析autowire-candidate属性
        // 解析primary属性
        // 解析init-method属性
        // 解析detory-method属性
        // 解析factory-method属性
        // 解析factory-bean属性
        ...
    }
    
    // 解析Meta元素
    <!-- spring-meta.xml -->
    <bean id="myTestBean" class="bean.MyTestBean">
        <meta key="testStr" value="aaa"/>
    </bean>
    parseMetaElements(Element ele, BeanMetadataAttributeAccessor attributeAccessor) {
        // 获取当前节点的所有子元素
        ...
    }

    4、bean的加载

    MyTestBean bean = (MyTestBean) bf.getBean("myTestBean");
    步骤:
    (1) 转换对应的beanName
     name="&aa"=>name="aa" || A->B->C=>C
    (2) 尝试从缓存中加载单例
     singletonFactories集合缓存ObjectFactory
    (3) bean的实例化
     getObjectForBeanInstance(sharedInstance, name, beanName, mbd)
    (4) 原型模式的依赖检查
     A有B属性,B有A属性,属性循环依赖
     isPrototypeCurrentlyInCreation(beanName)
    (5) 检测parentBeanFactory
    (6) 将存储XML配置文件的GernericBeanDefinition转换为RootBeanDefinition
    (7) 寻找依赖
    (8) 针对不同的scope进行bean的创建
     scope="singleton||prototype||other"
    (9) 类型转换
     return (T) bean;
    代码实现如下:

    (1) 转换对应的beanName
    String beanName = transformedBeanName(name);
    (2) 尝试从缓存中加载单例
    T doGetBean(args ...){
        Object bean; 
        sharedInstance = getSingleton(beanName);
        (3) bean的实例化
        if (!sharedInstance) { // 非单例
            bean = getObjectForBeanInstance(beanName, mbd, args);
        } else { // 单例
            (4) 原型模式的依赖检查
            if (isPrototypeCurrentlyInCreation(beanName)) throw e;
            
            (5) 检测parentBeanFactory
            BeanFactory parentBeanFactory = getParentBeanFactory();
            if (parentBeanFactory != null) {
                nameToLoopup = orginalBeanName(name);
                // 递归到BeanFactory中寻找
                return parentBeanFactory.getBean(nameToLoopup, args);
            }
            
            (6) 将存储XML配置文件的GernericBeanDefinition转换为RootBeanDefinition
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            checkMergedBeanDefinition(mbd, beanName, args);
            
            (7) 寻找依赖
            // 存在依赖,递归实例化bean
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dependsOnBean : dependsOn){
                    getBean(dependsOnBean);
                    registerDependentBean(dependsOnBean);
                }
            }
            
            (8) 针对不同的scope进行bean的创建
            // 实例化mbd本身
            if (mbd.isSingleton()){
                sharedInstance = getSingleton(beanName, new ObjectFactory<Object>(){
                        getObject() {
                            try {
                                return createBean(beanName, mbd, args);
                            } catch(e) {
                                destoryName(beanName);
                                throw e;
                            }
                        }
                    });
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            } else if (mbd.isPrototype()) {
                prototypeInstance;
                try {
                    beforePrototypeCreation(beanName);
                    prototypeInstance = createBean(beanName, mbd, args);
                } finally {
                    afterPrototypeCreation(beanName);
                }
                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            } else {
                // 指定的scope上实例化bean
                String scopeName = mbd.getScope();
                final Scope scope = this.scopes.get(scopeName);
                scopeInstance = scope.get(beanName, new ObjectFactory<Object>() {
                    getObject() {
                        try {
                            return createBean(beanName, mbd, args);
                        } finally {
                            afterPrototypeCreation(beanName);
                        }
                    }
                });
                bean = getObjectForBeanInstance(scopeInstance, name, beanName, mbd);
            }
        }
        (9) 类型转换
        if (requriedType != null) {
            return getTypeConverter().convertIfNecessary(bean, requiredType);
        }
        return (T) bean;
    }

    5.1 FactoryBean接口类

    FactoryBean
        |-- T getObject(); // 
        |-- Class<?> getObjectType();
        |-- boolean isSingleton();
    CarFactoryBean implements FactoryBean<Car> {
        Car getObject() {
            Car car = new Car();
            String[] infos = carInfo.split(",");
            car.setBrand(infos[0]);
            car.setMaxSpeed(Integer.valueOf(infos[1]));
            car.setPrice(Double.valueOf(infos[2]));
            return car;
        }
        
        String carInfo;
        // setter、getter方法
        isSingleton() {
            return false;
        }
    }
    <!-- srping-bean.xml -->
    <bean id="car" class="com.test.CarFactoryBean" carInfo="跑车,400,2000"/>
    代码实现:
        getBean("car") -> spring发现CarFactoryBean implements FactoryBean接口,容器调用接口方法CarFactoryBean#getObject()返回
        getBean("&car") -> CarFactoryBean

    5.2 缓存中获取单例

    Object getSingleton(String beanName) {
        return getSingleton(beanName, true);
    }
    Object getSingleton(beanName, allowEarlyReference) {
        // 检查缓存是否存在
        Object singletonObject = this.singletonObjects.get(beanName);
        if (null == getSingleton) {
            synchronized(this.singletonObjects) {
                singletonObject = this.earlySingletonObjects.get(beanName);
                if (singletonObject == null && allowEarlyReference) {
                    // 当某些方法需要提前初始化的时候会调用addSingletonFactory方法将对应的ObjectFactory初始化策略存储在singletongFactories
                    ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {
                        // 调用预先设定的getObject方法
                        singletonObject = singletonFactory.getObject();
                        // 记录在缓存中,earlySingletonObjects与singletonFactories互斥
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
        return singletonObject != NULL_OBJECT ? singletonObject : null;
    }

    5.3 从bean的实例中获取对象

    (1) 对FactoryBean做正确性的验证
    (2) 对非FactoryBean不做任务处理
    (3) 对bean进行转换
    (4) 将从Factory中解析bean的工作委托给getObjectFromFactoryBean
    
    getObjectForBeanInstance(beanInstance, name, beanName, mbd) {
        // &testBeanFactory
        if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
            throw e;
        }
        // &testBeanFactory
        if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
            return beanInstance;
        }
        // 加载factoryBean
        Object object = null;
        if (mbd == null) {
            // 尝试从缓存中加载bean
            object = getCachedObjectForFactoryBean(beanName);
        }
        if (object == null) {
            FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
            if (mbd == null && containsBeanDefinition(beanName)) {
                mbd = getMergedLocalBeanDefinition(beanName);
            }
            // 是否是用户定义的而不是应用程序本身定义的
            boolean synthetic = (mbd != null && mbd.isSynthetic());
            object = getObjectFromFactoryBean(factory, beanName, !synthetic);
        }
    }
    getObjectFromFactoryBean(factory, beanName, shouldPostProcess) {
        // 如果是单例
        if (factory.isSingleton() && containsSingleton(beanName)) {
            synchronized(getSingletonMutex()) {
                Object object = this.factoryBeanObjectCache.get(beanName);
                if (object == null) {
                    object = doGetObjectFromFactoryBean(factory, beanName, shouldPostProcess);
                    this.factoryBeanObjectCache.put(beanName, object);
                }
                return object;
            }
        } else {
            return doGetObjectFromFactoryBean(factory, beanName, shouldPostProcess);
        }
    }
    doGetObjectFromFactoryBean(factory, beanName, shouldPostProcess) {
        Object object = null;
        try {
            if (System.getSecurityManager() != null) { // 权限验证
                try {
                    Object = AccessController.doPrivileged(new PrivilegedExceptionAction<Object>(){
                        run() {
                            return factory.getObject();
                        }
                    });
                } catch (e) {
                    throw e;
                }
            } else {
                object = factory.getObject();
            }
        } catch (e) {
            throw e;
        }
        if (object != null && shouldPostProcess) {
            try {
                object = postProcessObjectFromFactoryBean(object, beanName);
            } catch (e) {
                throw e;
            }
        }
        return object;
    }
    postProcessObjectFromFactoryBean(object, beanName) {
        return applyBeanPostProcessorsAfterInitialization(object, beanName);
    }
    applyBeanPostProcessorsAfterInitialization(existingBean, beanName) {
        Object result = existingBean;
        for (BeanPostProcessor beanPostProcessor : getBeanPostProcessors()) {
            result = beanPostProcessor.postProcessorsAfterInitialization(result, beanName);
            return result;
        }
        return result;
    }

    5.4 获取单例

    (1) 检查缓存是否已经加载过
    (2) 若没有加载,则记录beanName的正在加载状态
    (3) 加载单例前记录加载状态
    (4) 通过调用参数传入的ObjectFactory的个体Object实例化bean
    (5) 加载单例后的处理方法调用
    (6) 将结果记录到缴存并删除加载bean过程中所记录的各种辅助状态
    (7) 返回处理结果
    getSingleton(beanName, new ObjectFactory) {
        synchronized (this.singletonObjects) {
            Object singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null) {
                beforeSingletonCreation(beanName);
                try {
                    singletonObject = singletonFactory.getObject();
                } catch (e) {
                    throw e;
                } finally {
                    afterSingletonCreation(beanName);
                }
                // 加入缓存
                addSingleton(beanName, singletonObject);
            }
        }
        return (singletonObject != NULL_OBJECT ? singletonObject : null)
    }
    beforeSingletonCreation(beanName) {
        if (!this.singletonsCurrentlyCreation.add(beanName)) { // 将当前正要创建的bean记录在缓存中,这样便可以对循环依赖进行检测
            throw e;
        }
    }
    afterSingletonCreation(beanName) {
        if (!this.singletonsCurrentlyCreation.remove(beanName)) { // 加载结束后,移除缓存中对该bean正在加载状态的记录
            throw e;
        }
    }
    addSingleton(beanName, singletonObject) {
        synchronized (this.singletonObjects) {
            // 将结果记录到缓存,并删除加载bean过程中所记录的辅助状态
            this.singletonObjects.put(beanName, singletonObject);
            this.singletonFatories.remove(beanName);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }
    getSingleton(beanName, new ObjectFactory<Object>(){
        public Object getObject() {
            try {
                return createBean(beanName, mbd, args);
            } catch (e) {
                throw e;
            }
        }
    });

    5.5 准备创建bean

    (1) 根据设置的class属性,或者根据className来解析class
    (2) 对override属性进行标记及验证
    (3) 应用初始化前的后处理器,解析指定bean是否存在初始化前的短路操作
    (4) 创建bean
    createBean(beanName, mbd, args) {
        // 根据设置的class属性,或者根据className来解析class
        resolveBeanClass(mbd, beanName);
        
        // 对override属性进行标记及验证
        try {
            mbd.prepareMethodOverrides();
        } catch (e) {
            throw e;
        }
        // 给BeanPostProcessors一个机会返回代理来替代真正的实例
        Object bean = resolveBeforeInstantiation(beanName, mbd);
        if (bean != null) {
            return bean;
        }
        // 创建bean
        Object beanInstance = doCreateBean(beanName, mbd, args);
        return beanInstance;
    }
    
    prepareMethodOverrides() {
        MethodOverrides methodOverrides = getMethodOverrides();
        for (MethodOverride mo : MethodOverrides) {
            prepareMethodOverride(mo);
        }
    }
    // lookup-method、replace-method属性
    prepareMethodOverride(mo) {
        // 获取对应类中对应方法名的个数
        int count = ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName());
        if (count == 0) {
            throw e;
        } else if (count == 1) {
            // 标记未被覆盖,避免参数类型检查的开销
            mo.setOverloaded(false);
        }
    }
    |-- 实例化前置处理
    resolveBeforeInstantiation(beanName, mbd) {
        Object bean = null;
        try {
            bean = applyBeanPostProcessorsBeforeInitialization(mbd.getBeanClass(), beanName);
            if (bean != null) {
                bean = applyBeanPostProcessorsAfterInitialization(mbd.getBeanClass(), beanName);
            }
            mbd.beforeInstantiationResolved = (bean != null);
        } catch (e) {
            throw e;
        }
        return bean;
    }
    |-- 实例化前的处理器应用
    applyBeanPostProcessorsBeforeInitialization(beanClass, beanName) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
                Object result = ibp.postProcessorsBeforeInitialization(beanClass, beanName);
                if (result != null) {
                    return result;
                }
            }
        }
        return null;
    }
    |-- 实例化后的处理器应用
    applyBeanPostProcessorsAfterInitialization(existingBean, beanName) {
        
        Object result = existingBean;
        for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
            Object result = beanProcessor.postProcessorsAfterInitialization(result, beanName);
            if (result != null) {
                return result;
            }
        }
        return result;
    }

    5.6 循环依赖

    (1) 循环依赖定义:
        循环依赖就是循环引用,就是存在2个或多个bean相互之间的持有对方,如:A->B->C->A,A->B->A
    (2) 循环依赖的类型:
        构造器循环依赖、setter循环依赖
    5.6.1 构造器循环依赖处理
        TestA、TestB、TestC
        TestA -> 查找“当前创建bean池”,如果没发现则继续准备构造器参数“testB”,并将“testA”标识符放到“当前创建bean池”
        TestB -> 查找“当前创建bean池”,如果没发现则继续准备构造器参数“testC”,并将“testB”标识符放到“当前创建bean池”
        TestC -> 查找“当前创建bean池”,如果没发现则继续准备构造器参数“testA”,并将“testC”标识符放到“当前创建bean池”
        准备构造器参数“testA”时,发现该 bean的标识符在“当前创建bean池”存在,抛出BeanCurrentlyInCreationException。
        
    5.6.2 setter循环依赖处理
        TestA、TestB、TestC
        TestA -> 暴露ObjectFactory工厂,并将“testA”标识符放到“当前创建bean池”,然后进行setter注入“testB”
        TestB -> 暴露ObjectFactory工厂,并将“testB”标识符放到“当前创建bean池”,然后进行setter注入“testC”
        TestC -> 暴露ObjectFactory工厂,并将“testC”标识符放到“当前创建bean池”,然后进行setter注入“testA”,进入注入“TestA”时由于提前暴露了“ObjectFactory”工厂,从而使用它返回提前暴露一个创建中的bean。
        最后依赖注入"TestB""TestA",完成setter注入。
        
    5.6.3 prototype范围的依赖处理
        scope="prototpye" -> 由于prototpye作用域无法完成依赖注入,spring容器不进行缓存prototype作用域的bean,因此无法提前暴露一个创建中的bean。
        scope="singleton" -> setAllowCircularReferences(false); // 禁用循环引用

    5.7 创建bean

    (1) 如果是单例则需要首先清除缓存
    (2) 实例化bean,将BeanDefinition转换为BeanWrapper
    (3) MergedBeanDefinitionPostProccessor的应用
    (4) 依赖处理
    (5) 属性填充
    (6) 循环依赖检查
    (7) 注册DisposableBean
    (8) 完成创建并返回
    protected Object doCreateBean(final String beanName, final RooBeanDefinition mbd, final Object[] args) {
        BeanWrapper instanceWrapper = null;
        // 如果是单例则需要首先清除缓存
        if (mbd.isSingleton()) {
            instanceWrapper = this.factoryBeanObjectCache.remove(beanName);
        }
        // 实例化bean,将BeanDefinition转换为BeanWrapper
        if (instanceWrapper == null) {
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
        Class beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
        // MergedBeanDefinitionPostProccessor的应用
        synchronized (mbd.postProcessingLock) {
            if (!mbd.postProcessed) {
                applyMergedBeanDefinitionPostProccessor(mbd, beanType, beanName);
            }
        }
        // 依赖处理
        // 是否需要提前暴露(单例&循环引用&当前bean正在创建中)
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletongCurrentlyInCreation(beanName));
        if (earlySingletonExposure) {
            // 为避免循环依赖,在bean初始化完成前将创建实例的ObjectFactory加入工厂
            addSingletonFactory(beanName, new ObjectFactory(){
                public Object getObject() throw e {
                    // 对bean的再一次依赖引用
                    return getEarlyBeanReferences(beanName, mbd, bean);
                }
            });
        }
        
        Object exposedObject = bean;
        // 属性填充
        try {
            populateBean(beanName, mbd, instanceWrapper);
            if (exposedObject != null) {
                // 调用初始化方法,init-method
                exposedObject = initializeBean(beanName, exposedObject, mbd);
            }
        } catch (e) {
            throw e;
        }
        
        // 循环依赖检查
        if (earlySingletonExposure) {
            Object earlySingletonReference = getSingleton(beanName, false);
            if (earlySingletonReference != null) {
                // exposedObject没有在初始化方法改变,说明没有被增强
                if (exposedObject == null) {
                    exposedObject = earlySingletonReference;
                } else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                    String[] dependentBeans = getDependentBeans(beanName);
                    Set<String> actualDependentBeans = new LinkedHashSet<String>();
                    for (String dependentBean : dependentBean) {
                        // 检测依赖
                        if (!removeSingletonIfCreateForTypeCheckOnly(dependentBean)) {
                            actualDependentBeans.add(dependentBean);
                        }
                    }
                    if (!actualDependentBeans.isEmpty()) {
                        throw e; 
                    }
                }
            }
        }
        
        // 注册DisposableBean
        try {
            registerDisposableBeanIfNecessary(beanName, bean, mbd);
        } catch (e) {
            throw e;
        }
        return exposedObject;
    }

    5.7.1.1 属性的注入

    (1) InstantiationAwareBeanPostProcessor处理器的postProcessAfterInstantiation函数的应用,此函数可以控制程序是否继续进行属性填充
    (2) 根据类型,提取依赖bean,并统一存入PropertyValues中。
    (3) 应用InstantiationAwareBeanPostProcessor处理器的postProcessPropertyValues方法,对属性获取完毕填充前对属性的再次处理,RequiredAnnotationBeanPostProcessor对属性的验证
    (4) 将所有PropertyValues中的属性填充至BeanWrapper中
    populateBean(beanName, mbd, bw) {
        PropertyValues pvs = mbd.getPropertyValues();
        if (bw == null) {
            if (!pvs.isEmpty()) {
                throw e;
            } else {
                // 没有属性填充
                return ;
            }
        }
        
        boolean continueWithPropertyPopulation = true;
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                // 返回值是否继续填充bean
                if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                    continueWithPropertyPopulation = false;
                    break;
                }
            }
        }
        // 如果后处理器发出停止填充命令则终止后续的执行
        if (!continueWithPropertyPopulation) {
            return;
        }
        
        if (mbd.getResolvedAutowireMode() == RooBeanDefinition.AUTOWIRE_BY_NAME || 
                mbd.getResolvedAutowireMode() == RooBeanDefinition.AUTOWIRE_BY_TYPE) {
            MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
            if (mbd.getResolvedAutowireMode() == RooBeanDefinition.AUTOWIRE_BY_NAME) {
                autowireByName(beanName, mbd, bw, newPvs);
            }
            if (mbd.getResolvedAutowireMode() == RooBeanDefinition.AUTOWIRE_BY_TYPE) {
                autowireByType(beanName, mbd, bw, newPvs);
            }
            pvs = newPvs;
        }
        
        // 后处理器已经初始化
        boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
        // 需要检查依赖
        boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
        if (hasInstAwareBpps || needsDepCheck) {
            PropertyDescriptor[] filteredPds = filterPropertyDescriptionsForDependencyCheck(bw);
            if (hasInstAwareBpps) {
                for (BeanPostProcessor bp : getBeanPostProcessors()) {
                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                    // 对所有需要依赖检查的属性进行后处理
                    pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                    if (pvs == null) {
                        return;
                    }
                }
            } 
            if (needsDepCheck) {
                checkDependences(beanName, mbd, filteredPds, pvs);
            }
        }
        // 将属性应用到bean中
        applyPropertyValues(beanName, mbd, bw, pvs);
    }
    // 根据name注入属性
    autowireByName(beanName, mbd, bw, newPvs) {
        String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
        for (String propertyName : propertyNames) {
            if (containsBean(propertyName)) {
                // 递归初始化相关的bean
                Object bean = getBean(propertyName);
                pvs.add(propertyName, bean);
                // 注册依赖
                registerDependentBean(propertyName, beanName);
            } else {
                if (logger.isTraceEnabled()) {
                    logger.trace(...);
                }
            }
        }
    }
    // 根据type注入属性
    autowireByType(beanName, mbd, BeanWrapper bw, newPvs) {
        try {
            TypeConverter converter = getCustomTypeConverter();
            if (converter == null) {
                converter = bw;
            }
            
            Set<String> autowiredBeanNames = new LinkedHashSet<String>(4);
            // 寻找bw中需要依赖注入的属性
            String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
            for (String propertyName : propertyNames) {
                PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
                if (!Object.calss.equals(pd.getProperType())) {
                    // 探测指定的set方法
                    MethodParamter methodParam = BeanUtils.getWriteMethodParamter(pd);
                    boolean eager = PriorityOrdered.class.isAssignableFrom(bw.getWrappedClass());
                    PropertyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
                    
                    // 解析指定的属性所匹配的值,并把解析到的属性的名称存储在autowiredBeanNames中,当属性存在多个封装bean时:
                    // @Autowired private List<A> aList; 将会找到所有匹配A类型的bean将其注入
                    Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
                    if (autowiredArgument != null) {
                        pvs.add(propertyName, autowiredArgument);
                    }
                    for (String autowiredBeanName : autowiredBeanNames) {
                        // 注册依赖
                        registerBeanDefinition(autowiredBeanName, beanName);
                    }
                    autowiredBeanNames.clear();
                }
            }
        } catch (e) {
            throw e;
        }
    }
    resolveDependency(descriptor, beanName, Set<String> autowiredBeanNames, typeConverter) {
        descriptor.initParamterNameDisconvery(getParamterNameDisconverer());
        // ObjectFactory类注入的特殊处理
        if (descriptor.getDependencyType().equals(ObjectFactory.class)) {
            return new DependencyObjectFactory(descriptor, beanName);
        }
        else if (... eq javaxInjectProviderClass) {
            return new DependencyObjectFactory().createDependencyProvider(descriptor, beanName);
        }
        else {
            // 通用逻辑处理
            return doResolvedDependency(descriptor, descriptor.getDependencyType(), beanName, autowiredBeanNames, typeConverter);
        }
    }
    doResolvedDependency(descriptor, descriptor.getDependencyType(), beanName, autowiredBeanNames, typeConverter) {
        // 用于支持spring中新增的注解@value
        Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
        if (value != null) {
            if (value instanceof String) {
                value = evaluateBeanDefinitionString(strVal, bd);
            }
            TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
            return converter.convertIfNecessary(value, type);
        }
        
        // 属性是数组类型
        if (type.isArray()) { 
            // 数组类型
            Class<?> componentType = type.getComponentType();
            Map<String,Object> matchingBeans = findAutowireCandidates(beanName, componentType, descriptor);
            if (matchingBeans.isEmpty()) {
                if (descriptor.isRequired()) {
                    raiseNoSuchBeanDefinitionException(componentType, componentType.getName(), descriptor);
                }
                return null;
            }
            if (autowiredBeanNames != null) {
                autowiredBeanNames.addAll(matchingBeans.keySet());
            }
            TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
            return converter.convertIfNecessary(matchingBeans.values(), type);
        }
        else if (Collection.class.isAssignableFrom(type) && type.isInterface()) {
            // 集合类型
            Class<?> elementType = descriptor.getCollectionType();
            if (elementType == null) {
                if (descriptor.isRequired()) {
                    throw e;
                }
                return null;
            }
            Map<String,Object> matchingBeans = findAutowireCandidates(beanName, componentType, descriptor);
            if (matchingBeans.isEmpty()) {
                throw e;
            }
            if (autowiredBeanNames != null) {
                autowiredBeanNames.addAll(matchingBeans.keySet());
            }
            TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
            return converter.convertIfNecessary(matchingBeans.values(), type);
        } 
        else if (Map.class.isAssignableFrom(type) && type.isInterface()) {
            // Map类型
            Class<?> keyType = descriptor.getMapKeyType();
            if (keyType == null) {
                if (descriptor.isRequired()) {
                    throw e;
                }
                return null;
            }
            Map<String,Object> matchingBeans = findAutowireCandidates(beanName, componentType, descriptor);
            if (matchingBeans.isEmpty()) {
                throw e;
            }
            if (autowiredBeanNames != null) {
                autowiredBeanNames.addAll(matchingBeans.keySet());
            }
            TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
            return converter.convertIfNecessary(matchingBeans.values(), type);
        }
        else {
            Map<String,Object> matchingBeans = findAutowireCandidates(beanName, componentType, descriptor);
            if (matchingBeans.isEmpty()) {
                throw e;
            }
            if (matchingBeans.size() > 1) {
                String primaryBeanName = determinePrimaryCandidate(matchingBeans, descriptor);
                if (primaryBeanName == null) {
                    throw e;
                }
                if (autowiredBeanNames != null) {
                    autowiredBeanNames.add(primaryBeanName);
                }
                return matchingBeans.get(primaryBeanName);
            }
            // 已经可以确定只有一个匹配项
            Map.Entry<String,Object> entry = matchingBeans.entrySet().iterator().next();
            if (autowiredBeanNames != null) {
                autowiredBeanNames.add(entry.getKey());
            }
            return entry.getValue();
        }
    }
    // 将属性应用到bean中
    applyPropertyValues(beanName, mbd, bw, pvs) {
        if (pvs == null || pvs.isEmpty()) {
            return;
        }
        
        MutablePropertyValues mpvs = null;
        List<PropertyValue> original;
        if (bw instancof BeanWrapperImpl) {
            ((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
        }
        if (pvs instanceof MutablePropertyValues) {
            mpvs = (MutablePropertyValues) pvs;
            // 如果mpvs中的值已经被转换为对应的类型那么可以直接设置到beanWrapper中
            try {
                if (mpvs.isConverted()) {
                    bw.setPropertyValues(mpvs);
                    return;
                }
            } catch (e) {
                throw e;
            }
            original = mpvs.getPropertyValueList();
        } else {
            // 非MutablePropertyValues封装的类型,那么直接使用原始的属性获取方法
            original = Arrays.asList(pvs.getPropertyValues());
        }
        
        TypeConverter converter = getCustomTypeConverter();
        if (converter == null) {
            converter = bw;
        }
        // 获取对应的解析器
        BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
        // Create a deep copy, resolving any references for values.
        List<PropertyValue> deepCopy = new ArrayList<String>(original.size());
        boolean resolveNecessary = false;
        for (PropertyValue pv : original) {
            if (pv.isConverted()) {
                deepCopy.add(pv);
            } else {
                String propertyName = pd.getName();
                Object originalValue = pd.getValue();
                Object resolvedValue = valueResolver.resolveValueIfNecessay(pv, originalValue);
                
                Object convertedValue = resolvedValue;
                boolean convertible = (bw.isWritableProperty(propertyName) && !PropertyUtils.isNestedIndexedProperty(propertyName));
                if (convertible) {
                    convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
                }
                if (convertedValue == originalValue) {
                    if (convertible) {
                        pv.setConvertedValue(convertedValue);
                    }
                    deepCopy.add(pv);
                }
                else if (convertible && originalValue instanceof TypedStringValue && 
                    !((TypedStringValue) originalValue).isDynamic() &&
                    !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))){
                    pv.setConvertedValue(convertedValue);
                    deepCopy.add(pv);
                }
                else {
                    resolveNecessary = true;
                    deepCopy.add(new PropertyValue(pv, convertedValue));
                }
            }
        }
        if (mpvs != null && !resolveNecessary) {
            mpvs.setConverted();
        }
        try {
            bw.setPropertyValues(new MutablePropertyValues(deepCopy));
        } catch (e) {
            throw e;
        }
    }

    5.7.2 初始化bean

    // spring容器已经执行过bean的实例化,并且进行了属性填充,而就是这时将会调用用户设定的初始化方法
    initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
        if (System.getSecurityMananger() != null) {
            AccessController.doPrivileged(new PrivilegedAction<Object>(){
                Object run() {
                    invokeAwareMethods(beanName, bean);
                    return null;
                }
            });
        } else {
            // 对特殊的bean处理:Aware、BeanClassLoaderAware、BeanFactoryAware
            invokeAwareMethods(beanName, bean);
        }
        
        Object wrappedBean = bean;
        if (mbd != null || !mbd.isSynthetic()) {
            // 应用前处理器
            wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        }
        try {
            // 激活用户自定义的init方法
            invokeInitMethod(beanName, wrappedBean, mbd);
        } catch (e) {
            throw e;
        }
        if (mbd != null || !mbd.isSynthetic()) {
            // 后处理器应用
            wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }
        return wrappedBean;
    }
    invokeAwareMethods(final String beanName, final Object bean) {
        if (bean instanceof Aware) {
            if (bean instanceof BeanNameAware) {
                ((BeanNameAware) bean).setBeanName(beanName);
            }
            if (bean instanceof BeanClassLoaderAware) {
                ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
            }
            if (bean instanceof BeanFactoryAware) {
                ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
            }
        }
    }
    // 处理器应用
    applyBeanPostProcessorsBeforeInitialization(existingBean, beanName) {
        Object result = existingBean;
        for ( BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
            result = beanProcessor.postProcessBeforeInitialization(result, beanName);
            if (result == null) {
                return result;
            }
        }
        return result;
    }
    applyBeanPostProcessorsAfterInitialization(existingBean, beanName) {
        Object result = existingBean;
        for ( BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
            result = beanProcessor.postProcessAfterInitialization(result, beanName);
            if (result == null) {
                return result;
            }
        }
        return result;
    }
    // 激活用户自定义的init方法
    invokeInitMethod(beanName, bean, mbd) {
        // 检查是否是InitializingBean,如果是则调用afterPropertiesSet方法
        boolean isInitializingBean = (bean istanceof InitializingBean);
        if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
        
            if (System.getSecurityManager() != null) {
                try {
                    AccessController.doPrivileged(new PrivilegedExceptionAction<Object>(){
                        Object run() {
                            ((InitializingBean) bean).afterPropertiesSet();
                            return null;
                        }
                    });
                } catch (e) {
                    throw e;
                }
            } else {
                ((InitializingBean) bean).afterPropertiesSet();
            }
        }
        if (mbd != null) {
            String initMethodName = mbd.getInitMethodName();
            if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName))
                && !mbd.isExternallyManagedInitMethod(initMethodName)) {
                // 调用自定义初始化方法
                invokeCustomInitMethod(beanName, bean, mbd);
            }
        }
    }

    5.7.3 注册DisposableBean

    protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
        AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
        if (!mbd.isPrototype() && requiredDestruction(bean, mbd)) {
            if (mbd.isSingleton()) {
                // 单例模式下需要注册需要销毁的bean,此方法中会处理实现DisposableBean的bean,
                // 并且对所有的bean使用DestrunctionAwareBeanPostProccessors处理
                // DisposableBean DestrunctionAwareBeanPostProccessors
                registerDisposableBean(beanName, new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
            } else {
                scope scope = this.scopes.get(mgd.getScope());
                if (scope == null) {
                    throw e;
                }
                scope.registerDestructionCallback(beanName, new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
            }
        }
    }

    6. 容器的功能扩展

    ApplicationContext,用于扩展BeanFactory现有功能。
      使用场景:
       ApplicationContext ctx = new ClassPathXmlApplicationContext("beanFactoryTest.xml");

    |-- ClassPathXmlApplicationContext(String configLoocation) {
                    this(new String[]{configLocation}, true, null);
                }
            |-- ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent) {
                    super(parent);
                    setConfigLocations(configLocations);
                    if (refresh) {
                        refresh();
                    }
                }
            |-- 6.1 设置路径
                |-- setConfigLocations(String[] locations) {
                        if (locations != null) {
                            this.locations = new String[locations.length];
                            for (i=0 ; i<locations.length; i++) {
                                // 解析给定路径,如${var}特殊符号,搜寻匹配的变量并替换
                                this.locations[i] = resolvePath(locations[i]).trim();
                            }
                        } else {
                            this.configLocations = null;
                        }
                    }
            |-- 6.2 扩展功能
                (1) 初始化前准备工作,例如对系统属性或者环境变量进行准备及验证
                (2) 初始化BeanFactory,并进行XML文件读取
                (3) 对BeanFactory进行各种属性填充(@Qualifier、@Autowire)
                (4) 子类覆盖方法处理
                (5) 激活各种BeanFactory处理器
                (6) 注册拦截Bean创建的bean处理器,这里只是注册,真正调用是在getBean时候
                (7) 为上下文初始化Message源,即不同的语言的消息体,国际化处理
                (8) 初始化应用消息广播器,并放入“applicationEventMulticaster”bean中
                (9) 留给子类来初始化其它的bean
                (10) 在所有注册的bean中查找Listener bean,注册到消息广播器中
                (11) 初始化剩下的单实例(非惰性的)
                (12) 完成刷新过程,通知生命周期处理器lifecycleProcessor刷新过程,同时发出ContextRefreshEvent通知别人
                |-- refresh() {
                        // 准备刷新的上下文环境
                        prepareRefresh();
                        // 初始化FactoryBean,并进行XML文件读取
                        ConfigurableListableBeanFacbeanFactory beanFactory = obtainFreshBeanFactory();
                        // 对BeanFactory进行各种属性填充
                        prepareBeanFactory(beanFactory);
                        
                        try {
                            // 子类覆盖方法处理
                            postProcessBeanFactory();
                            // 激活各种BeanFactory处理器
                            invokeBeanFactoryPostProcessors(beanFactory);
                            // 注册拦截Bean创建的bean处理器,这里只是注册,真正调用是在getBean时候
                            registerBeanPostProcessors(beanFactory);
                            // 为上下文初始化Message源,即不同的语言的消息体,国际化处理
                            initMessageSource();
                            // 初始化应用消息广播器,并放入“applicationEventMulticaster”bean中
                            initApplicationEventMulticaster();
                            // 留给子类来初始化其它的bean
                            onRefresh();
                            // 在所有注册的bean中查找Listener bean,注册到消息广播器中
                            registerListeners();
                            // 初始化剩下的单实例(非惰性的)
                            finishBeanFactoryInitialization(beanFactory);
                            // 完成刷新过程,通知生命周期处理器lifecycleProcessor刷新过程,同时发出ContextRefreshEvent通知别人
                            finishRefresh();
                        } catch (e) {
                            // 销毁bean
                            destoryBeans();
                            // 取消通知
                            cancalRefresh(e);
                            throw e;
                        }
                    }
            |-- 6.3 环境准备
                |-- prepareRefresh() {
                        this.startupDate = System.currentTimeMillis();
                        synchronized (this.activeMonitor) {
                            this.active = true;
                        }
                        initPropertySources();
                        getEnvironment().validateRequiredProperties();
                    }
                    |-- 例如需要配置环境变量VAR,可以继承
                        |-- MyClassPathXmlApplicationContext extends ClassPathXmlApplicationContext {
                                MyClassPathXmlApplicationContext(String... configLocations) {
                                    super(configLocations);
                                }
                                @Override 
                                void initPropertySources() {
                                    getEnvironment().setRequiredProperties("VAR");
                                }
                            }
            |-- 6.4 加载factoryBean
                (1) 创建DefaultListableBeanFactory
                (2) 指定序列化id
                (3) 定制BeanFactory
                (4) 加载BeanDefinition
                (5) 使用全局变量记录BeanFactory类实例
                |-- obtainFreshBeanFactory() {
                        refreshBeanFactory();
                        ConfigurableListableBeanFacbeanFactory beanFactory = getBeanFactory();
                        return beanFactory;
                    }
                |-- refreshBeanFactory() {
                        if (hasBeanFactory()) {
                            // 销毁bean
                            destoryBeans();
                            closeBeanFactory(e);
                        }
                        try {
                            beanFactory = createBeanFactory();
                            beanFactory.setSerializationId(getId());
                            customizeBeanFactory(beanFactory);
                            loadBeanDefinitions(beanFactory);
                            synchronized (this.beanFactoryMonitor) {
                                this.beanFactory = beanFactory;
                            }
                        } catch (e) {
                            throw e;
                        }
                    }
                |-- 6.4.1 定制BeanFactory
                    |-- customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
                            if (this.allowBeanDefinitionOverring != null) {
                                beanFactory.setAllowBeanDefinitionOverring(this.allowBeanDefinitionOverring);
                            } 
                            if (this.allowCircularReferences != null) {
                                beanFactory.setAllowCircularReferences(allowCircularReferences);
                            } 
                            beanFactory.setAutowireCandidateResolver(new QualifierAnnotationAutowireCandidateResolver());
                        }
                        |-- 应用:子类覆盖设置属性
                        |-- MyClassPathXmlApplicationContext extends ClassPathXmlApplicationContext {
                                @Override
                                void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
                                    super.setAllowBeanDefinitionOverring(false);
                                    super.setAllowCircularReferences(false);
                                    super.customizeBeanFactory(beanFactory);
                                }
                            }
                    |-- 设置AutowireCandidateResolver
                        |-- Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor) {
                                Object value = findValue();
                                if (value = null) {
                                    methodParam = descriptor.getMethodParamter();
                                    if (methodParam != null) {
                                        value = findValue(methodParam.getMethodAnnotations());
                                    }
                                }
                                return value;
                            }
                |-- 6.4.2 加载BeanDefinition
                    |-- loadBeanDefinitions(beanFactory) {
                            // 为指定的BeanFactory创建XmlBeanDefinition
                            XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader();
                            
                            // 对beanDefinitionReader进行环境变量设置
                            beanDefinitionReader.setEnvironment(this.getEnvironment());
                            beanDefinitionReader.setResourceLoader(this);
                            beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
                            
                            // 对beanDefinitionReader进行设置,可以覆盖
                            initBeanDefinitionReader(beanDefinitionReader);
                            
                            loadBeanDefinitions(beanDefinitionReader);
                        }
                    |-- loadBeanDefinitions(BeanDefinitionReader reader) {
                            Resource[] configResources = getConfigResources();
                            if (configResources != null) {
                                reader.loadBeanDefinitions(configResources);
                            }
                            String[] configLocations = getConfigLocations();
                            if (configLocations != null) {
                                reader.loadBeanDefinitions(configLocations);
                            }
                        }
            |-- 6.5 功能扩展
                |-- prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
                        beanFactory.setBeanClassLoader(getClassLoader());
                        
                        // 增加对SPEL语言支持
                        beanFactory.setBeanExpressionResolver(new StandarBeanExpressionResolver());
                        
                        // 增加对属性编辑器的支持
                        beanFactory.addPropertyEditorRegistrar(new ResouceEditorRegistrar(this, getEnvironment()));
                        
                        // 增加对一些内置类,比如EnvironmentAware、MessageSourceAware信息的注入
                        beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
                        
                        // 设置了依赖功能可忽略的接口
                        beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
                        beanFactory.ignoreDependencyInterface(ApplicationEventPulisherAware.class);
                        beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
                        beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
                        beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
                        
                        // 注册了一些固定依赖的属性
                        beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
                        beanFactory.registerResolvableDependency(ResourceLoader.class, this);
                        beanFactory.registerResolvableDependency(ApplicationEventPulisher.class, this);
                        beanFactory.registerResolvableDependency(ApplicationContext.class, this);
                        
                        // 增加AspectJ的支持
                        if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
                            beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
                            // Set a temporary ClassLoader for type matching.
                            beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
                        }
                        
                        // 将相关环境变量及属性注册以单例模式注册
                        if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
                            beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME,getEnvironment());
                        }
                        if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
                            beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME,getEnvironment());
                        }
                        if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
                            beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME,getEnvironment());
                        }
                    }
                    |-- 6.5.1 增加对SPEL语言支持
                        |-- <!-- spring.xml -->
                            <bean><property name="instrument" value="#{saxphone}"></property></bean>
                        |-- applyPropertyValues
                            --> BeanDefinitionValueResolver valueResolver
                                --> evluateBeanDefinitionString(String value, BeanDefinition beanDefinition) {
                                        if (this.beanExpressionResolver == null) {
                                            return value;
                                        }
                                        scope = (beanDefinition != null ? getRegisteredScope(beanDefinition.getScope()) : null);
                                        return this.beanExpressionResolver.evaluate(value, new BeanExpressionContext(this, scope));
                                    }
                    |-- 6.5.2 增加对属性编辑器的支持    
                        |-- <!-- spring.xml -->
                            <bean id="userManager" class="com.test.UserManager">
                                <property name="datavalue">
                                    <value>2013-03-15</value>
                                </property>
                            </bean>
                        |-- 直接使用会报错,如下:
                            UserManager userManager = ctx.getBean(userManager);
                            sysout(userManager);
                        |-- 方案1:使用自定义属性编辑器
                            |-- DatePropertyEditor extends PropertyEditorSupport {
                                    private String format = "yyyy-MM-dd";
                                    void setFormate(String format) {
                                        this.format = format;
                                    }
                                    @Override
                                    public void setAsText(String args0) throw e {
                                        SimpleDateFormat sdf = new SimpleDateFormat(format);
                                        try {
                                            Date d = sdf.parse(args0);
                                            this.setValue(d);
                                        } catch (e) {
                                            throw e;
                                        }
                                    }
                                }
                            |-- 将自定义编辑器注册到Spring中
                                |-- <!-- spring.xml -->
                                    <bean class="org.springframework.beans.factory.config.CustomEditorConfigurer">
                                        <property name="customEditors">
                                            <map>
                                                <entry key="java.util.Date">
                                                    <bean class="com.test.DatePropertyEditor">
                                                        <property name="format" value="yyyy-MM-dd"/>
                                                    </bean>
                                                </entry>
                                            </map>
                                        </property>
                                    </bean>
                        |-- 方案2:使用Spring自带的属性编辑器CustomDateEditor
                            |-- (1) 定义属性编辑器
                                |-- DatePropertyEditorRegistrar implements PropertyEditorRegistrar {
                                        registerCustomEditors(Date.class, new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd"),true));
                                    }
                            |-- (2) 注册到Spring中
                                |-- <!-- spring.xml -->
                                    <bean class="org.springframework.beans.factory.config.CustomEditorConfigurer">
                                        <property name="propertyEditorRegistrars">
                                            <list>
                                                <bean class="com.test.DatePropertyEditorRegistrar"></bean>
                                            </list>
                                        </property>
                                    </bean>
                            |-- registerCustomEditors(PropertyEditorRegistrar registry) {
                                    ResourceEditor baseEditor = new ResourceEditor(this.resourceLoader, this.propertyResolver);
                                    doRegisterEditor(registry, Resource.class, baseEditor);
                                    doRegisterEditor(registry, ContextResource.class, baseEditor);
                                    doRegisterEditor(registry, InputStream.class, new InputStremEditor(baseEditor));
                                    doRegisterEditor(registry, InputSource.class, new InputSourceEditor(baseEditor));
                                    doRegisterEditor(registry, File.class, new FileEditor(baseEditor));
                                    doRegisterEditor(registry, URL.class, new URLEditor(baseEditor));
                                    
                                    ClassLoader classLoader = this.resourceLoader.getClassLoader();
                                    doRegisterEditor(registry, URI.class, new URIEditor(classLoader));
                                    doRegisterEditor(registry, Class.class, new ClassEditor(classLoader));
                                    doRegisterEditor(registry, Class[].class, new ClassArrayEditor(classLoader));
                                    if (this.resourceLoader instanceof ResourcePatternResolver) {
                                        doRegisterEditor(registry, Resource[].class, 
                                            new ResourceArrayPropertyEditor((ResourcePatternResolver) this.resourceLoader, this.propertyResolver));
                                    }
                                }
                                doRegisterEditor(PropertyEditorRegistrar registry, Class<?> requiredType, PropertyEditor editor) {
                                    if (registry instanceof PropertyEditorRegistrySupport) {
                                        ((PropertyEditorRegistrySupport) registry).overrideDefaultEditor(requiredType, editor);
                                    } else {
                                        registry.registerCustomEditors(requiredType, editor);
                                    }
                                }
                                |-- BeanWrapperImpl implements BeanWrapper extends PropertyEditorRegistrySupport {
                                        createDefaultEditors() {
                                            this.defaultEditors = new HashMap<Class<?>, PropertyEditor>(64);
                                            
                                            this.defaultEditors.put(Charset.class, new CharsetEditor());
                                            this.defaultEditors.put(Class.class, new ClassEditor());
                                            ...
                                        }
                                    } 
                    |-- 6.5.3 添加ApplicationContextAwareProcessor处理器
                        |-- prepareBeanFactory()
                            --> beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this)) // 注册个BeanPostProcessor,而真正的逻辑在ApplicationContextAwareProcessor中
                                --> ApplicationContextAwareProcessor implements BeanPostProcessor {
                                        // spring激活bean的init-method方法前后,会调用BeanPostProcessor的postProcessorBeforeInitailization()方法和postProcessAfterInitailization()方法
                                        // 同样对ApplicationContextAwareProcessor我们也关心这两个方法
                                        Object postProcessorBeforeInitailization(Object bean, String beanName) {
                                            return bean;
                                        } 
                                        Object postProcessAfterInitailization(final Object bean, String beanName) {
                                            AccessController acc = null;
                                            if (System.getSecurityManager() != null &&
                                                    (bean instanceof EnvironmentAware 
                                                        || bean instanceof EmbeddedValueResolverAware
                                                        || bean instanceof ResourceLoaderAware
                                                        || bean instanceof MessageSourceAware
                                                        || bean instanceof ApplicationContextAware)) {
                                                acc = this.applicationContext.getBeanFactory().getAccessControlContext();
                                            }
                                            if (acc != null) {
                                                AccessController.doPrivileged(new PrivilegedAction<Object>(){
                                                    public Object run() {
                                                        invokeAwareInterfaces(bean);
                                                        return null;
                                                    }
                                                });
                                            } else {
                                                invokeAwareInterfaces(bean);
                                            }
                                            return bean;
                                        }
                                        invokeAwareInterfaces(Object bean) {
                                            if (bean instanceof Aware) {
                                                if (bean instance of EnvironmentAware) {
                                                    ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
                                                }
                                                if (bean instance of EmbeddedValueResolverAware) {
                                                    ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(new EmbeddedValueResolver(this.applicationContext.getBeanFactory()));
                                                }
                                                if (bean instance of EnvironmentAware) {
                                                    ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
                                                }
                                                if (bean instance of ResourceLoaderAware) {
                                                    ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
                                                }
                                                if (bean instance of ApplicationContextAware) {
                                                    ((ApplicationContextAware) bean).setApplicationContextContext(this.applicationContext);
                                                }
                                                ...
                                            }
                                        }
                                    }
                        
                    |-- 6.5.4 设置忽略属性 
                        beanFactory.ingoreDependencyInterface(ResourceLoaderAware.class);
                        beanFactory.ingoreDependencyInterface(ApplicationEventPulisherAware.class);
                        beanFactory.ingoreDependencyInterface(MessageSourceAware.class);
                        beanFactory.ingoreDependencyInterface(ApplicationContextAware.class);
                        beanFactory.ingoreDependencyInterface(EnvironmentAware.class);
                    |-- 6.5.5 注册依赖
                        beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
                        beanFactory.registerResolvableDependency(ResourceLoader.class, beanFactory);
                        beanFactory.registerResolvableDependency(ApplicationEventPulisher.class, beanFactory);
                        beanFactory.registerResolvableDependency(ApplicationContext.class, beanFactory);
                
                |-- 6.6 BeanFactory 的后处理 
                    |-- 6.6.1 激活注册的BeanFactoryPostProcessor
                        |-- (1) BeanFactoryPostProcessor的典型应用:
                            |-- <!-- spring.xml -->
                                <bean id="message" class="com.test.HelloMessage">
                                    <property name="mes">
                                        <value>${bean.message}</value>
                                    </property>
                                </bean>
                            |-- bean.properties
                                bean.message=Hi, can you find me?
                            |-- 配置信息:
                                <bean id="mesHandler" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
                                    <property name="localtions">
                                        <value>config/bean.properties</value>
                                    </property>
                                </bean>
                            |-- PropertyPlaceholderConfigurer 间接继承了BeanFactoryPostProcessor
                        |-- (2) 使用自定义BeanFactoryPostProcessor
                            |-- <!-- spring.xml -->
                            <bean id="bfpp" class="com.spring.ch04.ObscenityRemovingBeanFactoryPostProcessor">
                                <property name="obscenties">
                                    <set>
                                        <value>bollocks</value>
                                        <value>winky</value>
                                        <value>bum</value>
                                        <value>Microsoft</value>
                                    </set>
                                </property>
                            </bean>
                            <bean id="simpleBean" class="com.spring.ch04.SimplePostProcessor">
                                <property name="connectionString" value="bollocks"></property>
                                <property name="password" value="imaginecup"></property>
                                <property name="username" value="Microsoft"></property>
                            </bean>
                            ...
                            |-- ObscenityRemovingBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
                                    private Set<String> obscenties;
                                    ObscenityRemovingBeanFactoryPostProcessor() {
                                        obscenties = new HashSet<String>();
                                    }
                                    
                                    void postProcessBeanFactory(beanFactory) {
                                        String[] beanNames = beanFactory.getBeanDefinitionNames();
                                        for (String beanName : beanNames) {
                                            BeanDefinition bd = beanFactory.getBeanDefinition(beanName);
                                            StringValueResolver valueREsolver = new StringValueResolver(){
                                                String resolveStringValue(String strVal) {
                                                    if (isObscene(strVal)) return "*****";
                                                    return strVal;
                                                }
                                            };
                                            BeanDefinitionVisitor vistor = new BeanDefinitionVisitor(valueResolver);
                                            visitor.visitBeanDefinition(bd);
                                        }
                                    }
                                    boolean isObscene(Object value) {
                                        String potentialObscenity = value.toString().toUppercase();
                                        return this.obscenties.contains();
                                    }
                                    void setObscenties(Set<String> obscenties) {
                                        this.obscenties.clear();
                                        for(String obscenity : obscenties) {
                                            this.obscenties.add(obscenity.toUpperCase());
                                        }
                                    }
                                }
                                // 执行类:
                                public class PropertyConfigurerDemo {
                                    main(String[] args) {
                                        bf = new XmlBeanFactory(new ClassPathResource("/META-INF/BeanFactory.xml"));
                                        
                                        ObscenityRemovingBeanFactoryPostProcessor bfpp = (ObscenityRemovingBeanFactoryPostProcessor) bf.get("bfpp");
                                        bfpp.postProcessBeanFactory(bf);
                                        sysout(bf.getBean("simpleBean"));
                                        // 输出结果:SimplePostProcessor{connectionString=*****,username=*****,password=imaginecup}
                                    }
                                }
                            |-- 激活BeanFactoryPostProcessor
                                (1) 对于硬编码注册的后处理器的处理,主要通过AbstractApplicationContext中的添加处理器方法addBeanFactoryPostProcessor
                                (2) 记录后处理器主要使用了三个List完成
                                    registryPostProcessors:记录通过硬编码方式注册的BeanDefinitionRegistryPostProcessor类型处理器
                                    regularPostProcessors:记录通过硬编码方式注册的BeanFactoryPostProcessors
                                    registryPostProcessorBeans:记录通过硬编码方式注册的BeanDefinitionRegistryPostProcessor
                                (3) 对以上所记录的List中的后处理器进行统一调用beanFactoryPostProcessors的postProcessBeanFactory()
                                (4) 对beanFactoryPostProcessors中非BeanDefinitionRegistryPostProcessor类的后处理器进行统一调用beanFactoryPostProcessors的postProcessBeanFactory()
                                (5) 普通beanFactory处理
                                |-- invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
                                        // BeanDefinitionRegistry
                                        if (beanFactory instanceof BeanDefinitionRegistry) {
                                            BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
                                            
                                            // 
                                            for (BeanFactoryPostProcessor postProcessor :getBeanFactoryPostProcessors()) {
                                                if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                                                    registryPostProcessor = (BeanDefinitionRegistryPostProcessor) postProcessor;
                                                    // 对于BeanDefinitionRegistryPostProcessor类型,在BeanFactoryPostProcessor基础上还有自己定义的方法,需要先调用
                                                    registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
                                                    registryPostProcessors.add(registryPostProcessor);
                                                } else {
                                                    regularPostProcessors.add(postProcessor);
                                                }
                                            }
                                            
                                            // 配置注册的后处理器
                                            Map<String,BeanDefinitionRegistryPostProcessor> beanMap = beannFactory.getBeanOfType(BeanDefinitionRegistryPostProcessor.class, true, false);
                                            List<BeanDefinitionRegistryPostProcessor> registryPostProcessorBeans = new ArrayList<>(beanMap.values());
                                            for (BeanDefinitionRegistryPostProcessor postProcessor : registryPostProcessorBeans) {
                                                postProcessor.postProcessBeanDefinitionRegistry(registry);
                                            }
                                            // 
                                            invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);
                                            invokeBeanFactoryPostProcessors(registryPostProcessorBeans, beanFactory);
                                            invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
                                        } else {
                                            invokeBeanFactoryPostProcessors(getBeanFactoryPostProcessors(), beanFactory);
                                        }
                                        
                                        // 从配置文件中读取的BeanFactoryPostProcessor的处理
                                        String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
                                        List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
                                        List<String> orderedPostProcessorNames = new ArrayList<>();
                                        List<String> nonOrderedPostProcessorNames = new ArrayList<>();
                                        // 对后处理器分类处理
                                        for (String ppName : postProcessorNames) {
                                            if (processedBeans..contains(ppName)) {
                                                // 已经处理过的
                                            } else if (isMatch(ppName, PriorityOrdered.class)) {
                                                priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
                                            } else if (isMatch(ppName, Ordered.class)) {
                                                orderedPostProcessorNames.add(ppName);
                                            } else {
                                                nonOrderedPostProcessorNames.add(ppName);
                                            } 
                                        }
                                        
                                        // 按优先级排序
                                        OrderComparator.sort(priorityOrderedPostProcessors);
                                        invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
                                        
                                        // next, invoke the 
                                        List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
                                        for (String postProcessorName : orderedPostProcessorNames) {
                                            orderedPostProcessors.add(getBean(postProcessorName, BeanFactoryPostProcessor.class));
                                        }
                                        OrderComparator.sort(orderedPostProcessors);
                                        invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
                                        
                                        // 无序直接调用
                                        List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
                                        for (String postProcessorName : nonOrderedPostProcessorNames) {
                                            nonOrderedPostProcessors.add(getBean(postProcessorName, BeanFactoryPostProcessor.class));
                                        }
                                        invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
                                    }
                |-- 6.6.2 注册BeanPostProcessor
                    |-- 自动注册功能
                    |-- MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
                            Object postProcessBeforeInitailization(Object bean, String beanName) {
                                sysout("==============");
                                return null;
                            }
                        }
                    |-- <!-- spring.xml -->
                        <bean class="processors.MyInstantiationAwareBeanPostProcessor"/>
                    |-- ApplicationContext ctx ; -> ctx.get("xxBean") -> sysout("==============");
                    |-- 上面这个特性是在registerBeanPostProcessors方法中完成的
                    |-- protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
                            // 从配置文件中读取的BeanFactoryPostProcessor的处理
                            String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
                            
                            int beanPostTargetProcessorCount = beanFactory.getBeanPostProcessorCount();
                            beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanPostTargetProcessorCount));
                            // 使用PriorityOrdered保证顺序
                            List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
                            // 
                            List<MergedBeanDefinitionPostProccessor> internalPostProcessor = new ArrayList<>();
                            // 使用Ordered保证顺序
                            List<String> orderedPostProcessorNames = new ArrayList<>();
                            // 无序
                            List<String> nonOrderedPostProcessorNames = new ArrayList<>();
                            // 对后处理器分类处理
                            for (String ppName : postProcessorNames) {
                                if (isMatch(ppName, PriorityOrdered.class)) {
                                    BeanFactoryPostProcessor pp = beanFactory.getBean(ppName, BeanFactoryPostProcessor.class);
                                    priorityOrderedPostProcessors.add(pp);
                                    if (pp instanceof MergedBeanDefinitionPostProccessor) {
                                        internalPostProcessor.add(pp);
                                    }
                                } else if (isMatch(ppName, Ordered.class)) {
                                    orderedPostProcessorNames.add(ppName);
                                } else {
                                    nonOrderedPostProcessorNames.add(ppName);
                                } 
                            }
                            
                            // 按优先级排序
                            OrderComparator.sort(priorityOrderedPostProcessors);
                            registerBeanFactoryPostProcessors(beanFactory, priorityOrderedPostProcessors);
                            
                            // next, invoke the 
                            List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
                            for (String postProcessorName : orderedPostProcessorNames) {
                                BeanFactoryPostProcessor pp = beanFactory.getBean(ppName, BeanFactoryPostProcessor.class);
                                orderedPostProcessors.add(pp);
                                if (pp instanceof MergedBeanDefinitionPostProccessor) {
                                    internalPostProcessor.add(pp);
                                }
                            }
                            OrderComparator.sort(orderedPostProcessors);
                            registerBeanFactoryPostProcessors(beanFactory, orderedPostProcessors);
                            
                            // 无序直接调用
                            List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
                            for (String postProcessorName : nonOrderedPostProcessorNames) {
                                BeanFactoryPostProcessor pp = beanFactory.getBean(ppName, BeanFactoryPostProcessor.class);
                                nonOrderedPostProcessors.add(pp);
                                if (pp instanceof MergedBeanDefinitionPostProccessor) {
                                    internalPostProcessor.add(pp);
                                }
                            }
                            registerBeanFactoryPostProcessors(beanFactory, nonOrderedPostProcessors);
                            
                            // 注册所有的MergedBeanDefinitionPostProccessor类型的BeanPostProcessor
                            OrderComparator.sort(internalPostProcessor);
                            registerBeanFactoryPostProcessors(beanFactory, internalPostProcessor);
                            
                            // 添加ApplicationListener探测器
                            beanFactory.addBeanPostProcessor(new ApplicationListenerDetector());
                        }
                
                |-- 6.6.3 初始化消息资源
                    |-- 示例:
                        (1) Locale locale1 = new Locale("zh","CN"); // 带语言+国家/地区信息的
                        (2) Locale locale2 = new Locale("zh"); // 带语言
                        (3) Locale locale3 = Locale.CHINA; // 带语言+国家/地区信息的
                        (4) Locale locale4 = Locale.CHINESS; // 带语言
                        (5) Locale locale5 = Locale.getDefault(); // 系统默认的本地化对象 
                        pattern1 = "{0} hello!";
                        pattern2 = "{0} 你好!";
                        Object[] params = {"John"};
                        // 默认言语格式化
                        String msg1 = MessageFormat.format(pattern1, params);
                        // 指定言语格式化
                        MessageFormat mf = new MessageFormat(pattern2, Locale.US);
                        String msg2 = mf.format(params);
                    |-- 如果使用
                        (1) 定义资源文件
                            |-- messages.properties
                                test=test
                            |-- messages_zh_CN.properties
                                test=测试
                        (2) 定义配置文件(id必须为messageSource)
                            <bean id="messageSource" class="">
                                <property name="basenames">
                                    <list>
                                        <value>test/messages</value>
                                    </list>
                                </property>
                            </bean>
                        (3) 使用。
                            String[] configs = {"applicationContext.xml"};
                            Application ctx = new ClassPathXmlApplicationContext(configs);
                            Object[] params = {"John"};
                            String str1 = ctx.getMessage("test", params, Locale.US);
                            String str2 = ctx.getMessage("test", params, Locale.CHINA);
                    |-- 核心方法:
                        protected void initMessageSource() {
                            beanFactory = getBeanFactory();
                            if (beanFactory.containsLocalBean(MESSAGE_SOURCE_NAME)) {
                                this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_NAME, MessageSource.class);
                                if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
                                    HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
                                    if (hms.getParentMessageSource() == null) {
                                        hms.setParentMessageSource(getInteralParentMessageSource());
                                    }
                                }
                            } else {
                                DelegatingMessageSource dms = new DelegatingMessageSource();
                                dms.setParentMessageSource(getInteralParentMessageSource());
                                this.messageSource = dms;
                                beanFactory.registerSingleton(MESSAGE_SOURCE_NAME, this.messageSource);
                                logger.info(...);
                            }
                        }
                        getMessage(String code, Object[] args, Locale locale) {
                            return getMessageSource().getMessage(code, args, locale);
                        }
                |-- 6.6.4 初始化ApplicationEventMulticaster
                    |-- (1) 定义监听事件
                        |-- TestEvent extends ApplicationEvent {
                                String msg;
                                TestEvent(Object source) {
                                    super(source);
                                }
                                TestEvent(Object source, String msg) {
                                    super(source);
                                    this.msg = msg;
                                }
                                print() {
                                    sysout(msg);
                                }
                            }
                    |-- (2) 定义监听器
                        |-- TestListener implements ApplicationListener {
                                onApplicationEvent(ApplicationEvent event) {
                                    if (event instanceof TestEvent) {
                                        TestEvent testEvent = (TestEvent) event;
                                        testEvent.print();
                                    }
                                }
                            }
                    |-- (3) 添加配置文件
                        <bean id="testListener" class="com.test.event.TestListener"/>
                    |-- (4) 测试
                        Test {
                            main(String[] args) {
                                ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
                                TestEvent event = new TestEvent("hello", "msg");
                                context.publishEvent(event);
                            }
                        }
                    |-- 初始化ApplicationEventMulticaster
                        |-- initApplicationEventMulticaster() {
                                beanFactory = getBeanFactory();
                                if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
                                    this.applicationEventMulticaster = beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
                                    if (logger.isDebugEnable()) {
                                        logger.info(...);
                                    }
                                } else {
                                    this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
                                    beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
                                    if (logger.isDebugEnable()) {
                                        logger.info(...);
                                    }
                                }
                            }
                        |-- SimpleApplicationEventMulticaster {
                                public void multicastEvent(final ApplicationEvent event) {
                                    for ( ApplicationListener listener : getApplicationListeners()) {
                                        Executor executor = getTaskExecutor();
                                        if (executor != null) {
                                            executor.execute(new Runnable(){
                                                run() {
                                                    listener.onApplicationEvent(event);
                                                }
                                            });
                                        } else {
                                            listener.onApplicationEvent(event);
                                        }
                                    }
                                }
                            }
                |-- 6.6.5 注册监听器
                    |-- protected void registerListeners() {
                            for (ApplicationListener listener : getApplicationListeners()) {
                                getApplicationEventMulticaster().addApplicationListener(listener);
                            }
                            // 配置文件注册的监听器处理
                            String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
                            for (String listName : listenerBeanNames) {
                                getApplicationEventMulticaster().addApplicationListenerBean(listName);
                            }
                        }
            |-- 6.7 初始化非延迟加载单例
                |-- protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
                        // InitializingBean 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));
                        }
                        // InitializingBean LoadTimeWeaverAwareProcessor beans early to allow for registering their transformedBeanName 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);
                        // 冻结所有的bean定义,说明注册的bean定义将不被修改或任何进一步的处理
                    }
    待续。。。
  • 相关阅读:
    java常用IO流集合用法模板
    java根据概率生成数字
    从浏览器直接转跳到APP具体页面---(魔窗)MagicWindow使用教程
    java开源即时通讯软件服务端openfire源码构建
    还在繁琐的敲MVP接口和实现类吗,教你一秒搞定。
    手把手带你走进MVP +Dagger2 + DataBinding+ Rxjava+Retrofit 的世界
    poj3666(DP+离散化)
    poj3616(LIS简单变式)
    hdoj2859(矩阵DP)
    poj1088(记忆化搜索入门题)
  • 原文地址:https://www.cnblogs.com/ice-line/p/9590842.html
Copyright © 2011-2022 走看看