zoukankan      html  css  js  c++  java
  • spring源码阅读(二)-IOC之ClassPathXmlApplicationContext

    说明

    一直有阅读Spring的念头,现在觉得不读源码并不代表自己熟悉一门框架。而且spring是平时最常用的框架。

    类图

    类图显示2条线,一种是xml配置方式,一种显示注解配置方式。现在我们都用注解方式比较多

    main

        @Test
        public void lqTEST() {
    //<1> ClassPathXmlApplicationContext ctx
    = new ClassPathXmlApplicationContext( new String[] {LQCONTEXT}, getClass()); assertTrue(ctx.getBean(Student.class).getClasses()!=null); ctx.close(); }

    xml配置

    <beans>
        <bean name="student"  class="org.springframework.lq.Student"></bean>
    </beans>

    ClassPathXmlApplicationContext

    <1>

        public ClassPathXmlApplicationContext(String[] paths, Class<?> clazz) throws BeansException {
            //<2>
            this(paths, clazz, null);
        }

    <2>

    回到上级

        public ClassPathXmlApplicationContext(String[] paths, Class<?> clazz, @Nullable ApplicationContext parent)
                throws BeansException {
    
            super(parent);
            Assert.notNull(paths, "Path array must not be null");
            Assert.notNull(clazz, "Class argument must not be null");
            //要解析的配置文件
            this.configResources = new Resource[paths.length];
            for (int i = 0; i < paths.length; i++) {
                //封装成ClassPathResource
                this.configResources[i] = new ClassPathResource(paths[i], clazz);
            }
            //<3>开始执行容器初始化
            refresh();
        }

    AbstractApplicationContext

    <3>

    回到上级

    org.springframework.context.support.AbstractApplicationContext#refresh

        @Override
        public void refresh() throws BeansException, IllegalStateException {
            /*
             *加锁 防止在初始化过程中,继续调用初始化和 销毁的方法
             */
            synchronized (this.startupShutdownMonitor) {
    
                //初始化容器的准备工作
                // <4>将 active 属性设置为 true,closed 属性设置为 false,它们都是 AtomicBoolean 类型
                prepareRefresh();
    
                //将会初始化 BeanFactory、加载 Bean、注册 Bean 等等。只是将需要初始化的bean通过BeanDefinition封装
                //<5>BeanDefinition封装了如何初始化bean
                ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
                //<19>为beanFactory设置创建bean的ClassLoader 添加几个 BeanPostProcessor,手动注册几个特殊的 bean 供后续使用
                prepareBeanFactory(beanFactory);
    
                try {
                    /**
                     *这里是提供给子类的扩展点,到这里的时候,所有的 Bean 都加载、注册完成了,但是都还没有初始化
                     *通过beanFactory我们可以获取并改变BeanDefinition 的属性改变将要创建bean的信息
                     * 钩子方法 目前空实现               */
                    postProcessBeanFactory(beanFactory);
    
    
    
                    /**
                     * 1.实例化并调用所有已注册的 BeanFactoryPostProcessor的实现类
                     * 这里是spring提供的扩展展点。我们可以通过实现BeanFactoryPostProcessor 在回调拿到beanFactory
                     * 我们可以往里面注册BeanDefinition或者改变Definition的值
                     * 注册:
                     *可以参考:org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#processBeanDefinition使用
                     *BeanDefinitionReaderUtils#registerBeanDefinition 注册 使用例子可参考:附录
                     * */
                    invokeBeanFactoryPostProcessors(beanFactory);
    
                    /**
                     * 初始化 BeanPostProcessor的实现类 注意这里并没有调用 只是先初始化这个接口的实现类到容器
                     * 1.实例化、依赖注入完毕,在调用显示的初始化之前完成一些定制的初始化任务
                     * 2.实例化、依赖注入、初始化完毕时执行
                     */
                    registerBeanPostProcessors(beanFactory);
    
                    //初始化当前 ApplicationContext 的 MessageSource 国际化相关
                    initMessageSource();
    
    
                    /**
                     * 初始化当前 ApplicationContext 的事件广播器 先在容器中找 如果没有则创建默认的
                     * ApplicationEventMulticaster 这个接口可以管理很多个ApplicationListener对象。并将事件发布给这些监听器
    * 可参考附录用法
    */ initApplicationEventMulticaster(); //扩展方法 具体的子类可以在这里初始化一些特殊的 Bean(在初始化 singleton beans 之前) onRefresh(); // 注册事件监听器,监听器需要实现 ApplicationListener 接口 <35> registerListeners(); /** * 核心方法 * <20>初始化所有的 singleton bean BeanDefinition isLazyInit为 lazy-init 的除外 */ finishBeanFactoryInitialization(beanFactory); /** * 完成刷新Context,主要调用org.springframework.context.LifecycleProcessor接口onRefresh方法,发布事件ContextRefreshedEvent事件 */ finishRefresh(); } catch (BeansException ex) { if (logger.isWarnEnabled()) { logger.warn("Exception encountered during context initialization - " + "cancelling refresh attempt: " + ex); } // 销毁已经初始化的 singleton 的 Beans,以免有些 bean 会一直占用资源 destroyBeans(); // 将active 设置为false 表示此容器不可用 cancelRefresh(ex); // Propagate exception to caller. throw ex; } finally { //重置Spring核心中的常见内核缓存,因为我们可能不再需要单例bean的元数据了 resetCommonCaches(); } } }

    <4>

    回到上级

    org.springframework.context.support.AbstractApplicationContext#prepareRefresh

        protected void prepareRefresh() {
            // Switch to active.
            this.startupDate = System.currentTimeMillis();
            //未关闭
            this.closed.set(false);
            //已激活
            this.active.set(true);
    ........省略部分
    }

    <5>

    回到上级

    protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
            //<6>销毁初始化过的BeanFactory 创建新的BeanFactory 加载Bean定义和注册Bean 模板方法由子类实现
             refreshBeanFactory();
             //获得BeanFactory
            ConfigurableListableBeanFactory beanFactory = getBeanFactory();
            if (logger.isDebugEnabled()) {
                logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
            }
            return beanFactory;
        }

    <19>

    回到上级

    org.springframework.context.support.AbstractApplicationContext#prepareBeanFactory

    protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
            /**
             *设置 BeanFactory 的类加载器,我们知道 BeanFactory 需要加载类,也就需要类加载器,
             *这里设置为加载当前 ApplicationContext 类的类加载器
             */
            beanFactory.setBeanClassLoader(getClassLoader());
            /**
             *设置beanFactory的表达式语言处理器,Spring3增加了表达式语言的支持,
             *默认可以使用#{bean.xxx}的形式来调用相关属性值
             */
            beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
            /**
             * 为beanFactory增加了一个默认的propertyEditor,这个主要是对bean的属性等设置管理的一个工具
             */
            beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
    
            /**
             * 添加一个 BeanPostProcessor,这个 processor 比较简单:
             *实现了 Aware 接口的 beans 在初始化的时候,这个 processor 负责回调实现注入
             *点进去下一下源码就清楚了
             *org.springframework.context.support.ApplicationContextAwareProcessor#postProcessBeforeInitialization(java.lang.Object, java.lang.String)
             */
            beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
            //如果某个 bean 依赖于以下几个接口的实现类,在自动装配的时候忽略它们,
            //比如 注入 @autowired EnvironmentAware ev;
            beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
            beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
            beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
            beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
            beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
            beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
    
            /**
             * Spring自动装配的时候如果一个接口有多个实现类,并且都已经放到IOC中去了,
             * 那么自动装配的时候就会出异常,因为spring不知道把哪个实现类注入进去,
             * 所以再这里指定注入哪个对象
             */
            beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
            beanFactory.registerResolvableDependency(ResourceLoader.class, this);
            beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
            beanFactory.registerResolvableDependency(ApplicationContext.class, this);
    
            /**
             * 1、在Bean初始化完成之后:如果Bean是单例的则并且bean instanceof ApplicationListener。加入到this.applicationListeners中。
             * 2、在Bean销毁之前搞事情: 如果Bean是一个ApplicationListener,则会从ApplicationEventMulticaster(事件广播器)中提前删除了
    * 可以参考附录 ApplicationListener的用法
    */ beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this)); /** * 如果当前BeanFactory包含loadTimeWeaver Bean,说明存在类加载期织入AspectJ。 * 则把当前BeanFactory交给类加载期BeanPostProcessor实现类LoadTimeWeaverAwareProcessor来处理,从而实现类加载期织入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())); } /** * 以下是当我们配有配置 spring注册一个默认的 * 比如:如果容器中没有environment 则注册一个默认的 */ if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) { beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment()); } //注册系统配置systemProperties组件Bean if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) { beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties()); } //注册系统环境systemEnvironment组件Bean if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) { beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment()); } }

    <20>

    回到上级

    org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization

        protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    
            /// 为上下文初始化类型转换器 首先,初始化名字为 conversionService的bean 需要实现ConversionService 的 Bean spring的类型转换器(非常实用)
            //可以参考此org.springframework.context.support.ConversionServiceFactoryBean用法 可参考附录用法
            if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
                    beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
                //通过getBean初始化并设置到beanFactory
                beanFactory.setConversionService(
                        beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
            }
    
            // 检查上下文中是否存在类型转换器 如没有则创建一个默认的 处理@Value注解
            if (!beanFactory.hasEmbeddedValueResolver()) {
                beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
            }
    
            // 先初始化 LoadTimeWeaverAware 类型的 Bean 以便尽早注册它们的转换器。AspectJ 相关的内容
            String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
            for (String weaverAwareName : weaverAwareNames) {
                getBean(weaverAwareName);
            }
    
            //    // 禁止使用临时类加载器进行类型匹配
            beanFactory.setTempClassLoader(null);
    
            /**
             * 设置configurationFrozen为true
             * 因为到这一步的时候,Spring 已经开始预初始化 singleton beans 了,这个时候肯定不希望这个时候还出现 bean 定义解析、加载、注册。所以打上标识
             */
            beanFactory.freezeConfiguration();
    
            //<21>开始初始化
            beanFactory.preInstantiateSingletons();
        }

    <35>

    org.springframework.context.support.AbstractApplicationContext#registerListeners

    protected void registerListeners() {
            //从容器获得所有ApplicationListener 将容器局部变量的Linstenner设置到容器
            for (ApplicationListener<?> listener : getApplicationListeners()) {
                getApplicationEventMulticaster().addApplicationListener(listener);
            }
    
            // Do not initialize FactoryBeans here: We need to leave all regular beans
            // uninitialized to let post-processors apply to them!
            String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
            for (String listenerBeanName : listenerBeanNames) {
                getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
            }
    
            // Publish early application events now that we finally have a multicaster...
            Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
            this.earlyApplicationEvents = null;
            if (earlyEventsToProcess != null) {
                for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
                    getApplicationEventMulticaster().multicastEvent(earlyEvent);
                }
            }
        }

    AbstractRefreshableApplicationContext

    <6>

    回到上级

    这里我们可以看到 虽然容器实现了BeanFactory 但是是组合关系 而非继承关系 BeanFactory相关都委托给了内部属性BeanFacotry 自己没有相关实现

    org.springframework.context.support.AbstractRefreshableApplicationContext#refreshBeanFactory

    protected final void refreshBeanFactory() throws BeansException {
            /**
             * 判断是否Application是否加载过beanFactory
             * 如果 ApplicationContext 中已经加载过 BeanFactory 了,销毁所有 Bean,关闭 BeanFactory
             *注意,应用中 BeanFactory 本来就是可以多个的,这里可不是说应用全局是否有 BeanFactory,而是当前
             * ApplicationContext 是否有 BeanFactory 主要看容器实现
             */
            if (hasBeanFactory()) {
                //销毁BeanFactory
                destroyBeans();
                closeBeanFactory();
            }
            try {
                /**
                 * 创建一个DefaultListableBeanFactory 如果当前容器有父容器则将父容器的BeanFactory设置为当前BeanFactory的父级
                 * 如果父级是ConfigurableApplicationContext 则获取父级的BeanFactory
                 * 如果非ConfigurableApplicationContext类型 则直接使用父容器 因为父容器也实现了BeanFactory
                 */
                DefaultListableBeanFactory beanFactory = createBeanFactory();
    
                //序列化的SerializationId
                beanFactory.setSerializationId(getId());
    
                // 设置 BeanFactory 的两个配置属性:是否允许 Bean 覆盖、是否允许循环引用
                customizeBeanFactory(beanFactory);
    
                /**
                 * 加载 BeanDefinition 到 BeanFactory 中 模板方法子类实现
                 * 比如classPath则扫描xml 解析并生成
                 * 如果是注解 则扫描注解 反射解析生成
                 * <7>模板方法  由子类自定义实现
                 */
    
                loadBeanDefinitions(beanFactory);
                this.beanFactory = beanFactory;
            } catch (IOException ex) {
                throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
            }
        }

    AbstractXmlApplicationContext

    <7>

    回到上级

    解析xml的方式是委托给XmlBeanDefinitionReader

    org.springframework.context.support.AbstractXmlApplicationContext#loadBeanDefinitions(org.springframework.beans.factory.support.DefaultListableBeanFactory)

    protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
            /// 将BeanFactory设置到reader BeanFactory 实例化一个 XmlBeanDefinitionReader 将解析xml的操作委托给它处理
            XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
    
            // Configure the bean definition reader with this context's
            // resource loading environment.
            beanDefinitionReader.setEnvironment(this.getEnvironment());
            //要扫描的资源信息
            beanDefinitionReader.setResourceLoader(this);
            /**
             * entityResolver的作用是项目本身就可以提供一个如何寻找DTD声明的方法,即由程序来实现寻找DTD声明的过程,
             * 比如我们将DTD文件放到项目中某处,在实现时直接将此文档读取并返回给SAX即可。这样就避免了通过网络来寻找相应的声明。
             */
            beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
    
            /**
             * //当Bean 读取器读取Bean 定义的Xml 资源文件时,启用Xml 的校验机制
             */
            initBeanDefinitionReader(beanDefinitionReader);
            /**
             * <8>加载beanDefinition
             */
            loadBeanDefinitions(beanDefinitionReader);
        }

    <8>

    回到上级

    org.springframework.context.support.AbstractXmlApplicationContext#loadBeanDefinitions(org.springframework.beans.factory.xml.XmlBeanDefinitionReader)

        protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
    
            //获得要价值的xmlResource
            Resource[] configResources = getConfigResources();
            if (configResources != null) {
                reader.loadBeanDefinitions(configResources);
            }
            //子类重写 xml配置的路径,
            String[] configLocations = getConfigLocations();
            if (configLocations != null) {
                //<9>进行加载
                reader.loadBeanDefinitions(configLocations);
            }
        }

    AbstractBeanDefinitionReader

    <9>

    回到上级

    @Override
        public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
            Assert.notNull(locations, "Location array must not be null");
            int counter = 0;
            //资源文件可以配置多个 所以循环加载
            for (String location : locations) {
                //<10>执行xml加载
                counter += loadBeanDefinitions(location);
            }
            return counter;
        }

    <10>

    回到上级

    public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
            //这里的ResoureceLoader是真实的beanFacotry容器实现了接口
            ResourceLoader resourceLoader = getResourceLoader();
            if (resourceLoader == null) {
                throw new BeanDefinitionStoreException(
                        "Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
            }
             //判断是否实现了Resolver接口如果实现了 则传入路径 返回Resource
            // 这里是个扩展点,我们可以通过容器的ResourcePatternResolver 返回加载配置的地址
            if (resourceLoader instanceof ResourcePatternResolver) {
                // Resource pattern matching available.
                try {
                    //如果
                    Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
                    //加载
                    int loadCount = loadBeanDefinitions(resources);
                    if (actualResources != null) {
                        for (Resource resource : resources) {
                            actualResources.add(resource);
                        }
                    }
                    if (logger.isDebugEnabled()) {
                        logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");
                    }
                    return loadCount;
                }
                catch (IOException ex) {
                    throw new BeanDefinitionStoreException(
                            "Could not resolve bean definition resource pattern [" + location + "]", ex);
                }
            }
            else {
                //从BeanFactory里面根据location获取Resource
                Resource resource = resourceLoader.getResource(location);
                //<11>模板方法 子类实现
                int loadCount = loadBeanDefinitions(resource);
                if (actualResources != null) {
                    actualResources.add(resource);
                }
                if (logger.isDebugEnabled()) {
                    logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
                }
                return loadCount;
            }
        }

    XmlBeanDefinitionReader

    <11>

    回到上级

    org.springframework.beans.factory.xml.XmlBeanDefinitionReader#loadBeanDefinitions(org.springframework.core.io.support.EncodedResource)

        public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
            Assert.notNull(encodedResource, "EncodedResource must not be null");
            if (logger.isInfoEnabled()) {
                logger.info("Loading XML bean definitions from " + encodedResource);
            }
            // 用一个 ThreadLocal 来存放配置文件资源
            Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
            if (currentResources == null) {
                currentResources = new HashSet<>(4);
                this.resourcesCurrentlyBeingLoaded.set(currentResources);
            }
            //表示重复加载了
            if (!currentResources.add(encodedResource)) {
                throw new BeanDefinitionStoreException(
                        "Detected cyclic loading of " + encodedResource + " - check your import definitions!");
            }
            try {
                InputStream inputStream = encodedResource.getResource().getInputStream();
                try {
                    InputSource inputSource = new InputSource(inputStream);
                    if (encodedResource.getEncoding() != null) {
                        //通知 SAX 解析器使用何种编码;在涉及国际化或使用多字节字符集的 XML 应用程序中
                        inputSource.setEncoding(encodedResource.getEncoding());
                    }
                    //<12>进行加载
                    return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
                }
                finally {
                    inputStream.close();
                }
            }
            catch (IOException ex) {
                throw new BeanDefinitionStoreException(
                        "IOException parsing XML document from " + encodedResource.getResource(), ex);
            }
            finally {
                currentResources.remove(encodedResource);
                if (currentResources.isEmpty()) {
                    this.resourcesCurrentlyBeingLoaded.remove();
                }
            }
        }

    <12>

    回到上级

    org.springframework.beans.factory.xml.XmlBeanDefinitionReader#doLoadBeanDefinitions

    protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
                throws BeanDefinitionStoreException {
            try {
                //将XML转换为Document对象
                Document doc = doLoadDocument(inputSource, resource);
                //<13>解析doc 并封装成Definition
                return registerBeanDefinitions(doc, resource);
            }
            catch (BeanDefinitionStoreException ex) {
                throw ex;
            }
            catch (SAXParseException ex) {
                throw new XmlBeanDefinitionStoreException(resource.getDescription(),
                        "Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
            }
            catch (SAXException ex) {
                throw new XmlBeanDefinitionStoreException(resource.getDescription(),
                        "XML document from " + resource + " is invalid", ex);
            }
            catch (ParserConfigurationException ex) {
                throw new BeanDefinitionStoreException(resource.getDescription(),
                        "Parser configuration exception parsing XML from " + resource, ex);
            }
            catch (IOException ex) {
                throw new BeanDefinitionStoreException(resource.getDescription(),
                        "IOException parsing XML document from " + resource, ex);
            }
            catch (Throwable ex) {
                throw new BeanDefinitionStoreException(resource.getDescription(),
                        "Unexpected exception parsing XML document from " + resource, ex);
            }
        }

    <13>

    回到上级

    org.springframework.beans.factory.xml.XmlBeanDefinitionReader#registerBeanDefinitions

        public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
            //获得的的读取器
            BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
            int countBefore = getRegistry().getBeanDefinitionCount();
            //<14>解析Document 并注册到Bean Facotry
            documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
            return getRegistry().getBeanDefinitionCount() - countBefore;
        }

    DefaultBeanDefinitionDocumentReader

    <14>

    回到上级

    org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#doRegisterBeanDefinitions

    protected void doRegisterBeanDefinitions(Element root) {
            // 我们看名字就知道,BeanDefinitionParserDelegate 必定是一个重要的类,它负责解析 Bean 定义,
            // 这里为什么要定义一个 parent? 看到后面就知道了,是递归问题,
            // 因为 <beans /> 内部是可以定义 <beans /> 的,所以这个方法的 root 其实不一定就是 xml 的根节点,也可以是嵌套在里面的 <beans /> 节点,
            // 从源码分析的角度,我们当做根节点就好了
            BeanDefinitionParserDelegate parent = this.delegate;
            this.delegate = createDelegate(getReaderContext(), root, parent);
    
            if (this.delegate.isDefaultNamespace(root)) {
                String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
                //// 这块说的是根节点 <beans ... profile="dev" /> 中的 profile 是否是当前环境需要的,
                if (StringUtils.hasText(profileSpec)) {
                    String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
                            profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
                    //// 如果当前环境配置的 profile 不包含此 profile,那就直接 return 了,不对此 <beans /> 解析
                    if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
                        if (logger.isInfoEnabled()) {
                            logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
                                    "] not matching: " + getReaderContext().getResource());
                        }
                        return;
                    }
                }
            }
            //提供给子类的扩展方法
            preProcessXml(root);
            //<15>从头root节点开始解析
            parseBeanDefinitions(root, this.delegate);
            //提供给子类的扩展方法
            postProcessXml(root);
    
            this.delegate = parent;
        }

    <15>

    回到上级

    org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#parseBeanDefinitions

        protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
            //是否定义namespace http://www.springframework.org/schema/beans
            if (delegate.isDefaultNamespace(root)) {
                NodeList nl = root.getChildNodes();
                for (int i = 0; i < nl.getLength(); i++) {
                    Node node = nl.item(i);
                    if (node instanceof Element) {
                        Element ele = (Element) node;
                        if (delegate.isDefaultNamespace(ele)) {
                            /**
                             * <16></>parseDefaultElement(ele, delegate) 代表解析的节点是 <import />、<alias />、<bean />、<beans /> 这几个。
                             */
                            parseDefaultElement(ele, delegate);
                        } else {
                            /**
                             * 解析扩展标签 如 <mvc />、<task />、<context />、<aop />等。通过schema 可以参考dubbo的实现
                             * 如 MvcNamespaceHandler、TaskNamespaceHandler、ContextNamespaceHandler、AopNamespaceHandler 等
                             */
                            delegate.parseCustomElement(ele);
                        }
                    }
                }
            } else {
                delegate.parseCustomElement(root);
            }
        }

    <16>

    回到上级

    org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#parseDefaultElement

        private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
            if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
                 // 处理 <import /> 标签
                importBeanDefinitionResource(ele);
            } else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
                // 处理 <alias /> 标签定义
                // <alias name="fromName" alias="toName"/>
                processAliasRegistration(ele);
            } else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
                // <17>处理 <bean /> 标签定义,这也算是我们的重点吧
                processBeanDefinition(ele, delegate);
            } else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
                // 如果碰到的是嵌套的 <beans /> 标签,需要递归
                doRegisterBeanDefinitions(ele);
            }
        }

    <17>

    回到上级

    org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#processBeanDefinition

        protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
            // 将 <bean /> 节点中的信息提取出来,然后封装到一个 BeanDefinitionHolder 中,细节往下看
            BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
            if (bdHolder != null) {
                // 如果有自定义属性的话,进行相应的解析
                bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
                try {
                    // <18>我们把这步叫做 注册Bean
                    BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
                } catch (BeanDefinitionStoreException ex) {
                    getReaderContext().error("Failed to register bean definition with name '" +
                            bdHolder.getBeanName() + "'", ele, ex);
                }
                // 注册完成后,发送事件
                getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
            }
        }

    <18>

    回到上级

    返回最外层

    org.springframework.beans.factory.support.BeanDefinitionReaderUtils#registerBeanDefinition

    public static void registerBeanDefinition(
                BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
                throws BeanDefinitionStoreException {
    
            // Register bean definition under primary name.
            String beanName = definitionHolder.getBeanName();
            // 注册这个 Bean
            registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
    
            // 如果还有别名的话,也要根据别名全部注册一遍,不然根据别名就会找不到 Bean 了
            String[] aliases = definitionHolder.getAliases();
            if (aliases != null) {
                for (String alias : aliases) {
                    // alias -> beanName 保存它们的别名信息,这个很简单,用一个 map 保存一下就可以了,
                    // 获取的时候,会先将 alias 转换为 beanName,然后再查找
                    registry.registerAlias(beanName, alias);
                }
            }
        }

    到这里 如何初始化对象就交给BeanDefinition封装起来了。但是还没有初始化

    BeanDefinition代码太长就不贴了 可以去看一下BeanDefinition的定义 

    DefaultListableBeanFactory

    <21>

    回到上级

    org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons

    public void preInstantiateSingletons() throws BeansException {
            if (logger.isDebugEnabled()) {
                logger.debug("Pre-instantiating singletons in " + this);
            }
    
            // this.beanDefinitionNames 保存了所有的 beanNames
            List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
    
            //触发所有的非懒加载的 singleton beans 的初始化操作
            for (String beanName : beanNames) {
                /**
                 * / 合并父 Bean 中的配置,如: <bean id="" class="" parent="" /> 中的 parent
                 * 具体看 bean parent用法
                 */
                RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
                // 非抽象、非懒加载的 singletons。如果配置了 'abstract = true',那是不需要初始化的
                if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                    //是否是factoryBean 可参考附录
                    if (isFactoryBean(beanName)) {
                        //如果是FactoryBean则初始化 并在beanName前面拼上&
                        Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                        if (bean instanceof FactoryBean) {
                            FactoryBean<?> factory = (FactoryBean<?>) bean;
                            boolean isEagerInit;
                            //判断factory是否是SmartFactoryBean实现
                            if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                                isEagerInit = AccessController.doPrivileged(
                                        (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
                                        getAccessControlContext());
                            }
                            else {
                                isEagerInit = (factory instanceof SmartFactoryBean &&
                                        ((SmartFactoryBean<?>) factory).isEagerInit());
                            }
                            if (isEagerInit) {
                                getBean(beanName);
                            }
                        }
                    }
                    else {
                        //<22>对于普通的 Bean,只要调用 getBean(beanName) 这个方法就可以进行初始化了
                        getBean(beanName);
                    }
                }
            }
    
            // Trigger post-initialization callback for all applicable beans...
            for (String beanName : beanNames) {
                Object singletonInstance = getSingleton(beanName);
                if (singletonInstance instanceof SmartInitializingSingleton) {
                    SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
                    if (System.getSecurityManager() != null) {
                        AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                            smartSingleton.afterSingletonsInstantiated();
                            return null;
                        }, getAccessControlContext());
                    }
                    else {
                        smartSingleton.afterSingletonsInstantiated();
                    }
                }
            }
        }

    AbstractBeanFactory

    <22>

    回到上级

    org.springframework.beans.factory.support.AbstractBeanFactory#getBean(java.lang.String)

        @Override
        public Object getBean(String name) throws BeansException {
            return doGetBean(name, null, null, false);
        }
    protected <T> T doGetBean(
                String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
                throws BeansException {
    
           // 获取一个 “正统的” beanName,处理两种情况,一个是前面说的 FactoryBean(前面带 ‘&’),去掉&
            // 一个传入的是别名问题,因为这个方法是 getBean,获取 Bean 用的,你要是传一个别名进来,是完全可以的
            String beanName = transformedBeanName(name);
            Object bean;
    
            /**
             *   根据beanName尝试从singletonObjects获取Bean
             *    获取不到则再尝试从earlySingletonObjects,singletonFactories 从获取Bean
             *     这段代码和解决循环依赖有关
             */
            Object sharedInstance = getSingleton(beanName);
            //// 第一次进入sharedInstance肯定为null
            if (sharedInstance != null && args == null) {
                if (logger.isDebugEnabled()) {
                    if (isSingletonCurrentlyInCreation(beanName)) {
                        logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
                                "' that is not fully initialized yet - a consequence of a circular reference");
                    }
                    else {
                        logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
                    }
                }
                // 下面这个方法:如果是普通 Bean 的话,直接返回 sharedInstance,
                // 如果是 FactoryBean 的话,调用getObject返回它创建的那个实例对象
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
            }
    
            else {
                //判断是否循环依赖
                if (isPrototypeCurrentlyInCreation(beanName)) {
                    throw new BeanCurrentlyInCreationException(beanName);
                }
    
                //获取父BeanFactory,一般情况下,父BeanFactory为null,如果存在父BeanFactory,就先去父级容器去查找
                BeanFactory parentBeanFactory = getParentBeanFactory();
                //// 如果当前容器不存在这个 BeanDefinition,试试父容器中有没有
                if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
    
                    //调用父容器的doGetBean尝试获取
                    String nameToLookup = originalBeanName(name);
                    if (parentBeanFactory instanceof AbstractBeanFactory) {
                        return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                                nameToLookup, requiredType, args, typeCheckOnly);
                    }
                    else if (args != null) {
    
                        return (T) parentBeanFactory.getBean(nameToLookup, args);
                    }
                    else {
                        // No args -> delegate to standard getBean method.
                        return parentBeanFactory.getBean(nameToLookup, requiredType);
                    }
                }
               // 创建的Bean是否需要进行类型验证,一般情况下都不需要
                if (!typeCheckOnly) {
                    //// 标记 bean 已经被创建
                    markBeanAsCreated(beanName);
                }
    
                try {
                    //// 获取其父类Bean定义,子类合并父类公共属性
                    RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                    checkMergedBeanDefinition(mbd, beanName, args);
    
                    // Guarantee initialization of beans that the current bean depends on.
                    String[] dependsOn = mbd.getDependsOn();
                    if (dependsOn != null) {
                        for (String dep : dependsOn) {
                            // 检查是不是有循环依赖,
                            if (isDependent(beanName, dep)) {
                                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                        "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                            }
                            // 如果当前Bean依赖其他Bean,把被依赖Bean注册给当前Bean
                            registerDependentBean(dep, beanName);
                            try {
                                //// 先去创建所依赖的Bean
                                getBean(dep);
                            }
                            catch (NoSuchBeanDefinitionException ex) {
                                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                        "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                            }
                        }
                    }
    
                    // 如果是 singleton scope 的,创建 singleton 的实例
                    if (mbd.isSingleton()) {
                        //创建单例bean
                        sharedInstance = getSingleton(beanName, () -> {
                            try {
                                return createBean(beanName, mbd, args);
                            }
                            catch (BeansException ex) {
                                // Explicitly remove instance from singleton cache: It might have been put there
                                // eagerly by the creation process, to allow for circular reference resolution.
                                // Also remove any beans that received a temporary reference to the bean.
                                destroySingleton(beanName);
                                throw ex;
                            }
                        });
                        bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                    }
                    // 创建prototype Bean,每次都会创建一个新的对象
                    else if (mbd.isPrototype()) {
                        // It's a prototype -> create a new instance.
                        Object prototypeInstance = null;
                        try {
                            //// 回调beforePrototypeCreation方法,注册当前创建的原型对象
                            beforePrototypeCreation(beanName);
                            //// 回调 afterPrototypeCreation 方法,告诉容器该Bean的原型对象不再创建
                            prototypeInstance = createBean(beanName, mbd, args);
                        }
                        finally {
                            afterPrototypeCreation(beanName);
                        }
                        bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                    }
    
                    else {
                        //如果既不是单例Bean,也不是prototype,则获取其Scope 委托给相应的Scope实现类创建
                        String scopeName = mbd.getScope();
                        if (!StringUtils.hasLength(scopeName)) {
                            throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
                        }
                        Scope scope = this.scopes.get(scopeName);
                        if (scope == null) {
                            throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
                        }
                        try {
                            Object scopedInstance = scope.get(beanName, () -> {
                                beforePrototypeCreation(beanName);
                                try {
                                    //创建bean 传入beanName,RootBeanDefinition 抽象方法 子类实现
                                    //<23>args 数组代表创建实例需要的参数,不就是给构造方法用的参数,或者是工厂 Bean 的参数嘛,不过要注意,在我们的初始化阶段,args 是 null。
                                    return createBean(beanName, mbd, args);
                                }
                                finally {
                                    afterPrototypeCreation(beanName);
                                }
                            });
                            bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                        }
                        catch (IllegalStateException ex) {
                            throw new BeanCreationException(beanName,
                                    "Scope '" + scopeName + "' is not active for the current thread; consider " +
                                    "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
                                    ex);
                        }
                    }
                }
                catch (BeansException ex) {
                    cleanupAfterBeanCreationFailure(beanName);
                    throw ex;
                }
            }
    
            // 最后如果设置了类型requiredType,检查一下类型对不对,不对的话就抛异常,对的话就返回了
            if (requiredType != null && !requiredType.isInstance(bean)) {
                try {
                    T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
                    if (convertedBean == null) {
                        throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
                    }
                    return convertedBean;
                }
                catch (TypeMismatchException ex) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Failed to convert bean '" + name + "' to required type '" +
                                ClassUtils.getQualifiedName(requiredType) + "'", ex);
                    }
                    throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
                }
            }
            return (T) bean;
        }

    AbstractAutowireCapableBeanFactory

    <23> 

    回到上级

    org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean

        protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
                throws BeanCreationException {
    
            if (logger.isDebugEnabled()) {
                logger.debug("Creating instance of bean '" + beanName + "'");
            }
            RootBeanDefinition mbdToUse = mbd;
    
            // // 获得beanDefinition的class
            Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
            if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
                mbdToUse = new RootBeanDefinition(mbd);
                mbdToUse.setBeanClass(resolvedClass);
            }
    
            // Prepare method overrides.
            try {
                /**
                 *准备方法覆写,这里又涉及到一个概念:MethodOverrides,它来自于 bean 定义中的<lookup -method / >
                 *  和 <replaced-method /> 可参考 附录
                */
                mbdToUse.prepareMethodOverrides();
            }
            catch (BeanDefinitionValidationException ex) {
                throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                        beanName, "Validation of method overrides failed", ex);
            }
    
            try {
                // 让 InstantiationAwareBeanPostProcessor 在这一步有机会替代对象。 此接口是BeanPostProcessor的子接口
                Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
                //如果通过此扩展点创建了对象 则直接返回对象 不会执行下面createBean
                if (bean != null) {
                    return bean;
                }
            }
            catch (Throwable ex) {
                throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
                        "BeanPostProcessor before instantiation of bean failed", ex);
            }
    
            try {
                //<24>重头戏,创建 bean
                Object beanInstance = doCreateBean(beanName, mbdToUse, args);
                if (logger.isDebugEnabled()) {
                    logger.debug("Finished creating instance of bean '" + beanName + "'");
                }
                return beanInstance;
            }
            catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
                // A previously detected exception with proper bean creation context already,
                // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
                throw ex;
            }
            catch (Throwable ex) {
                throw new BeanCreationException(
                        mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
            }
        }

    <24>

    返回上一级

    org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean

    protected Object doCreatexBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
                throws BeanCreationException {
    
            // Instantiate the bean.
            BeanWrapper instanceWrapper = null;
            // //如果RootBeanDefinition是单例的,则移除未完成的FactoryBean实例的缓存
            if (mbd.isSingleton()) {
                instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
            }
            if (instanceWrapper == null) {
                //<25>这里实例化 Bean 通过BeanWrapper包装
                instanceWrapper = createBeanInstance(beanName, mbd, args);
            }
            // 这个就是 Bean 里面的 我们定义的类 的实例,很多地方我直接描述成 "bean 实例"
            Object bean = instanceWrapper.getWrappedInstance();
            //获取bean的Class
            Class<?> beanType = instanceWrapper.getWrappedClass();
            if (beanType != NullBean.class) {
                mbd.resolvedTargetType = beanType;
            }
    
            // Allow post-processors to modify the merged bean definition.
            synchronized (mbd.postProcessingLock) {
                if (!mbd.postProcessed) {
                    try {
                      //bean 的生命周期之一。如果实现了MergedBeanDefinitionPostProcessor会在这里调用postProcessMergedBeanDefinition方法
                        //代表性的实现就是org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor
                        //找到打上@Autowired @Value注解的元数据信息
                        applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                    }
                    catch (Throwable ex) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                "Post-processing of merged bean definition failed", ex);
                    }
                    mbd.postProcessed = true;
                }
            }
    
            //// 下面这块代码是为了解决循环依赖的问题
            boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                    isSingletonCurrentlyInCreation(beanName));
            if (earlySingletonExposure) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Eagerly caching bean '" + beanName +
                            "' to allow for resolving potential circular references");
                }
                addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
            }
    
            // Initialize the bean instance.
            Object exposedObject = bean;
            try {
                /**
                 * 负责装配bean的属性 静态注入
                 *<27> @Autowrit @Value动态注入 InstantiationAwareBeanPostProcessor
                 *
                 */
                populateBean(beanName, mbd, instanceWrapper);
                //<30>bean初始化完成后的各种回调
                exposedObject = initializeBean(beanName, exposedObject, mbd);
            }
            catch (Throwable ex) {
                if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
                    throw (BeanCreationException) ex;
                }
                else {
                    throw new BeanCreationException(
                            mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
                }
            }
    
            if (earlySingletonExposure) {
                Object earlySingletonReference = getSingleton(beanName, false);
                if (earlySingletonReference != null) {
                    if (exposedObject == bean) {
                        exposedObject = earlySingletonReference;
                    }
                    else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                        String[] dependentBeans = getDependentBeans(beanName);
                        Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
                        for (String dependentBean : dependentBeans) {
                            if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                                actualDependentBeans.add(dependentBean);
                            }
                        }
                        if (!actualDependentBeans.isEmpty()) {
                            throw new BeanCurrentlyInCreationException(beanName,
                                    "Bean with name '" + beanName + "' has been injected into other beans [" +
                                    StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
                                    "] in its raw version as part of a circular reference, but has eventually been " +
                                    "wrapped. This means that said other beans do not use the final version of the " +
                                    "bean. This is often the result of over-eager type matching - consider using " +
                                    "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
                        }
                    }
                }
            }
    
            // Register bean as disposable.
            try {
                registerDisposableBeanIfNecessary(beanName, bean, mbd);
            }
            catch (BeanDefinitionValidationException ex) {
                throw new BeanCreationException(
                        mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
            }
    
            return exposedObject;
        }

    <25>

    返回上一级

    org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance

        protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
            //beanDefinition解析bean的class
            Class<?> beanClass = resolveBeanClass(mbd, beanName);
    
            //校验一下是否有访问权限
            if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
            }
    
            // 通过beanDefinition中的supplier实例化这个bean
            Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
            if (instanceSupplier != null) {
                return obtainFromSupplier(instanceSupplier, beanName);
            }
            // 通过FactoryMethod实例化这个bean
            if (mbd.getFactoryMethodName() != null) {
                return instantiateUsingFactoryMethod(beanName, mbd, args);
            }
    
            // 下面这段代码都是在通过构造函数实例化这个Bean,分两种情况,一种是通过默认的无参构造,一种    有参数的构造方法
            //是否解析过
            boolean resolved = false;
            //false无参  true有参
            boolean autowireNecessary = false;
            if (args == null) {
                synchronized (mbd.constructorArgumentLock) {
                    if (mbd.resolvedConstructorOrFactoryMethod != null) {
                        resolved = true;
                        autowireNecessary = mbd.constructorArgumentsResolved;
                    }
                }
            }
            //如果解析过 判断是根据有参还是无参构造方式实例化对象
            if (resolved) {
                if (autowireNecessary) {
                    //有参构造函数
                    return autowireConstructor(beanName, mbd, null, null);
                }
                else {
                    //无参构造函数
                    return instantiateBean(beanName, mbd);
                }
            }
            //未解析过
            // Candidate constructors for autowiring?
            Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
            if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
                    mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
                //有参构造函数
                return autowireConstructor(beanName, mbd, ctors, args);
            }
    
            // <26>无参构造函数
            return instantiateBean(beanName, mbd);
        }

    <26>

    org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#instantiateBean

    protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
            try {
                Object beanInstance;
                if (System.getSecurityManager() != null) {
                    beanInstance = AccessController.doPrivileged(
                            (PrivilegedAction<Object>) () -> getInstantiationStrategy().instantiate(mbd, beanName, this),
                            getAccessControlContext());
                }
                else {
                    //创建bean
                    beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this);
                }
                //通过BeanWrapper包装返回
                BeanWrapper bw = new BeanWrapperImpl(beanInstance);
                initBeanWrapper(bw);
                return bw;
            }
            catch (Throwable ex) {
                throw new BeanCreationException(
                        mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
            }
        }

    <27>

    返回上一级

    org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean

    protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
            if (bw == null) {
                if (mbd.hasPropertyValues()) {
                    //如果有BeanWrapper 但是有又有属性值则抛异常
                    throw new BeanCreationException(
                            mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
                }
                else {
                    // Skip property population phase for null instance.
                    return;
                }
            }
    
            // 到这步的时候,bean 实例化完成(通过工厂方法或构造方法),但是还没开始属性设值,
            // InstantiationAwareBeanPostProcessor 的实现类可以在这里对 bean 进行状态修改,
            //比如dubbo 服务消费者 通过代理实现@Refrence注入属性值
            if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
                for (BeanPostProcessor bp : getBeanPostProcessors()) {
                    if (bp instanceof InstantiationAwareBeanPostProcessor) {
                        InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                        // 如果返回 false,代表不需要进行后续的属性设值,也不需要再经过其他的 BeanPostProcessor 的处理
                        if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                            return;
                        }
                    }
                }
            }
    
            //静态注入 里面默认会存储注入关系
            PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
    
            int resolvedAutowireMode = mbd.getResolvedAutowireMode();
            //=============================autowireMode注入方式 不用打任何注解 自动注入 详细可搜索用法==========================
            if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
                MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
                //<28> 根据属性名称在容器查找bean
                if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
    autowireByName(beanName, mbd, bw, newPvs); }
    //<29>根据属性类型在容器查找bean if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) { autowireByType(beanName, mbd, bw, newPvs); } pvs = newPvs; } //容器是否有InstantiationAwareBeanPostProcessor boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors(); boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE); if (hasInstAwareBpps || needsDepCheck) { if (pvs == null) { pvs = mbd.getPropertyValues(); } PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching); if (hasInstAwareBpps) { for (BeanPostProcessor bp : getBeanPostProcessors()) { if (bp instanceof InstantiationAwareBeanPostProcessor) { // 这里有个非常有用的 BeanPostProcessor 进到这里: AutowiredAnnotationBeanPostProcessor //// 对采用 @Autowired、@Value 注解的依赖进行设值 InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp; pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName); if (pvs == null) { return; } } } } if (needsDepCheck) { checkDependencies(beanName, mbd, filteredPds, pvs); } } if (pvs != null) { // 设置 bean 实例的属性值 applyPropertyValues(beanName, mbd, bw, pvs); } }

    <28>

    返回上一级

    org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#autowireByName

        protected void autowireByName(
                String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
           // 获取可set的属性,且这个属性不是简单的属性,比如基本类型、包装类这些
            String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
            for (String propertyName : propertyNames) {
                //// 是否有这个bean
                if (containsBean(propertyName)) {
                    // 有的话获取
                    Object bean = getBean(propertyName);
                    // 添加到pvs
                    pvs.add(propertyName, bean);
                    //  // 注册依赖关系
                    registerDependentBean(propertyName, beanName);
                    if (logger.isDebugEnabled()) {
                        logger.debug("Added autowiring by name from bean name '" + beanName +
                                "' via property '" + propertyName + "' to bean named '" + propertyName + "'");
                    }
                }
                else {
                    if (logger.isTraceEnabled()) {
                        logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
                                "' by name: no matching bean found");
                    }
                }
            }
        }

    <29>

    返回上一级

    org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#autowireByType

        protected void autowireByType(
                String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
    
            // 类型转换器获取
            TypeConverter converter = getCustomTypeConverter();
            if (converter == null) {
                converter = bw;
            }
    
            //==================== 获取可set的属性,且这个属性不是简单的属性,比如基本类型、包装类这些===================
            Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
            String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
            for (String propertyName : propertyNames) {
                try {
                    PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
                    // 如果是Object,就不管了
                    if (Object.class != pd.getPropertyType()) {
                         // 获取写参数
                        MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
                        // Do not allow eager init for type matching in case of a prioritized post-processor.
                        boolean eager = !(bw.getWrappedInstance() instanceof PriorityOrdered);
                        DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
                        Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
                        if (autowiredArgument != null) {
                            pvs.add(propertyName, autowiredArgument);
                        }
                        for (String autowiredBeanName : autowiredBeanNames) {
                            // 注册依赖
                            registerDependentBean(autowiredBeanName, beanName);
                            if (logger.isDebugEnabled()) {
                                logger.debug("Autowiring by type from bean name '" + beanName + "' via property '" +
                                        propertyName + "' to bean named '" + autowiredBeanName + "'");
                            }
                        }
                        autowiredBeanNames.clear();
                    }
                }
                catch (BeansException ex) {
                    throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
                }
            }
        }

    <30>

    返回上一级

    org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean

    protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                    invokeAwareMethods(beanName, bean);
                    return null;
                }, getAccessControlContext());
            }
            else {
                //<31> 如果 bean 实现了 BeanNameAware、BeanClassLoaderAware 或 BeanFactoryAware 接口,回调
                invokeAwareMethods(beanName, bean);
            }
    
            Object wrappedBean = bean;
            if (mbd == null || !mbd.isSynthetic()) {
                //<32> BeanPostProcessor 的 postProcessBeforeInitialization 回调
                wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
            }
    
            try {
                ////<处理 bean 中定义的 init-method,
                // <33>     // 或者如果 bean 实现了 InitializingBean 接口,调用 afterPropertiesSet() 方法
                invokeInitMethods(beanName, wrappedBean, mbd);
            }
            catch (Throwable ex) {
                throw new BeanCreationException(
                        (mbd != null ? mbd.getResourceDescription() : null),
                        beanName, "Invocation of init method failed", ex);
            }
            if (mbd == null || !mbd.isSynthetic()) {
                //<34>BeanPostProcessor 的 postProcessAfterInitialization 回调
                wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
            }
    
            return wrappedBean;
        }

    <31>

    org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#invokeAwareMethods

        private void invokeAwareMethods(String beanName, Object bean) {
            /**
             * 判断是否实现了Aware接口
             * 依次判断是否实现了 BeanNameAware BeanClassLoaderAware BeanFactoryAware并调用对应的方法
             */
            if (bean instanceof Aware) {
                if (bean instanceof BeanNameAware) {
                    ((BeanNameAware) bean).setBeanName(beanName);
                }
                if (bean instanceof BeanClassLoaderAware) {
                    ClassLoader bcl = getBeanClassLoader();
                    if (bcl != null) {
                        ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
                    }
                }
                if (bean instanceof BeanFactoryAware) {
                    ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
                }
            }
        }

    <32>

    org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization

        public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
                throws BeansException {
    
            Object result = existingBean;
            for (BeanPostProcessor processor : getBeanPostProcessors()) {
                Object current = processor.postProcessBeforeInitialization(result, beanName);
                if (current == null) {
                    return result;
                }
                result = current;
            }
            return result;
        }

    <33>

    org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#invokeInitMethods

    protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
                throws Throwable {
    
    
            boolean isInitializingBean = (bean instanceof InitializingBean);
            //判断是否实现了InitializingBean接口和是否实现了initMethod方法
            if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
                }
                if (System.getSecurityManager() != null) {
                    try {
                        AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
                            ((InitializingBean) bean).afterPropertiesSet();
                            return null;
                        }, getAccessControlContext());
                    }
                    catch (PrivilegedActionException pae) {
                        throw pae.getException();
                    }
                }
                else {
                    //执行调用
                    ((InitializingBean) bean).afterPropertiesSet();
                }
            }
          //如果配置了initMethod 就执行initMethod方法 这里只是取到了方法名,显然是要通过反射调用了
            if (mbd != null && bean.getClass() != NullBean.class) {
                String initMethodName = mbd.getInitMethodName();
                if (StringUtils.hasLength(initMethodName) &&
                        !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
                        !mbd.isExternallyManagedInitMethod(initMethodName)) {
                    invokeCustomInitMethod(beanName, bean, mbd);
                }
            }
        }

    <34>

    org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization

    @Override
        public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
                throws BeansException {
    
            Object result = existingBean;
            //获得实现了BeanPostProcessor的累的对象遍历调用postProcessAfterInitialization
            for (BeanPostProcessor processor : getBeanPostProcessors()) {
                Object current = processor.postProcessAfterInitialization(result, beanName);
                if (current == null) {
                    return result;
                }
                result = current;
            }
            return result;
        }
  • 相关阅读:
    Algebra, Topology, Differential Calculus, and Optimization Theory For Computer Science and Machine Learning 第4章 读书笔记(待更新)
    Algebra, Topology, Differential Calculus, and Optimization Theory For Computer Science and Machine Learning 第3章 读书笔记(待更新)
    Algebra, Topology, Differential Calculus, and Optimization Theory For Computer Science and Machine Learning 第1,2章 读书笔记(待更新)
    Tkinter的Message组件
    Git 实操/配置/实践
    mysq5.7.32-win安装步骤
    行为型模式之模板方法
    结构型模式之组合模式
    结构型模式之享元模式
    结构型模式之外观模式
  • 原文地址:https://www.cnblogs.com/LQBlog/p/13954302.html
Copyright © 2011-2022 走看看