资讯专栏INFORMATION COLUMN

上云采购季！| 2核2G4M爆款云服务器低至59元/年，更有多台、长期优惠，快来选购！

立即前往
首页/文章专栏/Spring IOC源码跟踪记录-基于XML

Spring IOC源码跟踪记录-基于XML

Big_fat_cat / 1722人阅读

摘要：在有了之后，类与类之间的耦合关系是这样的。为刷新做好准备。初始化上下文消息为这个上下文初始化事件多播器。

what is IOC？

IOC（Inversion of Control ）控制反转，是Spring框架最重要的一个特性，提供了一个装载类的容器来为类之间进行解耦，并提供了一系列的扩展接口，使得开发者可以在bean的生命周期里自定义一些行为操作。

在没有IOC之前，类与类之间的耦合关系是这样的。这儿仅仅只有5个类，类之间的耦合关系就如此复杂，难以想象当类的数量随着业务发展而爆炸增多的时候，耦合关系是多么的糟糕。

在有了IOC之后，类与类之间的耦合关系是这样的。所有类都注册在IOC容器上，所有类只和IOC容器耦合，并且IOC容器为所有管理的类提供生命周期的管理。

how IOC do？

可以看出来IOC容器很像我们生活中的百货商场，我们需要什么东西都可以去百货商场买到，在没有百货商场以前我们买菜需要去菜市场，买手机需要去手机店，买电脑需要到电脑城......极大的方便了获取类的方式。接下来我通过Debug源码的方式来追一追整个IOC启动过程的步骤，希望能揭开这个“百货商场”的神秘面纱。

这是我们debug的入口，用的是最基础的XML解析的方式。

ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
HelloService service = (HelloService) context.getBean("service");
service.say();
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
      throws BeansException {
   super(parent); //设置parent父容器
   setConfigLocations(configLocations);//让ioc容器感知到xml配置文件
   if (refresh) {
      refresh();
   }
}

做的第一步是super(parent)，可以看出IOC容器是具备父子关系的，顺便提一下，这个特性在SpringMVC中体现出来了，SpringMVC的容器是 Spring容器的子容器，这样的结果就是Controller（SpringMVC容器中的Bean）可以调用Service（Spring容器中的类），而反过来则不行，这样一定程度保证了类之间的单向关系，以及调用方式不可逆，使得容器更加安全。

public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
      // 为刷新做好准备。
      prepareRefresh();
      // 告诉子类刷新内部bean工厂。
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
      // 准备beanfactory，为使用ioc容器做好准备
      prepareBeanFactory(beanFactory);
      try {
         // 允许beanfactory准备好后做一些事情，扩展点
         postProcessBeanFactory(beanFactory);
         // 将bean注册在ioc容器
         invokeBeanFactoryPostProcessors(beanFactory);
         // 注册拦截bean创建的bean处理器。
         registerBeanPostProcessors(beanFactory);
         // 初始化上下文消息
         initMessageSource();
         // 为这个上下文初始化事件多播器。
         initApplicationEventMulticaster();
         // 初始化特定上下文子类中的其他特殊bean。
         onRefresh();
         // 检查listener类并注册它们
         registerListeners();
         // 实例化所有的lazy-init单例
         finishBeanFactoryInitialization(beanFactory);
         // 最后一步：发布相应的事件
         finishRefresh();
      }
      catch (BeansException ex) {
         if (logger.isWarnEnabled()) {
            logger.warn("Exception encountered during context initialization - " +
                  "cancelling refresh attempt: " + ex);
         }
         // 销毁已经创建的单例
         destroyBeans();
         // 重置active的值
         cancelRefresh(ex);
         // 将异常传播给调用者
         throw ex;
      }
      finally {
         //清空一些元数据的内存，这些元数据生成了单例模式后就再也用不到了
         resetCommonCaches();
      }
   }
}

这里是ioc容器的诞生点 createBeanFactory()

protected final void refreshBeanFactory() throws BeansException {
......

      DefaultListableBeanFactory beanFactory = createBeanFactory();
......
      loadBeanDefinitions(beanFactory);
......
}

再看看loadBeanDefinitions（）方法 ，这里解释下什么是BeanDefinition （所有的Bean在Spring容器中的数据结构都是BeanDefinition，其中包含了跟这个bean相关的所有信息）beanDefinitionReader可以看做是一个IOC容器bean的生产者，可以从外部环境（xml，注解等）获取到bean的信息并装载进去，这个方法对beanDefinitionReader 设置了ResourceLoader，EnitityResolver等等对解析xml文件很重要的类，继续Debug看。

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
   // Create a new XmlBeanDefinitionReader for the given BeanFactory.
   XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

   // Configure the bean definition reader with this context"s
   // resource loading environment.
   beanDefinitionReader.setEnvironment(this.getEnvironment());
   beanDefinitionReader.setResourceLoader(this);
   beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

   // Allow a subclass to provide custom initialization of the reader,
   // then proceed with actually loading the bean definitions.
   initBeanDefinitionReader(beanDefinitionReader);
   loadBeanDefinitions(beanDefinitionReader);
}

