• Spring IOC 源码分析


              刚学习Spring的时候,印象最深的就是 DispatcherServlet,所谓的中央调度器,我也尝试从这个万能胶这里找到入口

    configureAndRefreshWebApplicationContext()方法,应该就是IOC容器初始化的真正入口  

        protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac) {
            if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
                if (this.contextId != null) {
                    wac.setId(this.contextId);
                }
                else {
                    wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +
                            ObjectUtils.getDisplayString(getServletContext().getContextPath()) + '/' + getServletName());
                }
            }
            wac.setServletContext(getServletContext());
            wac.setServletConfig(getServletConfig());
            wac.setNamespace(getNamespace());
            wac.addApplicationListener(new SourceFilteringListener(wac, new ContextRefreshListener()));
            ConfigurableEnvironment env = wac.getEnvironment();
            if (env instanceof ConfigurableWebEnvironment) {
                ((ConfigurableWebEnvironment) env).initPropertySources(getServletContext(), getServletConfig());
            }
            postProcessWebApplicationContext(wac);
            applyInitializers(wac);
    //核心代码 wac.refresh(); }

     

    上面代码中的wac(ConfigurableWebApplicationContext),执行了它的父类AbstractApplicationContext中的refresh的模板方法

        @Override
        public void refresh() throws BeansException, IllegalStateException {
            synchronized (this.startupShutdownMonitor) {//调用容器准备刷新的方法,获取容器的当时时间,同时给容器设置同步标识
                prepareRefresh();//子类的refreshBeanFactory()方法启动
                ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();//为BeanFactory配置容器特性,例如类加载器、事件处理器等
                prepareBeanFactory(beanFactory);
                try {//注册BeanFactory的事件
                    postProcessBeanFactory(beanFactory);//调用所有注册的BeanFactoryPostProcessor
                    invokeBeanFactoryPostProcessors(beanFactory);//注册Bean处理器,用于监听容器触发的事件
                    registerBeanPostProcessors(beanFactory);//初始化信息源,和国际化相关.
                    initMessageSource();//初始化容器事件传播器.
                    initApplicationEventMulticaster();//调用子类的某些特殊Bean初始化方法
                    onRefresh();//为事件传播器注册事件监听器.
                    registerListeners();//初始化所有剩余的单例Bean
                    finishBeanFactoryInitialization(beanFactory);//初始化容器的生命周期事件处理器,并发布容器的生命周期事件
                    finishRefresh();
                }
                catch (BeansException ex) {
                    if (logger.isWarnEnabled()) {
                        logger.warn("Exception encountered during context initialization - " +
                                "cancelling refresh attempt: " + ex);
                    }//销毁已创建的Bean
                    destroyBeans();//取消refresh操作,重置容器的同步标识.
                    cancelRefresh(ex);
                    throw ex;
                }
                finally {
                    resetCommonCaches();
                }
            }
        }

            手写测试用例(xml配置的bean实例)

     

          ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("xxx.xml");
          //获取bean
          ctx .getBean("xxx");
    
    

     

           通过跟踪代码和debug的方式,找到了初始化流程

           

    ClassPathXmlApplicationContext 的构造方法,最终走了如下构造方法

        public ClassPathXmlApplicationContext(
                String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
                throws BeansException {
    
            super(parent);
            setConfigLocations(configLocations);
            if (refresh) {
    //和上面的分析一样调用的是父类AbstractApplicationContext的模板方法 refresh(); } }
     refresh方法中的obtainFreshBeanFactory
        protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
            //委派模式,父类定义了抽象的refreshBeanFactory()方法,具体实现调用子类容器的refreshBeanFactory()方法,子类refresh BeanFactory
            refreshBeanFactory();
            ConfigurableListableBeanFactory beanFactory = getBeanFactory();
            if (logger.isDebugEnabled()) {
                logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
            }
            return beanFactory;
        }

    到AbstractRefreshableApplicationContext类的refreshBeanFactory()方法

        @Override
        protected final void refreshBeanFactory() throws BeansException {
            //如果已经有容器,销毁容器中的bean,关闭容器
            if (hasBeanFactory()) {
                destroyBeans();
                closeBeanFactory();
            }
            try {
                //创建IOC容器BeanFactory
                DefaultListableBeanFactory beanFactory = createBeanFactory();
                beanFactory.setSerializationId(getId());
                //对IOC容器进行定制化,如设置启动参数,开启注解的自动装配等
                customizeBeanFactory(beanFactory);
                //调用载入Bean定义的方法,子类实现
                loadBeanDefinitions(beanFactory);
                synchronized (this.beanFactoryMonitor) {
                    this.beanFactory = beanFactory;
                }
            }
            catch (IOException ex) {
                throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
            }
        }
    loadBeanDefinitions有四个实现

       明显到  AbstractXmlApplicationContext 的 loadBeanDefinitions()方法

        @Override
        protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {//创建XmlBeanDefinitionReader,即创建Bean读取器,并通过回调设置到容器中去,容器使用该读取器读取Bean定义资源
            XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
            //set参数 环境,资源加载器,解析器        
            beanDefinitionReader.setEnvironment(this.getEnvironment());
            beanDefinitionReader.setResourceLoader(this);
            beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
    //当Bean读取器读取Bean定义的Xml资源文件时,启用Xml的校验机制
            initBeanDefinitionReader(beanDefinitionReader);
            //Bean读取器真正实现加载的方法
            loadBeanDefinitions(beanDefinitionReader);
        }

    loadBeanDefinitions的重载方法

        //Xml Bean读取器加载Bean定义资源
        protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
            //获取Bean定义资源的定位
            Resource[] configResources = getConfigResources();
            if (configResources != null) {
                //Xml Bean读取器调用其父类AbstractBeanDefinitionReader读取定位
                reader.loadBeanDefinitions(configResources);
            }
            //如果子类中获取的Bean定义资源定位为空,则获取FileSystemXmlApplicationContext构造方法中setConfigLocations方法设置的资源
            String[] configLocations = getConfigLocations();
            if (configLocations != null) {
                //Xml Bean读取器调用其父类AbstractBeanDefinitionReader读取定位
                reader.loadBeanDefinitions(configLocations);
            }
        }

    最终到父类AbstractBeanDefinitionReader的loadBeanDefinitions 重载方法

        public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
            //获取在IoC容器初始化过程中设置的资源加载器
            ResourceLoader resourceLoader = getResourceLoader();
            if (resourceLoader == null) {
                throw new BeanDefinitionStoreException(
                        "Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
            }
    
            if (resourceLoader instanceof ResourcePatternResolver) {
                try {
                    //将指定位置的Bean定义资源文件解析为Spring IOC容器封装的资源
                    //加载多个指定位置的Bean定义资源文件
                    Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
                    //委派调用其子类XmlBeanDefinitionReader的方法,实现加载功能
                    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 {
                Resource resource = resourceLoader.getResource(location);
                //委派调用其子类XmlBeanDefinitionReader的方法,实现加载功能
                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的loadBeanDefinitions()方法

        //这里是载入XML形式Bean定义资源文件方法
        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.getResource());
            }
    
            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的IO流
                InputStream inputStream = encodedResource.getResource().getInputStream();
                try {
                    //从InputStream中得到XML的解析源
                    InputSource inputSource = new InputSource(inputStream);
                    if (encodedResource.getEncoding() != null) {
                        inputSource.setEncoding(encodedResource.getEncoding());
                    }
                    //真实的读取过程
                    return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
                }
                finally {
                    //关闭从Resource中得到的IO流
                    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();
                }
            }
        }
    doLoadBeanDefinitions方法
        protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
                throws BeanDefinitionStoreException {
            try {
                //将XML文件转换为DOM对象,解析过程由documentLoader实现
                Document doc = doLoadDocument(inputSource, resource);
                //这里是启动对Bean定义解析的详细过程,该解析过程会用到Spring的Bean配置规则
                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);
            }
        }
    registerBeanDefinitions方法
        public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
            //得到BeanDefinitionDocumentReader来对xml格式的BeanDefinition解析
            BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
            //获得容器中注册的Bean数量
            int countBefore = getRegistry().getBeanDefinitionCount();//实现类DefaultBeanDefinitionDocumentReader完成
            documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
            //统计解析的Bean数量
            return getRegistry().getBeanDefinitionCount() - countBefore;
        }
    子类DefaultBeanDefinitionDocumentReader的registerBeanDefinitions方法
        @Override
        public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
            this.readerContext = readerContext;
            logger.debug("Loading bean definitions");
            //获得Document的根元素
            Element root = doc.getDocumentElement();
    //真实注册 doRegisterBeanDefinitions(root); }
    doRegisterBeanDefinitions方法
        protected void doRegisterBeanDefinitions(Element root) {
            BeanDefinitionParserDelegate parent = this.delegate;
            this.delegate = createDelegate(getReaderContext(), root, parent);
    
            if (this.delegate.isDefaultNamespace(root)) {
                String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
                if (StringUtils.hasText(profileSpec)) {
                    String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
                            profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
                    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;
                    }
                }
            }
    
            //准备解析xml
            preProcessXml(root);
            //从Document的根元素开始进行Bean定义的Document对象
            parseBeanDefinitions(root, this.delegate);
            //在解析Bean定义之后,进行自定义的解析,增加解析过程的可扩展性
            postProcessXml(root);
    
            this.delegate = parent;
        }
    parseBeanDefinitions方法
        //使用Spring的Bean规则从Document的根元素开始进行Bean定义的Document对象
        protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
            //判断默认的XML命名空间
            if (delegate.isDefaultNamespace(root)) {
                //获取Bean定义的Document对象根元素的所有子节点
                NodeList nl = root.getChildNodes();
                for (int i = 0; i < nl.getLength(); i++) {
                    Node node = nl.item(i);
                    //获得Document节点是XML元素节点
                    if (node instanceof Element) {
                        Element ele = (Element) node;
                        if (delegate.isDefaultNamespace(ele)) {
                            //使用Spring的Bean规则解析元素节点
                            parseDefaultElement(ele, delegate);
                        }
                        else {
                            //没有使用Spring默认的XML命名空间,则使用用户自定义的解//析规则解析元素节点
                            delegate.parseCustomElement(ele);
                        }
                    }
                }
            }
            else {
                delegate.parseCustomElement(root);
            }
        }
    parseDefaultElement方法
        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>元素,
            //按照Spring的Bean规则解析元素
            else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
                processBeanDefinition(ele, delegate);
            }
            else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
                // recurse
                doRegisterBeanDefinitions(ele);
            }
        }

     只看普通bean的解析processBeanDefinition方法

        protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
            BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
            // BeanDefinitionHolder是对BeanDefinition的封装,即Bean定义的封装类
            if (bdHolder != null) {
                bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
                try {//向Spring IOC容器注册解析得到的Bean定义,这是Bean定义向IOC容器注册的入口
                    BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
                }
                catch (BeanDefinitionStoreException ex) {
                    getReaderContext().error("Failed to register bean definition with name '" +
                            bdHolder.getBeanName() + "'", ele, ex);
                }//在完成向Spring IOC容器注册解析得到的Bean定义之后,发送注册事件
                getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
            }
        }
    BeanDefinitionReaderUtils.registerBeanDefinition方法
        public static void registerBeanDefinition(
                BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
                throws BeanDefinitionStoreException {
    //获取解析的BeanDefinition的名称
            String beanName = definitionHolder.getBeanName();
            //向IOC容器注册BeanDefinition
            registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
    //别名处理
            String[] aliases = definitionHolder.getAliases();
            if (aliases != null) {
                for (String alias : aliases) {
                    registry.registerAlias(beanName, alias);
                }
            }
        }

    到DefaultListableBeanFactory类的registerBeanDefinition方法

        //向IOC容器注册解析出来的BeanDefiniton
        @Override
        public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
                throws BeanDefinitionStoreException {
            Assert.hasText(beanName, "Bean name must not be empty");
            Assert.notNull(beanDefinition, "BeanDefinition must not be null");
            //校验解析
            if (beanDefinition instanceof AbstractBeanDefinition) {
                try {
                    ((AbstractBeanDefinition) beanDefinition).validate();
                }
                catch (BeanDefinitionValidationException ex) {
                    throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                            "Validation of bean definition failed", ex);
                }
            }
            BeanDefinition oldBeanDefinition;
            oldBeanDefinition = this.beanDefinitionMap.get(beanName);
            if (oldBeanDefinition != null) {
                if (!isAllowBeanDefinitionOverriding()) {
                    throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                            "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
                            "': There is already [" + oldBeanDefinition + "] bound.");
                }
                else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
                    if (this.logger.isWarnEnabled()) {
                        this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +
                                "' with a framework-generated bean definition: replacing [" +
                                oldBeanDefinition + "] with [" + beanDefinition + "]");
                    }
                }
                else if (!beanDefinition.equals(oldBeanDefinition)) {
                    if (this.logger.isInfoEnabled()) {
                        this.logger.info("Overriding bean definition for bean '" + beanName +
                                "' with a different definition: replacing [" + oldBeanDefinition +
                                "] with [" + beanDefinition + "]");
                    }
                }
                else {
                    if (this.logger.isDebugEnabled()) {
                        this.logger.debug("Overriding bean definition for bean '" + beanName +
                                "' with an equivalent definition: replacing [" + oldBeanDefinition +
                                "] with [" + beanDefinition + "]");
                    }
                }
                this.beanDefinitionMap.put(beanName, beanDefinition);
            }
            else {
                if (hasBeanCreationStarted()) {//同步
                    synchronized (this.beanDefinitionMap) {
    //注册
    this.beanDefinitionMap.put(beanName, beanDefinition); List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1); updatedDefinitions.addAll(this.beanDefinitionNames); updatedDefinitions.add(beanName); this.beanDefinitionNames = updatedDefinitions; if (this.manualSingletonNames.contains(beanName)) { Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames); updatedSingletons.remove(beanName); this.manualSingletonNames = updatedSingletons; } } } else { this.beanDefinitionMap.put(beanName, beanDefinition); this.beanDefinitionNames.add(beanName); this.manualSingletonNames.remove(beanName); } this.frozenBeanDefinitionNames = null; } //检查是否有同名的BeanDefinition已经在IOC容器中注册 if (oldBeanDefinition != null || containsSingleton(beanName)) { //重置所有已经注册过的BeanDefinition的缓存 resetBeanDefinition(beanName); } }

    到这个AbstractApplicationContext类的obtainFreshBeanFactory方法 终于结束了。

    继续看AbstractApplicationContext中refresh方法中的prepareBeanFactory方法:配置工厂的标准上下文特征,例如上下文的ClassLoader和后处理器

        protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
            // Tell the internal bean factory to use the context's class loader etc.
            beanFactory.setBeanClassLoader(getClassLoader());
            beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
            beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
    
            // Configure the bean factory with context callbacks.
            beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
            beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
            beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
            beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
            beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
            beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
            beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
    
            // BeanFactory interface not registered as resolvable type in a plain factory.
            // MessageSource registered (and found for autowiring) as a bean.
            beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
            beanFactory.registerResolvableDependency(ResourceLoader.class, this);
            beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
            beanFactory.registerResolvableDependency(ApplicationContext.class, this);
    
            // Register early post-processor for detecting inner beans as ApplicationListeners.
            beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
    
            // Detect a LoadTimeWeaver and prepare for weaving, if found.
            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()));
            }
    
            // Register default environment beans.
            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().getSystemProperties());
            }
            if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
                beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
            }
        }
    refresh方法中的postProcessBeanFactory()
        protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
            beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext, this.servletConfig));
            beanFactory.ignoreDependencyInterface(ServletContextAware.class);
            beanFactory.ignoreDependencyInterface(ServletConfigAware.class);
    
            WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
            WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, this.servletConfig);
        }
    refresh方法中的invokeBeanFactoryPostProcessors()
        protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
            PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
    
            // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
            // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
            if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
                beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
                beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
            }
        }
    refresh方法中的registerBeanPostProcessors()
        public static void registerBeanPostProcessors(
                ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
    
            String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
    
            // Register BeanPostProcessorChecker that logs an info message when
            // a bean is created during BeanPostProcessor instantiation, i.e. when
            // a bean is not eligible for getting processed by all BeanPostProcessors.
            int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
            beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
    
            // Separate between BeanPostProcessors that implement PriorityOrdered,
            // Ordered, and the rest.
            List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
            List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
            List<String> orderedPostProcessorNames = new ArrayList<>();
            List<String> nonOrderedPostProcessorNames = new ArrayList<>();
            for (String ppName : postProcessorNames) {
                if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                    BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
                    priorityOrderedPostProcessors.add(pp);
                    if (pp instanceof MergedBeanDefinitionPostProcessor) {
                        internalPostProcessors.add(pp);
                    }
                }
                else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
                    orderedPostProcessorNames.add(ppName);
                }
                else {
                    nonOrderedPostProcessorNames.add(ppName);
                }
            }
    
            // First, register the BeanPostProcessors that implement PriorityOrdered.
            sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
            registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
    
            // Next, register the BeanPostProcessors that implement Ordered.
            List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
            for (String ppName : orderedPostProcessorNames) {
                BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
                orderedPostProcessors.add(pp);
                if (pp instanceof MergedBeanDefinitionPostProcessor) {
                    internalPostProcessors.add(pp);
                }
            }
            sortPostProcessors(orderedPostProcessors, beanFactory);
            registerBeanPostProcessors(beanFactory, orderedPostProcessors);
    
            // Now, register all regular BeanPostProcessors.
            List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
            for (String ppName : nonOrderedPostProcessorNames) {
                BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
                nonOrderedPostProcessors.add(pp);
                if (pp instanceof MergedBeanDefinitionPostProcessor) {
                    internalPostProcessors.add(pp);
                }
            }
            registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
    
            // Finally, re-register all internal BeanPostProcessors.
            sortPostProcessors(internalPostProcessors, beanFactory);
            registerBeanPostProcessors(beanFactory, internalPostProcessors);
    
            // Re-register post-processor for detecting inner beans as ApplicationListeners,
            // moving it to the end of the processor chain (for picking up proxies etc).
            beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
        }
    refresh方法中的initMessageSource和initApplicationEventMulticaster  这里就不赘述了
    refresh方法中的onRefresh是调用特殊bean的初始化
    refresh方法中的registerListeners是注册监听

    下面看下refresh方法中的finishBeanFactoryInitialization方法
        protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {//转换服务
            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));
            }
            if (!beanFactory.hasEmbeddedValueResolver()) {
                beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
            }
            String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
            for (String weaverAwareName : weaverAwareNames) {
                getBean(weaverAwareName);
            }
            beanFactory.setTempClassLoader(null);
    //冻结Configuration,防止被修改
            beanFactory.freezeConfiguration();
    
            // Instantiate all remaining (non-lazy-init) singletons.
            //对配置了lazy-init属性的单态模式Bean进行预实例化处理
            beanFactory.preInstantiateSingletons();
        }
    到 DefaultListableBeanFactory的preInstantiateSingletons方法
    public void preInstantiateSingletons() throws BeansException {
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Pre-instantiating singletons in " + this);
            }
            List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
    
            for (String beanName : beanNames) {
                //获取bean的RootBeanDefinition
                RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
                //Bean不是抽象的,单态模式,不是懒加载
                if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                    //如果指定名称的bean是创建容器的Bean
                    if (isFactoryBean(beanName)) {
                        //FACTORY_BEAN_PREFIX=”&”,当Bean名称前面加”&”符号时,获取的是产生容器对象本身,而不是容器产生的Bean.
                        final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
                        //标识是否需要预实例化
                        boolean isEagerInit;
                        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) {
                            //触发容器对Bean实例化和依赖注入过程
                            getBean(beanName);
                        }
                    }
                    else {
    //触发容器对Bean实例化和依赖注入的过程 getBean(beanName); } } }
    for (String beanName : beanNames) { Object singletonInstance = getSingleton(beanName); if (singletonInstance instanceof SmartInitializingSingleton) { final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance; if (System.getSecurityManager() != null) { AccessController.doPrivileged((PrivilegedAction<Object>) () -> { smartSingleton.afterSingletonsInstantiated(); return null; }, getAccessControlContext()); } else { smartSingleton.afterSingletonsInstantiated(); } } } }
    AbstractBeanFactory的getBean方法,其实调用的是doGetBean方法
        protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
                @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
            //处理bean名称
            final String beanName = transformedBeanName(name);
            Object bean;
    //对于单例模式的Bean整个IOC容器中只创建一次,不需要重复创建
            Object sharedInstance = getSingleton(beanName);
            //IOC容器创建单例模式Bean实例对象
            if (sharedInstance != null && args == null) {
                if (logger.isDebugEnabled()) {
                    //如果指定名称的Bean在容器中已有单例模式的Bean被创建,直接返回
                    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的实例对象,完成FactoryBean的相关处理
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
            }
    
            else {//缓存中已经有已经创建的原型模式Bean,循环引用问题,直接抛出异常
                if (isPrototypeCurrentlyInCreation(beanName)) {
                    throw new BeanCurrentlyInCreationException(beanName);
                }//获得parentBeanFactory
                BeanFactory parentBeanFactory = getParentBeanFactory();
                //当前容器的父级容器存在,且当前容器中不存在指定名称的Bean
                if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {//原始名称
                    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 {//委派父级容器根据指定名称和类型查找
                        return parentBeanFactory.getBean(nameToLookup, requiredType);
                    }
                }
    
                if (!typeCheckOnly) {
                    markBeanAsCreated(beanName);
                }
    
                try {//解决Bean继承时子类合并父类公共属性问题
                    final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                    checkMergedBeanDefinition(mbd, beanName, args);//获取当前Bean所有依赖Bean的名称
                    String[] dependsOn = mbd.getDependsOn();
                    //如果当前Bean有依赖Bean
                    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 + "'");
                            }
                            //递归调用getBean方法,获取当前Bean的依赖Bean
                            registerDependentBean(dep, beanName);
                            //把被依赖Bean注册给当前依赖的Bean
                            getBean(dep);
                        }
                    }
    //创建单例模式Bean的实例对象
                    if (mbd.isSingleton()) {
                        //这里使用了一个匿名内部类,创建Bean实例对象,并且注册给所依赖的对象
                        sharedInstance = getSingleton(beanName, () -> {
                            try {
                                //创建一个指定Bean实例对象,如果有父级继承,则合并子类和父类的定义
                                return createBean(beanName, mbd, args);
                            }
                            catch (BeansException ex) {//显式地从容器单例模式Bean缓存中清除实例对象
                                destroySingleton(beanName);
                                throw ex;
                            }
                        });
                        //获取给定Bean的实例对象
                        bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                    }
    
                    //IOC容器创建原型模式Bean实例对象
                    else if (mbd.isPrototype()) {
                        Object prototypeInstance = null;
                        try {
                            //回调beforePrototypeCreation方法,默认的功能是注册当前创建的原型对象
                            beforePrototypeCreation(beanName);
                            //创建指定Bean对象实例
                            prototypeInstance = createBean(beanName, mbd, args);
                        }
                        finally {
                            //回调afterPrototypeCreation方法,默认的功能告诉IOC容器指定Bean的原型对象不再创建
                            afterPrototypeCreation(beanName);
                        }
                        //获取给定Bean的实例对象
                        bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                    }
    //其他bean,如:request、session、application等生命周期
                    else {
                        String scopeName = mbd.getScope();
                        final Scope scope = this.scopes.get(scopeName);
                        //Bean定义资源中没有配置生命周期范围,则Bean定义不合法
                        if (scope == null) {
                            throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
                        }
                        try {
                            //这里又使用了一个匿名内部类,获取一个指定生命周期范围的实例
                            Object scopedInstance = scope.get(beanName, () -> {
                                beforePrototypeCreation(beanName);
                                try {
                                    return createBean(beanName, mbd, args);
                                }
                                finally {
                                    afterPrototypeCreation(beanName);
                                }
                            });
                            //获取给定Bean的实例对象
                            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;
                }
            }
    
            // Check if required type matches the type of the actual bean instance.
            //对创建的Bean实例对象进行类型检查
            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类的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;
            Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
            if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
                mbdToUse = new RootBeanDefinition(mbd);
                mbdToUse.setBeanClass(resolvedClass);
            }//准备Bean中的方法覆盖
            try {
                mbdToUse.prepareMethodOverrides();
            } catch (BeanDefinitionValidationException ex) {
                throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                        beanName, "Validation of method overrides failed", ex);
            }
            try {//如果Bean配置了初始化前和初始化后的处理器,则试图返回一个需要创建Bean的代理对象
                Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
                if (bean != null) {
                    return bean;
                }
            } catch (Throwable ex) {
                throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
                        "BeanPostProcessor before instantiation of bean failed", ex);
            }
    
            try {
                //创建Bean的入口
                Object beanInstance = doCreateBean(beanName, mbdToUse, args);
                if (logger.isDebugEnabled()) {
                    logger.debug("Finished creating instance of bean '" + beanName + "'");
                }
                return beanInstance;
            } catch (BeanCreationException ex) {
                throw ex;
            } catch (ImplicitlyAppearedSingletonException ex) {
                throw ex;
            } catch (Throwable ex) {
                throw new BeanCreationException(
                        mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
            }
        }

    doCreateBean方法

        protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
                throws BeanCreationException {
    //Bean对象将被包装成Wrapper
            BeanWrapper instanceWrapper = null;
            if (mbd.isSingleton()) {
                instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
            }
            if (instanceWrapper == null) {
                instanceWrapper = createBeanInstance(beanName, mbd, args);
            }
            final Object bean = instanceWrapper.getWrappedInstance();
            //获取实例化对象的类型
            Class<?> beanType = instanceWrapper.getWrappedClass();
            if (beanType != NullBean.class) {
                mbd.resolvedTargetType = beanType;
            }
    //调用PostProcessor后置处理器
            synchronized (mbd.postProcessingLock) {
                if (!mbd.postProcessed) {
                    try {
                        applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                    } catch (Throwable ex) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                "Post-processing of merged bean definition failed", ex);
                    }
                    mbd.postProcessed = true;
                }
            }//向容器中缓存单例模式的Bean对象,以防循环引用
            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));
            }
            //暴露的bean
            Object exposedObject = bean;
            try {
                //属性注入
                populateBean(beanName, mbd, instanceWrapper);
                //初始化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) {
                //获取指定名称的已注册的单例模式Bean对象
                Object earlySingletonReference = getSingleton(beanName, false);
                if (earlySingletonReference != null) {
                    //根据名称获取的已注册的Bean和正在实例化的Bean是同一个
                    if (exposedObject == bean) {
                        //当前实例化的Bean初始化完成
                        exposedObject = earlySingletonReference;
                    }
                    //当前Bean依赖其他Bean,并且当发生循环引用时不允许新创建实例对象
                    else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                        String[] dependentBeans = getDependentBeans(beanName);
                        Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
                        //获取当前Bean所依赖的其他Bean
                        for (String dependentBean : dependentBeans) {
                            //对依赖Bean进行类型检查
                            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 " +
                                            "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
                        }
                    }
                }
            }
    //注册完成依赖注入的Bean
            try {
                registerDisposableBeanIfNecessary(beanName, bean, mbd);
            } catch (BeanDefinitionValidationException ex) {
                throw new BeanCreationException(
                        mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
            }
    
            return exposedObject;
        }
    initializeBean方法
        protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
            //JDK的安全机制验证权限
            if (System.getSecurityManager() != null) {
                //实现PrivilegedAction接口的匿名内部类
                AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                    invokeAwareMethods(beanName, bean);
                    return null;
                }, getAccessControlContext());
            } else {
                //为Bean实例对象包装相关属性,如名称,类加载器,所属容器等信息
                invokeAwareMethods(beanName, bean);
            }
    
            Object wrappedBean = bean;
            //对BeanPostProcessor后置处理器的postProcessBeforeInitialization
            //回调方法的调用,为Bean实例初始化前做一些处理
            if (mbd == null || !mbd.isSynthetic()) {
                wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
            }
            //调用Bean实例对象初始化的方法,这个初始化方法是在Spring Bean定义配置
            //文件中通过init-method属性指定的
            try {
                invokeInitMethods(beanName, wrappedBean, mbd);
            } catch (Throwable ex) {
                throw new BeanCreationException(
                        (mbd != null ? mbd.getResourceDescription() : null),
                        beanName, "Invocation of init method failed", ex);
            }
            //对BeanPostProcessor后置处理器的postProcessAfterInitialization
            if (mbd == null || !mbd.isSynthetic()) {
                wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
            }
            return wrappedBean;
        }

           整个IOC流程 基本结束

    
    
  • 相关阅读:
    [Redis]主从同步可能遇到的坑
    Redis_如何保证原子操作
    .Net Core 5.0 Json序列化和反序列化 | System.Text.Json 的json序列化和反序列化
    JavaScript Error对象整理_JavaScript 异常处理整理
    Canvas 事件绑定|Canvas事件处理
    Css3 常用布局方式 一行两列&高度自适应&垂直方向居中
    Css3 实现锯齿效果整理
    Css3 currentColor 变量使用
    Css3 实现任意角扇形|Css3实现六角扇形
    实现 Application_Start 和 Application_End
  • 原文地址:https://www.cnblogs.com/dyg0826/p/10716040.html
Copyright © 2020-2023  润新知