分析spring源码第五(三)篇：Spring中Bean的解析、加载、创建 过程总结

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量240 收藏
点赞数
文章标签： java python
原文链接：https://my.oschina.net/u/3209651/blog/1936666
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

一、IOC type
   1.Xml               -- 配置bean
   2.Annotation        -- @Compoment
   3.Class             -- @Configuration
   4.Properties,YML    -- @EnableConfigurationProperties(User.class)   @ConfigurationProperties("bnb.user")

  二、IOC 注入方式
   1.Setter
   2.Constructor
   3.Factory-method

  三、Why IOC
   1.模块化
   2.可重用性
   3.易于扩展
   4.可维护

   四、Spring IOC API
   1.BeanDefinition                  -- 描述bean的实例,有属性值，构造参数值
   2.Resource and ResourceLoader     -- 资源和加载资源
   3.BeanFactory                     -- spring bean容器的根接口,定义了容器最基本的功能
   4.ApplicationContext              -- 为应用程序提供配置的中心接口


   五、Spring IOC  process resource

      核心： XML -->  c  --> BeanWrapper(实现依赖注入与类型转化) -> Object (获取我们要的对象)

      1. BeanDefinition 处理过程

       xml or properties ---> ResourceLoader  --->  Resource  --> XXXReader (XmlBeanDefinitionReader/)  -->  BeanDefinition   (主要是这两种解析值的形式  ConstructorArgumentValues 和 MutablePropertyValues)

        new ClassPathXmlApplicationContext("")
            -->  org.springframework.context.support.AbstractApplicationContext.obtainFreshBeanFactory
            -->  org.springframework.context.support.AbstractApplicationContext.refreshBeanFactory
            -->  org.springframework.context.support.AbstractRefreshableApplicationContext.loadBeanDefinitions
            -->  org.springframework.context.support.AbstractXmlApplicationContext.loadBeanDefinitions(org.springframework.beans.factory.support.DefaultListableBeanFactory)

         最终XML解析 是在BeanDefinitionParserDelegate类中完成的

      2. BeanWrapper  处理过程
         Spring的基础设施的中心接口，继承以下四个接口：
         ConfigurablePropertyAccessor
         PropertyAccessor
         PropertyEditorRegistry
         TypeConverter


     3. 依赖注入过程
        Java实例过程：   创建对象  -->  设置属性 --> 初始化方法
        IOC实例化过程：   CreateBeanInstance  -->  populateBean  -->  initializeBean

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

     4.spring 类型转换
      类型转换核心类 TypeConverterDelegate 方法 convertIfNecessary
        ConversionService
        PropertyEditor


     5.spring 容器扩展

     BeanPostProcessor :定制化bean逻辑,bean 后置处理器   典型应用场景：

     注解式依赖注入  @Autowired  @Value    AutowiredAnnotationBeanPostProcessor  (依赖注入的过程 其实就是根据注解获取注解bean的对象值,然后根据Java反射将bena注入进去)

     AOP的实现

     Spring容器感知


   六.
     总结 IOC 过程 BeanFactory xmlBeanFactory = new XmlBeanFactory(new ClassPathResource("beanUserTest.xml"));
     1. xml -> ResourceLoader -> Resource
     2.XmlBeanDefinitionReader.loadBeanDefinitions(resource) -> XmlBeanDefinitionReader.loadBeanDefinitions(new EncodedResource(resource))
     3.XmlBeanDefinitionReader.doLoadBeanDefinitions(InputSource inputSource, Resource resource)
     3.1. 将resource转化成document                        Document doc = XmlBeanDefinitionReader.doLoadDocument(inputSource, resource)     ->  DocumentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,getValidationModeForResource(resource), isNamespaceAware());
     3.2. reader读取document为注册beanDefinition作准备     XmlBeanDefinitionReader.registerBeanDefinitions(Document doc, Resource resource) ->  DefaultBeanDefinitionDocumentReader.registerBeanDefinitions(Document doc, XmlReaderContext readerContext) -> DefaultBeanDefinitionDocumentReader.doRegisterBeanDefinitions(Element root)
     3.3. 用自定义或默认解析器解析element                   DefaultBeanDefinitionDocumentReader.doRegisterBeanDefinitions(Element root)      ->  DefaultBeanDefinitionDocumentReader.parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) -> delegate.parseDefaultElement(ele) / delegate.parseCustomElement(root)
     3.4. 用默认解析器解析element过程     DefaultBeanDefinitionDocumentReader.parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate)
     3.4.1  包含import标签的,则找出引入的resource最后在递归调用loadBeanDefinitions(resource)再次解析  DefaultBeanDefinitionDocumentReader.importBeanDefinitionResource(Element ele) -> AbstractBeanDefinitionReader.loadBeanDefinitions(Resource... resources) ->  XmlBeanDefinitionReader.loadBeanDefinitions(Resource resource)
     3.4.2  包含alias别名的，解析出bean的别名并在aliasRegistered进行注册  DefaultBeanDefinitionDocumentReader.processAliasRegistration(Element ele) ->  ReaderContext.fireAliasRegistered(name, alias, extractSource(ele)) -> EmptyReaderEventListener.aliasRegistered(AliasDefinition aliasDefinition)
     3.4.3  包含bean标签的,则解析出bean并进行bean的注册到map中   DefaultBeanDefinitionDocumentReader.processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate)  ->  BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele) -> BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry())
     3.4.4  包含beans标签的 又重新进入3.2步 DefaultBeanDefinitionDocumentReader.doRegisterBeanDefinitions(Element root)
     4.获取bean xmlBeanFactory.getBean("test")， AbstractBeanFactory.getBean(name) -> AbstractBeanFactory.doGetBean(name,requiredType)
     4.1  转化成真正的bean名，name可能是别名或工厂名等   String beanName = transformedBeanName(name)
     4.2  从缓存中获取单利bean，获取到则返回 Object sharedInstance = getSingleton(beanName)
     4.3 如果4.2 没有获取到，则获取bean的所有依赖，并将依赖进行注册和创建  String[] dependsOn = mbd.getDependsOn() ->  DefaultSingletonBeanRegistry.registerDependentBean(dep, beanName) -> AbstractBeanFactory.getBean(dep);
     4.4 如果是单例 mbd.isSingleton()，  AbstractAutowireCapableBeanFactory.createBean(beanName, rootBeanDefinition，args)
     4.4.1 给BeanPostProcessors处理器一个返回代理而不是目标bean实例的机会。   AbstractAutowireCapableBeanFactory.resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd)
     4.4.1.1  实例化前置处理器 applyBeanPostProcessorsBeforeInstantiation(targetType, beanName)
     4.4.1.2  实例化后置处理器 applyBeanPostProcessorsAfterInitialization(bean, beanName)
     4.4.2 创建bean,  doCreateBean(beanName, mbdToUse, args)
     4.4.2.1  创建bean实例对象   createBeanInstance(beanName, mbd, args)
     4.4.2.1.1    有指定的构造函数的创建bean对象  autowireConstructor(beanName, mbd, null, null)
     4.4.2.1.2    使用默认构造函数创建bean对象   instantiateBean(beanName, mbd)
     4.4.2.2  设置属性，填充值   populateBean(beanName, mbd, instanceWrapper)  给任何实例化的后置处理器修改的机会 InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)
     4.4.2.3  初始化bean       initializeBean(beanName, exposedObject, mbd)
     4.4.2.3.1   更改BeanNameAware/BeanClassLoaderAware/BeanFactoryAware     invokeAwareMethods(beanName, bean)
     4.4.2.3.2   执行所有getBeanPostProcessors的初始化的前置方法                applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName)
     4.4.2.3.3   执行bean的初始化方法                                          invokeInitMethods(beanName, wrappedBean, mbd)   ->  ((InitializingBean) bean).afterPropertiesSet()
     4.4.2.3.4   执行所有getBeanPostProcessors的初始化的后置方法                applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName)
     4.4.3  从bean实例中获取object，   bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
     4.5 如果是多例 mbd.isPrototype()  则创建一个新的实例对象
     4.5.1  将创建中的多例bean存入ThreadLocal<Object> prototypesCurrentlyInCreation =new NamedThreadLocal<Object>中，    beforePrototypeCreation(beanName);
     4.5.2  将建bean对象                createBean(beanName, mbd, args)
     4.5.3  将bean从4.5.1中的prototypesCurrentlyInCreation移除        afterPrototypeCreation(beanName)
     4.5.5  从bean实例中获取object，   bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);



     七.介绍 初始化bean的一些方法的执行顺序

     1、init-method方法，初始化bean的时候执行，可以针对某个具体的bean进行配置。init-method需要在applicationContext.xml配置文档中bean的定义里头写明。例如：<bean id="TestBean" class="nju.software.xkxt.util.TestBean" init-method="init"></bean>
        这样，当TestBean在初始化的时候会执行TestBean中定义的init方法。

     2、afterPropertiesSet方法，初始化bean的时候执行，可以针对某个具体的bean进行配置。afterPropertiesSet 必须实现 InitializingBean接口。实现 InitializingBean接口必须实现afterPropertiesSet方法。

     3、BeanPostProcessor，针对所有Spring上下文中所有的bean，可以在配置文档applicationContext.xml中配置一个BeanPostProcessor，然后对所有的bean进行一个初始化之前和之后的代理。BeanPostProcessor接口中有两个方法： postProcessBeforeInitialization和postProcessAfterInitialization。 postProcessBeforeInitialization方法在bean初始化之前执行， postProcessAfterInitialization方法在bean初始化之后执行。

        总之，afterPropertiesSet 和init-method之间的执行顺序是afterPropertiesSet 先执行，init-method 后执行。从BeanPostProcessor的作用，可以看出最先执行的是postProcessBeforeInitialization，然后是afterPropertiesSet，然后是init-method，然后是postProcessAfterInitialization。