ResourceLoader会去解析xml文件，将每个xml中的每个元素都解析然后返回一个DOM的文档树便于后续操作。

接着会执行prepareBeanFactory方法，这个方法类似一个制定ioc规则的方法，让哪些接口的bean不注册进去，哪些接口的bean注册进去

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());
   }
}

之后会对实现了BeanFactoryPostProcessor接口的类处理，该扩展点允许在（容器已经初始完成，但是bean还没有初始化这部分时间进行扩展），体现了Spring的扩展性。

又看到了一个扩展点，BeanPostProcessor，该扩展点允许在bean 初始化之前或者之后的时候进行扩展

String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

接下来回去预实例化没有设置lazy-init的类

beanFactory.preInstantiateSingletons();

进入这个方法体，在debug已经可以看到自己设置的bean的id值了

可以看到除了类之外还有scope，lazyInit，primary等属性

这儿走了一遍getBean的逻辑，不过因为没有初始化，去到的实例都是null，接着会标记即将创建的bean，并将其缓存

/**
 标记已创建的（或即将创建的）指定bean。
这允许bean工厂优化其缓存重复。
创建指定的bean。
 * @param beanName the name of the bean
 */
protected void markBeanAsCreated(String beanName) {
   if (!this.alreadyCreated.contains(beanName)) {
      synchronized (this.mergedBeanDefinitions) {
         if (!this.alreadyCreated.contains(beanName)) {
            // Let the bean definition get re-merged now that we"re actually creating
            // the bean... just in case some of its metadata changed in the meantime.
            clearMergedBeanDefinition(beanName);
            this.alreadyCreated.add(beanName);
         }
      }
   }
}

马上进入实例化bean的代码，其中createBean（）是重点

// Create bean instance.
if (mbd.isSingleton()) {
   sharedInstance = getSingleton(beanName, new ObjectFactory() {
      @Override
      public Object getObject() throws BeansException {
         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是通过反射实例化的。


Class resolvedClass = ClassUtils.forName(className, classLoader);


如果是singleton，直接从map里面取，如果没有则通过反射生成，放进map中然后返回，如果是prototype则每次获取都会实例化，返回一个新的。


if (mbd.isSingleton()) {
   sharedInstance = getSingleton(beanName, new ObjectFactory() {
      @Override
      public Object getObject() throws BeansException {
         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);
}

else if (mbd.isPrototype()) {
   // It"s a prototype -> create a new instance.
   Object prototypeInstance = null;
   try {
      beforePrototypeCreation(beanName);
      prototypeInstance = createBean(beanName, mbd, args);
   }
   finally {
      afterPrototypeCreation(beanName);
   }
   bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}

这就是缓存单例bean的map


private final Map singletonObjects = new ConcurrentHashMap(256);


protected Object getSingleton(String beanName, boolean allowEarlyReference) {
   Object singletonObject = this.singletonObjects.get(beanName);
   if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
      synchronized (this.singletonObjects) {
         singletonObject = this.earlySingletonObjects.get(beanName);
         if (singletonObject == null && allowEarlyReference) {
            ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
            if (singletonFactory != null) {
               singletonObject = singletonFactory.getObject();
               this.earlySingletonObjects.put(beanName, singletonObject);
               this.singletonFactories.remove(beanName);
            }
         }
      }
   }
   return (singletonObject != NULL_OBJECT ? singletonObject : null);
}

总结

ResourceLoader对xml文档树进行读取解析生成Resource文件，Resource文件封装了对xml文件的IO操作，然后BeanDefinitionReader会对Resource文件读取并生成BeanDefinition放在BeanDefinitionRegistry里面，过后beanFactoryPostProcesser会解析占位符，然后SimpleInstantiationStrategy会通过反射实例化，然后BeanWrapper会对非lazy-init的bean进行赋值，在getBean的时候IOC容器通过Map缓存的方式来达到单例的效果。
           
               
                                           
                       
                 
            
                     

                 

                                                                                                                    
                         云服务器
                                             
                         GPU云服务器
                                                                                                                                                 
                                      
                     
                    
                                                                                               基于c语言的记录本
                                                                                                           asp删除记录 源码
                                                                                                           IOC
                                                                                                           _IOC
                                                         
                 

               
              

             
               

                   
 文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

                 
                   
转载请注明本文地址：https://www.ucloud.cn/yun/76673.html

               

                      
               
              
              

                
相关文章

                
    
                             
                                                                                                    
  • 
                                                
    
                          
    Spring AOP从零单排-织入时期源码分析
    
                                                     
    摘要：何为简单点来定义就是切面，是一种编程范式。定义一个切面的载体定义一个切点定义一个为，并指定对应的切点一个注册配置类，启动容器，初始化时期获取对象，获取对象时期，并进行打印好了，这样我们整体的代理就已经完成。

问题：Spring AOP代理中的运行时期，是在初始化时期织入还是获取对象时期织入？
织入就是代理的过程，指目标对象进行封装转换成代理，实现了代理，就可以运用各种代理的场景模式。
...
    
                                                   
                          
    
                                
    
                                    honmaple
                                    
                                    评论0 
                                    收藏0 
                                
    
                          
    
                      
    
                    
    •  
                                                                                       
  • 
                                                
    
                          
    仿照 Spring 实现简单的 IOC 和 AOP - 下篇
    
                                                     
    摘要：在上文中，我实现了一个很简单的和容器。比如，我们所熟悉的就是在这里将切面逻辑织入相关中的。初始化的工作算是结束了，此时处于就绪状态，等待外部程序的调用。其中动态代理只能代理实现了接口的对象，而动态代理则无此限制。

1. 背景
本文承接上文，来继续说说 IOC 和 AOP 的仿写。在上文中，我实现了一个很简单的 IOC 和 AOP 容器。上文实现的 IOC 和 AOP 功能很单一，且 I...
    
                                                   
                          
    
                                
    
                                    AlexTuan
                                    
                                    评论0 
                                    收藏0 
                                
    
                          
    
                      
    
                    
    •  
                                                                                       
  • 
                                                
    
                          
    Spring专题之IOC源码分析
    
                                                     
    摘要：前言以下源码基于版本解析。实现源码分析对于的实现，总结来说就是定位加载和注册。定位就是需要定位配置文件的位置，加载就是将配置文件加载进内存注册就是通过解析配置文件注册。下面我们从其中的一种使用的方式一步一步的分析的实现源码。

前言
以下源码基于Spring 5.0.2版本解析。
什么是IOC容器？
容器，顾名思义可以用来容纳一切事物。我们平常所说的Spring IOC容器就是一个可以容...
    
                                                   
                          
    
                                
    
                                    不知名网友
                                    
                                    评论0 
                                    收藏0 
                                
    
                          
    
                      
    
                    
    •  
                                                                                       
  • 
                                                
    
                          
    零基础带你看Spring源码——IOC控制反转
    
                                                     
    摘要：依赖注入是向某个类或方法注入一个值，其中所用到的原理就是控制反转。但发现更多时间是在调和的源码。里面就是从中取出这个，完成控制反转的。控制反转的优点最后来以我个人观点谈谈控制反转的优点吧。控制反转为了降低项目耦合，提高延伸性。

本章开始来学习下Spring的源码，看看Spring框架最核心、最常用的功能是怎么实现的。网上介绍Spring，说源码的文章，大多数都是生搬硬推，都是直接看来的...
    
                                                   
                          
    
                                
    
                                    wing324
                                    
                                    评论0 
                                    收藏0 
                                
    
                          
    
                      
    
                    
    •  
                                                                                       
  • 
                                                
    
                          
    SpringBoot原理深入篇
    
                                                     
    摘要：启动原理和执行原理分析一的启动原理我们打开，注意看下面两个依赖我们第一步是继承了父项目，然后在添加启动器的依赖，项目就会自动给我们导入关于项目所需要的配置和。

上一篇我们看到，我们很轻松的完成了项目的构建，那么SpringBoot是如何做到的呢，在使用的使用又有哪些通用配置和注意事项呢？
其实SpringBoot给我们做了大量的自动配置功能，我们只需要引入对应的启动器就可以直接使用，作...
    
                                                   
                          
    
                                
    
                                    gotham
                                    
                                    评论0 
                                    收藏0 
                                
    
                          
    
                      
    
                    
    •  
                                                                           
                

              

              
               

                  
                  
发表评论

                   

                                      
                      

                        登陆后可评论
                      
                   

               

              

                

                  
0条评论
   
                
 
                      

              

           
           

              
 
                

                    
                    
Big_fat_cat

                    
男|高级讲师

                    

                     
                                                                      
      
                                                                                        我要私信
                     
                                            
                    

                    

                          
TA的文章

                          阅读更多
                    

                      
                


                   
              
  

                  
最新活动
 
           
         

                    
                      
                    
                    
              





                                
              

           

        
       
    
    
     

      
    

    
    

    
       
       

         
阅读需要支付1元查看
  
         
     
       

      
  
    
    








        

            

              

                    
UCloud （优刻得科技股份有限公司）

                    
UCloud （优刻得科技股份有限公司）是中立、安全的云计算服务平台，坚持中立，不涉足客户业务领域。公司自主研发IaaS、PaaS、大数据流通平台、AI服务平台等一系列云计算产品，并深入了解互联网、传统企业在不同场景下的业务需求，提供公有云、混合云、私有云、专有云在内的综合性行业解决方案。

              

              

                  

            

            
Copyright © 2012-2023 UCloud 优刻得科技股份有限公司｜沪公网安备 31011002000058号｜ 沪ICP备12020087号-3｜ 





 
        

    



<