转载于:https://my.oschina.net/u/3209651/blog/1936666

weixin_34100227
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【Spring】Spring原理源码解析（四）-- Spring在解析配置类时，怎么识别并处理@Bean的
ArvinZsh的博客
09-01 199
该篇主要介绍spring在解析配置类时，是如何解析@Bean，构建BD注册到spring中的
Spring5深入浅出篇:Spring中的FactoryBean对象
helloworld工程师的博客
01-28 632
复杂对象：指的就是不能直接通过new构造⽅法创建的对象Connection。
Spring的加载过程
m0_67402341的博客
04-27 372
Spring提供了IOC（控制反转）和AOP（面向切面编程）基本功能，解决企业应用开发的复杂性的一个开源框架。其核心组件包括core、context、bean。 启动过程 在一个基于springmvc的web应用中，需要有一个web容器，一般我们用tomacat，这个web容器提供了一个全局的上下文环境ServletContext，同时也是Spring IoC容器的宿主环境。 宿主容器启动时，其入口文件便是web.xml。web.xml需要定义两个最基本的内容，ContextLoaderListener和D
Spring源码阅读——Bean的加载和获取过程
yyf的博客
11-18 2万+
我们经常使用Spring，并且也都了解其大概原理。我想我们一定会对Spring源码的解读有迫切的渴望。 我也如此。所以，我打算阅读一下Spring的源码。再此之前，我也为此准备了很多。包括，去复习熟练java反射，理解常用的设计模式。当然，这些复习笔记也会在今后的复习中顺便记录在我的csdn博客。（当然，可能写的不好，也可能理解不正确（可以一起交流嘛）。但是乐于分享总归是好的。） 首先看下
Spring加载javaBean过程
青春年少不知疼的博客
08-07 7598
Spring加载普通的Bean的过程 今天看到有人问这个问题，于是我从源码中摘抄并借阅百度文档部分内容。 学习后做一个笔记，以后说不定会用上。 首先先从配置： &lt;!--   配置spring启动listener入口--&gt;    &lt;listener&gt; &lt;listener-class&gt; org.springframework.web.context.C...
如何正确控制springboot中bean的加载顺序小结篇
08-18
主要介绍了如何正确控制springboot中bean的加载顺序总结，本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
spring学习（五）——Bean的创建（总结）
大风的博客
03-30 539
参考文章： http://www.iocoder.cn/ 根据前面几章学习，大概可以总结Bean创建的流程 启动方法 实例化 属性填充 初始化实例 bean 的初始化节点的启动方法，第一次调用 getBean（）来开启 public Object getBean(String name) throws BeansException { return doGetBean(...
springBean加载过程源码解析文档，附有代码类名和行数
06-15
Spring Bean 加载过程源码解析文档 Spring Bean 加载过程是 Spring 框架中最核心的部分之一，涉及到 ApplicationContext 的初始化、Bean 的加载和注册等过程。在 Spring Boot 应用程序中，SpringApplication 负责...
spring源码12: spring创建Bean
01-20
在上一节讲到，首先spring在AbstractBeanFactory类中创建了ObjectFactory的对象，并重写了getObject()方法，然后将他传给DefaultSingletonBeanRegistry。此时DefaultSingletonBeanRegistry调用了singletonFactory....
Spring源码学习二：BeanDefinition解析1
08-04
在Spring容器启动时，配置文件或注解中的bean定义会被解析成BeanDefinition对象，然后由容器进行管理。本文将深入探讨BeanDefinition的内部结构和主要属性。 首先，BeanDefinition接口继承了AttributeAccessor和...
深入解析Spring IoC源码：核心机制与实践应用
12-13
《深入解析Spring IoC源码：核心机制与实践应用》 Spring框架的IoC（Inversion of Control，控制反转）是其核心特性之一，它极大地简化了Java应用程序的开发。本文将深入剖析Spring IoC容器的源码，揭示其工作原理...
Spring5 源码分析(第 2 版)-某Tom老师
07-04
《Spring5 源码分析(第 2 版)》是某Tom老师精心编写的深度解析文档，旨在帮助读者全面理解Spring5的核心机制和设计理念。Spring作为Java领域最为广泛应用的框架之一，其源码的深入理解对于开发者来说至关重要。这篇...
Spring核心之BeanFactory 一张图看懂getBean全过程.
热门推荐
zghwaicsdn的专栏
03-17 3万+
Spring核心之BeanFactory 一张图看懂getBean全过程. Spring通过资源加载器加载相应的XML文件，使用读取器读取资源加载器中的文件到读取器中，在读取过程中，解析相应的xml文件元素，转化为spring定义的数据结BeanDefinition，把相应的BeanDefinition注册到注册表中。注册表中包含的BeanDefinition的数据结构，没有经过加工处理过，无法得到我们想要的bean对象。 我们如何得到Bean对象，spring都做了那些工作？BeanFa
Spring中Bean的创建流程
weixin_34452850的博客
03-14 4387
Spring中Bean的创建流程 一. 核心代码 BeanDefinition的解析在AbstractAutowireCapableBeanFactory的resolveBeforeInstantiation()中： @Nullable protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition m...
Spring源码深度解析系列——bean标签解析《一》
寒山道杳
07-02 1120
导语 在上一篇文章Spring源码深度解析系列——Bean的基本实现中，阐述了bean的加载、xml的验证模式、以及文件的获取等。但这还只是一个开始，在我们获取到文件后，且进行验证之后，我们便需要对这样的文件进行解析的工作了。所以，本篇文章将开始文件解析的代码讲解。 在Spring中对于标签有默认标签和自定义标签这两种，但这两种方式的用法和解析是存在很大区别的，本篇文章将只针对默认标签和大家进...
Spring-单例bean创建过程小结
Details Inside Spring
01-15 1587
缺省情况下，一个Spring bean是单例模式的，也就是说，在整个Spring容器中，该bean只有一个。并且一个单例bean会在第一次从容器获取时被创建，随后再次从容器获取时返回的其实是已经创建好的实例。Spring创建bean的过程，并不是简单地使用Java new关键字创建一个POJO对象，相反，除了创建POJO对象之外，Spring还会对所创建的bean对象进行必要的代理包装，执行生命周...
Spring加载bean的顺序
当我谈编程时我谈些什么
05-16 4034
如果是类加载到Spring容器的顺序，默认是按照类名升序的顺序加载。 方法，如果没有指定顺序或者优先级规定，@Bean按照代码的顺序来进行加载；如果在某个Bean加载过程中调用还没来得及加载的Bean的方法，则（还没来得及加载的Bean）会懒加载此Bean。 @Bean public String fun2() { System.out.println("fun2"); Api api1 = fun1(); System.out.println(api1.hashCode())
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1138
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
"SpringBean加载过程源码解析，包含代码类名和行数详解
SpringBean加载过程源码解析是对Spring框架中Bean加载的具体流程和实现进行深入研究的过程。在源码解析文档中，通过查看代码类名和行数来分析SpringBean加载的每个关键步骤和原理。下面将对SpringBean加载过程的源码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值