精华内容
下载资源
问答
  • springBean生命周期
    万次阅读 多人点赞
    2020-12-18 14:46:36

    一、springBean的生命周期

    1、  启动spring容器,也就是创建beanFactory(bean工厂),
         一般用的是beanFactory的子类applicationcontext,
         applicationcontext比一般的beanFactory要多很多功能,比如aop、事件等。
         通过applicationcontext加载配置文件,或者利用注解的方式扫描将bean
         的配置信息加载到spring容器里面。
    
     2、  加载之后,spring容器会将这些配置信息(java bean的信息),封装成BeanDefinition对象
          BeanDefinition对象其实就是普通java对象之上再封装一层,
          赋予一些spring框架需要用到的属性,比如是否单例,是否懒加载等等。
    
    3、  然后将这些BeanDefinition对象以key为beanName,
         值为BeanDefinition对象的形式存入到一个map里面,
         将这个map传入到spring beanfactory去进行springBean的实例化。
      
    4、  传入到pring beanfactory之后,利用BeanFactoryPostProcessor接口这个扩展点
         去对BeanDefinition对象进行一些属性修改。
    
    5、  开始循环BeanDefinition对象进行springBean的实例化,springBean的实例化也就
         是执行bean的构造方法(单例的Bean放入单例池中,但是此刻还未初始化),
         在执行实例化的前后,可以通过InstantiationAwareBeanPostProcessor扩展点
         (作用于所有bean)进行一些修改。
    
    6、   spring bean实例化之后,就开始注入属性,
          首先注入自定义的属性,比如标注@autowrite的这些属性,
          再调用各种Aware接口扩展方法,注入属性(spring特有的属性),
          比如BeanNameAware.setBeanName,设置Bean的ID或者Name;
    
    7、   初始化bean,对各项属性赋初始化值,,初始化前后执行BeanPostProcessor
          (作用于所有bean)扩展点方法,对bean进行修改。
    
          初始化前后除了BeanPostProcessor扩展点还有其他的扩展点,执行顺序如下:
    
            (1). 初始化前                	   postProcessBeforeInitialization()
            (2). 执行构造方法之后                执行 @PostConstruct 的方法
            (3). 所有属性赋初始化值之后           afterPropertiesSet()
            (4). 初始化时              	       配置文件中指定的 init-method 方法
            (5). 初始化后                	   postProcessAfterInitialization()
    
    		先执行BeanPostProcessor扩展点的前置方法postProcessBeforeInitialization(),
    		再执行bean本身的构造方法
    		再执行@PostConstruct标注的方法
    		所有属性赋值完成之后执行afterPropertiesSet()
    		然后执行 配置文件或注解中指定的 init-method 方法
    		最后执行BeanPostProcessor扩展点的后置方法postProcessAfterInitialization()
    
    8、     此时已完成bean的初始化,在程序中就可以通过spring容器拿到这些初始化好的bean。
    
    9、     随着容器销毁,springbean也会销毁,销毁前后也有一系列的扩展点。
      		销毁bean之前,执行@PreDestroy 的方法
    	    销毁时,执行配置文件或注解中指定的 destroy-method 方法。
    
    
      		以上就是spring bean的整个生命周期
    
      		其实就是根据配置文件或注解信息,生成BeanDefinition,
      		循环BeanDefinition去实例化-》注入属性-》初始化-》销毁,在这4个阶段执行前后,
      		spring框架提供了一系列的扩展点。
    

    二、springBean的各种扩展点

    (1)、容器级扩展点(作用于所有bean):
    
    	BeanFactoryPostProcessor接口:
    	
    	在循环初始化springbean之前,对BeanDefinition元数据做扩展处理
    	
    	InstantiationAwareBeanPostProcessor接口:
    	
    	在对象实例化前后扩展,作用于所有bean
    	
    	BeanPostProcessor接口:
    	
    	在对象初始化化前后扩展,作用于所有bean
    
    (2)、Bean扩展点(作用于单个bean):
    
    	Aware接口:
    	
    	springBean实例化并且注入自定义属性之后
    	
    	InitializingBean接口:
    	
    	springBean初始化时,执行构造方法结束,并且属性赋初始化值结束之后执行
    	
    	DiposableBean接口:
    	
    	springBean销毁之前执行。
    
    (3)、Bean自身的方法
    
    	包括了Bean本身调用的方法
    	
    	通过配置文件中<bean>的init-method和destroy-method指定的方法(或者用注解的方式)
    	
    	(4)、包括了AspectJWeavingEnabler, 
    	 ConfigurationClassPostProcessor, 
    	 CustomAutowireConfigurer等等非常有用的工厂后处理器接口的方法。
    	 工厂后处理器也是容器级的。在应用上下文装配配置文件之后立即调用。
    
    更多相关内容
  • Spring Bean生命周期在整个 Spring 中占有很重要的位置,掌握这些可以加深对 Spring 的理解。这篇文章主要介绍了Spring Bean 生命周期,需要的朋友可以参考下
  • spring bean生命周期

    2019-01-16 08:37:23
    spring bean生命周期,把运行结果的日志,用sublime打开对比查看,你会有比较清晰的认识
  • SpringBean生命周期详解

    千次阅读 多人点赞 2020-10-28 17:51:28
    SpringBean生命周期详解 一、简述: Spring是我们每天都在使用的框架,Bean是被Spring管理的Java对象,是Spring框架最重要的部分之一,那么让我们一起了解一下Spring中Bean的生命周期是怎样的吧 二、流程图 我们先从...

    SpringBean生命周期详解

    一、简述:

    Spring是我们每天都在使用的框架,Bean是被Spring管理的Java对象,是Spring框架最重要的部分之一,那么让我们一起了解一下Spring中Bean的生命周期是怎样的吧

    二、流程图

    在这里插入图片描述

    总体分为四个阶段:

      ①实例化 CreateBeanInstance
      ②属性赋值 PopulateBean
      ③初始化 Initialization
      ④销毁 Destruction**
    

    其中多个增强接口贯穿了这四个阶段!

    三、SpringBean生命周期中的增强接口PostProcessor:

    在上图里有多种后置处理器接口,它们贯穿了Bean的生命周期,且它们的实现类都会在SpringIOC容器进行初始化的时候进行实例化,让我们来做一个区分:

    |  |  ||--|--||  |  |

    解释:

    Bean的实例化:
    是指Spring通过反射获取Bean的构造方法进行实例化的过程
    Bean的初始化:
    是指Bean的属性赋值、执行初始化方法(init-method)的过程

    四、实例展示

    SpringBeanDemo

    package com.rx.spring;
     
    import com.rx.spring.domain.Person;
    import com.rx.spring.domain.Student;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
     
    public class SpringBeanDemo {
        public static void main(String[] args) throws Exception {
            System.out.println("****开始启动****");
            AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(Config.class);
            System.out.println("****启动完毕****");
            Person person = applicationContext.getBean("person", Person.class);
            Student student = applicationContext.getBean("student", Student.class);
     
            System.out.println("=============================================");
            System.out.println("person:" + person);
            System.out.println("student:" + student);
            person.destroy();
     
            System.out.println("============现在开始关闭容器======================");
            applicationContext.registerShutdownHook();
        }
    }
    

    Config

    package com.rx.spring;
     
    import org.springframework.context.annotation.*;
     
    @Configuration
    @ComponentScan("com.rx.spring")
    @ImportResource("classpath:spring.xml")
    public class Config {
         
    }
    

    Person

    package com.rx.spring.domain;
     
    import lombok.Data;
    import org.springframework.beans.factory.DisposableBean;
     
    @Data
    public class Person implements DisposableBean {
        private String name;
        private String address;
        private String tel;
     
        public Person(String name, String address, String tel) {
            System.out.println("Person--->>>有参构造方法");
            this.name = name;
            this.address = address;
            this.tel = tel;
        }
     
        public Person() {
            System.out.println("Person--->>>无参构造方法");
        }
     
        private void raoInitMethod() {
            System.out.println("person--->>>InitMethod...");
        }
     
        private void raoDestroyMethod() {
            System.out.println("person--->>>DestroyMethod...");
        }
     
        @Override
        public void destroy() throws Exception {
            System.out.println("【DisposableBean接口】调用DisposableBean.destroy()");
        }
    }
    

    Student

    package com.rx.spring.domain;
     
    import lombok.Data;
    import org.springframework.beans.factory.DisposableBean;
     
    @Data
    public class Student implements DisposableBean {
        private String username;
        private String password;
     
        public Student(String username, String password) {
            System.out.println("student--->>有参构造方法");
            this.username = username;
            this.password = password;
        }
        public Student() {
            System.out.println("student--->>>无参构造方法");
        }
     
        private void raoInitMethod() {
            System.out.println("student--->>>InitMethod...");
        }
     
        private void raoDestroyMethod() {
            System.out.println("student--->>>DestroyMethod...");
        }
     
        @Override
        public void destroy() throws Exception {
            System.out.println("【DisposableBean接口】调用DisposableBean.destroy()");
        }
    }
    

    RaoBeanFactoryPostProcessor

    package com.rx.spring.beanfactorypostprocessor;
     
    import org.springframework.beans.BeansException;
    import org.springframework.beans.MutablePropertyValues;
    import org.springframework.beans.factory.config.BeanDefinition;
    import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
    import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
    import org.springframework.stereotype.Component;
     
    @Component
    public class RaoBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
            System.out.println("postProcessBeanFactory...");
            String[] beanStr = beanFactory.getBeanDefinitionNames();
            for (String beanName : beanStr) {
                if ("person".equals(beanName)) {
                    BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName);
                    MutablePropertyValues m = beanDefinition.getPropertyValues();
                    if (m.contains("address")) {
                        //这个方法是判断是否有propertyName=username,有就替换,没有就添加
                        m.addPropertyValue("address", "大兴区");
                        System.out.println("***修改了address属性初始值了***");
                    }
                }
            }
        }
    }
    

    RaoInstantiationAwareBeanPostProcessor

    package com.rx.spring.beanpostprocessor;
     
    import com.rx.spring.domain.Person;
    import org.springframework.beans.BeansException;
    import org.springframework.beans.PropertyValue;
    import org.springframework.beans.PropertyValues;
    import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter;
    import org.springframework.stereotype.Component;
     
    @Component
    public class RaoInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter {
        @Override
        public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
            if ("person".equals(beanName) || "student".equals(beanName)) {
                System.out.println(beanName + "--->>>InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation....");
            }
            return null;
        }
     
        @Override
        public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
            if ("person".equals(beanName) || "student".equals(beanName)) {
                System.out.println(beanName + "--->>>InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation....");
            }
            return bean instanceof Person;
        }
     
        @Override
        public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
            System.out.println(beanName + "--->>>InstantiationAwareBeanPostProcessor.postProcessProperties...");
            PropertyValue[] propertyValues = pvs.getPropertyValues();
            for (PropertyValue propertyValue : propertyValues) {
                if ("name".equals(propertyValue.getName())) {
                    propertyValue.setConvertedValue("改后rx");
                }
            }
            return pvs;
        }
    }
    

    RaoBeanPostProcessor

    
    package com.rx.spring.beanpostprocessor;
     
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.config.BeanPostProcessor;
    import org.springframework.stereotype.Component;
     
    @Component
    public class RaoBeanPostProcessor implements BeanPostProcessor {
        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            if ("person".equals(beanName) || "student".equals(beanName)) {
                System.out.println(beanName + "--->>>BeanPostProcessor.postProcessBeforeInitialization...");
            }
            return bean;
        }
     
        @Override
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
            if ("person".equals(beanName) || "student".equals(beanName)) {
                System.out.println(beanName + "--->>>BeanPostProcessor.postProcessAfterInitialization....");
            }
            return bean;
        }
    }
    

    spring.xml

    
    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
     
        <bean id ="person" class="com.rx.spring.domain.Person" init-method="raoInitMethod" destroy-method="raoDestroyMethod">
            <property name="name" value="rx"/>
            <property name="address" value="beijing"/>
            <property name="tel" value="157********"/>
        </bean>
     
        <bean id ="student" class="com.rx.spring.domain.Student" init-method="raoInitMethod" destroy-method="raoDestroyMethod">
            <property name="username" value="rx"/>
            <property name="password" value="1234"/>
        </bean>
     
    </beans>
    

    运行结果:

    在这里插入图片描述
    在这里插入图片描述

    运行结果符合预期,成功验证了之前的结论!!!

    原创不易,转载请附上本页面链接

    展开全文
  • Springbean生命周期详解

    2022-02-21 18:03:22
    如果是在springBean里面,Bean的生命周期就显得非常复杂,我把它详细了解了一下,分为十个步骤: Bean的实例化:spring启动后,会查找和加载需要被spring管理的Bean,并且实例化。 Bean属性注入:Bean被实例化后对...

    在传统的java应用中,JavaBean的生命周期一般都是浅化理解,就是在在Java中使用关键字new把Bean进行实例化,然后Bean就可以使用了,一旦不使用了,Java会自动进行垃圾回收。

    如果是在springBean里面,Bean的生命周期就显得非常复杂,我把它详细了解了一下,分为十个步骤:

    1. Bean的实例化:spring启动后,会查找和加载需要被spring管理的Bean,并且实例化。
    2. Bean属性注入:Bean被实例化后对将Bean的引入和值注入到Bean的属性中。
    3. 调用BeanNameAware的setBeanName()方法:如果实现了BeanNameAware接口的话,Spring将Bean的Id传递给setBeanName()方法。
    4. 调用BeanFactoryAware的setBeanFactory()方法:如果Bean实现了BeanFactoryAware接口的话,spring就将调用他们的setBeanFactory()方法,将BeanFactory容器实例传入。
    5. 调用ApplicationContextAware的setApplicationContext方法:如果Bean实现了ApplicationContextAware接口的话,spring将调用Bean的setApplicationContext方法,将Bean所在用用上下文引用传入进来。
    6. 调用BeanPostProcessor的预初始化方法:如果Bean实现了BeanPostProcessor接口,spring将调用他们的postProcessBeforeInitialization()方法。
    7. 调用InitializingBean的afterPropertiesSet()方法:如果Bean实现了InitializingBean接口,spring将调用他们的afterPropertiesSet()方法,类似的,如果Bean使用init-method生命了初始化方法的话,这个方法也会被调用。
    8. 调用BeanPostProcessor的初始化后的方法:如果Bean实现了BeanPostProcessor接口,spring就将调用他们的postprocessAfterInitialization()方法。
    9. Bean可以使用了:这个时候,Bean就已经准备好了,可以被应用程序使用了,他们将一直驻留在应用的上下文中,直到应用的上下文被销毁。
    10. 调用DisposableBean的destory()方法:如果Bean实现DisposableBean接口,spring将嗲用他的destory()就扣方法,相同的,如果Bean使用了destory-method生命销毁方法,该方法也会被调用。

    以上就是spring中Bean的核心接口和生命周期,但是翻阅JavaDoc文档发现除了以上接口外,还有另外的初始化过程设计的接口。

                            springBean生命周期的详解图

    Bean完整的生命周期

    文字解释如下:

    ----------初始化----------

    BeanNameAware.setBeanName()在创建此Bean的Bean工厂设置Bean的名称,在普通属性设置之后再调用,在InitializingBean.afterPropertiesSet()方法之前调用。

    BeanClassLoadeAware.setBeanClassLoader():在普通属性设置之后,InitializingBean.afterPropertiesSet()之前调用。

    BeanFactoryAware.setBeanFactory():回调提供了自己的Bean实例工厂,在普通实行设置后,在InitializingBean.afterPropertiesSet()或者自定义初始化方法之前调用。

    EnvironmentAware.setEnvironment():设置environment在组件使用是调用。

    EmbeddedValueResolverAware.setEmbeddedValueResolver():设置StringValueResolver用来解决嵌入式的值域问题。

    ResourceLoaderAware.setResourceLoader():在普通Bean对象之后调用,在afterPropertiesSet或者自定义的init-method之前调用,在ApplicationContextAware之前调用。

    ApplicationEventPublisherAware.setApplicationEventPublisher():在普通Bean书香之后调用,在初始化调用afterpropertiesSet或者自定义初始化方法之前调用。在ApplicationContextAware之前调用。

    MessageSourceAware.setMessageSource():在普通Bean属性之后条用,在初始化调用afterPropertiesSet或者自定义初始化方法之前调用,在A品牌力擦体哦那ContextAware之前调用。

    ApplicationContextAware.setApplicationContext():在普通Bean对象生成之后调用,在InitializingBean.afterPropertiesSet之前调用或者用户自定义初始化方法之前。在ReasourceLoaderAware.setResourceLoader,ApplicationEcentPublisherAware.setApplicationEvenPublisher,MessageSourceAware之后使用。

    ServketContextAware.setServletContext():运行时设置ServletContext,在普通Bean初始化后调用,在InitializingBean.aftePropertiesSet之前调用,在ApplicationContextAware之后调用。

    注意:实在WebApplicationContext运行时。

    BeanPostProcessor.postPricessBeforeInitialization():将此BeanPostProcessor应用与给定的新B额按实例,在任何Bean初始化回调方法(像是InitializingBean.afterPropertiesSet或者自定义的初始化方法)之前调用。这个Bean将要准备天秤属性的值。返回的Bean实例可能被普通对象包装,默认实现返回时一个Bean。

    BeanPostProcessor.postPricessAfterInitialization():将此BeanPostProcessor应用与给定的新B额按实例,在任何Bean初始化回调方法(像是InitializingBean.afterPropertiesSet或者自定义的初始化方法)之后调用。这个Bean将要准备填充属性的值。返回的Bean实例可能被普通对象包装。

    InitializingBean.afterPropertiesSet():被BeanFactory在设置所有Bean属性之后调用(并且满足BeanFactory和ApplicationContextAware)。

    ---------销毁----------

    在BeanFactory关闭的时候,Bean 的生命周期会调用如下方法:

    DestructionAwareBeanPostProcessor.postProcessBeforeDestruction():在销毁之前将此BeanProcessor应用于给定的Bean实例。能够调用自定义回调,像是DisposableBean的销毁和自定义销毁方法,这个回调仅仅适用于Factory中的单例Bean(包括内壁Bean)。

    展开全文
  • Spring bean生命周期详解

    千次阅读 2021-09-10 10:49:21
    Spring bean生命周期 四个阶段 Bean的实例化阶段 Bean的设置属性阶段 Bean的 初始化阶段 Bean的销毁阶段 Spring bean生命周期13个环节 阶段1:Bean元信息配置阶段 阶段2:Bean元信息解析阶段 阶段3:将Bean注册到...

    Spring Bean的完整生命周期从创建Spring容器开始,直到最终Spring容器销毁Bean,这其中包含了一系列关键点。
    在这里插入图片描述
    在这里插入图片描述

    Spring bean生命周期 四个阶段

    Bean的实例化阶段
    Bean的设置属性阶段
    Bean的 初始化阶段
    Bean的销毁阶段

    Spring bean生命周期13个环节

    阶段1:Bean元信息配置阶段
    阶段2:Bean元信息解析阶段
    阶段3:将Bean注册到容器中
    阶段4:BeanDefinition合并阶段
    阶段5:Bean Class加载阶段
    阶段6:Bean实例化阶段(2个小阶段)
    1.Bean实例化前阶段
    2.Bean实例化阶段
    阶段7:合并后的BeanDefinition处理
    阶段8:属性赋值阶段(3个小阶段)
    1.Bean实例化后阶段
    2.Bean属性赋值前阶段
    3.Bean属性赋值阶段
    阶段9:Bean初始化阶段(5个小阶段)
    1.Bean Aware接口回调阶段
    2.Bean初始化前阶段
    3.Bean初始化阶段
    4.Bean初始化后阶段
    5.Bean初始化完成
    阶段10:所有单例bean初始化完成后阶段
    阶段11:Bean的使用阶段
    阶段12:Bean销毁前阶段
    阶段13:Bean销毁阶段

    阶段1:Bean元信息配置阶段

    这个阶段主要是bean信息的定义阶段
    Bean信息定义4种方式

    1. API的方式
    2. Xml文件方式
    3. 注解的方式
      类上标注@Compontent注解来定义一个bean
      配置类中使用@Bean注解来定义bean
    4. properties文件的方式
      Spring容器启动的过程中,会将Bean解析成Spring内部的BeanDefinition结构。

    不管是是通过xml配置文件的标签,还是通过注解配置的@Bean,还是@Compontent标注的类,还是扫描得到的类,它最终都会被解析成一个BeanDefinition对象,最后我们的Bean工厂就会根据这份Bean的定义信息,对bean进行实例化、初始化等等操作。

    你可以把BeanDefinition丢给Bean工厂或者其子类,然后Bean工厂就会根据这个信息帮你生产一个Bean实例
    一般用的是beanFactory的子类applicationcontext, applicationcontext比一般的beanFactory要多很多功能,比如aop、事件等。
    通过t加载配置文件,或者利用注解的方式扫描将bean的配置信息加载到spring容器里面。

    在这里插入图片描述

    BeanDefinition接口:bean定义信息接口
    AttributeAccessor接口:属性访问接口
    BeanMetadataElement接口:返回BeanDefinition定义的来源
    RootBeanDefinition类:表示根bean定义信息
    ChildBeanDefinition类:表示子bean定义信息
    GenericBeanDefinition类:通用的bean定义信息
    ConfigurationClassBeanDefinition类:表示通过配置类中@Bean方法定义bean信息
    AnnotatedBeanDefinition接口:表示通过注解的方式定义的bean信息
    BeanDefinitionBuilder:构建BeanDefinition的工具类,可以非常方便的组装BeanDefinition对象

    @Component 和 @Bean 的区别

    Spring帮助我们管理Bean分为两个部分,一个是注册Bean,一个装配Bean。
    完成这两个动作有三种方式,一种是使用自动配置的方式、一种是使用JavaConfig的方式,一种就是使用XML配置的方式。

    @Compent 作用就相当于 XML配置

    @Component
    public class Student {
    
        private String name = "lkm";
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }
    

    @Bean 需要在配置类中使用,即类上需要加上@Configuration注解

    @Configuration
    public class WebSocketConfig {
        @Bean
        public Student student(){
            return new Student();
        }
    
    }
    

    两者都可以通过@Autowired装配

    @Autowired Student student;

    那为什么有了@Compent,还需要@Bean呢?
    如果你想要将第三方库中的组件装配到你的应用中,在这种情况下,是没有办法在它的类上添加@Component注解的,因此就不能使用自动化装配的方案了,但是我们可以使用@Bean,当然也可以使用XML配置。

    阶段2:Bean元信息解析阶段

    Bean元信息的解析主要有3种方式

    1. xml文件定义bean的解析
      XML方式解析:XmlBeanDefinitionReader
    2. properties文件定义bean的解析
      properties文件定义bean的解析:PropertiesBeanDefinitionReader
    3. 注解方式定义bean的解析
      AnnotatedBeanDefinitionReader
      BeanDefinationReader的作用就是加载配置元信息,并将其转化为内存形式的BeanDefination

    阶段3:Spring Bean注册阶段

    bean注册阶段需要用到一个非常重要的接口:BeanDefinitionRegistry

    别名注册接口:AliasRegistry
    BeanDefinitionRegistry接口继承了AliasRegistry接口,这个接口中定义了操作bean别名的一些方法。

    BeanDefinitionRegistry唯一实现:DefaultListableBeanFactory
    org.springframework.beans.factory.support.DefaultListableBeanFactory
    例如 AnnotationConfigApplicationContext 类就实现了 BeanDefinitionRegistry接口

    Spring通过BeanDefinationReader将配置元信息加载到内存生成相应的BeanDefination之后,就将其注册到BeanDefinationRegistry中,BeanDefinationRegistry就是一个存放BeanDefination的大篮子,它也是一种键值对的形式,通过特定的Bean定义的id,映射到相应的BeanDefination。

    getBean这个方法的源码
    org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean

    阶段4:BeanDefinition合并阶段

    org.springframework.beans.factory.support.AbstractBeanFactory#getMergedBeanDefinition
    bean定义可能存在多级父子关系,合并的时候进进行递归合并,最终得到一个包含完整信息的RootBeanDefinition.

    合并之前是GenericBeanDefinition类型的,合并之后得到的是RootBeanDefinition类型的。

    后面的阶段将使用合并产生的RootBeanDefinition

    阶段5:Bean Class加载阶段

    这个阶段就是将bean的class名称转换为Class类型的对象。

    此时会对阶段4中合并产生的RootBeanDefinition中的beanClass进行解析,将bean的类名转换为Class对象,然后赋值给RootBeanDefinition#setBeanClassName字段

    上面得到了Bean Class对象以及合并之后的BeanDefinition,下面就开始进入实例化这个对象的阶段了。
    Bean实例化分为3个阶段:前阶段、实例化阶段、后阶段;

    阶段6:Bean实例化阶段

    Bean实例化前操作

    看一下 DefaultListableBeanFactory

    在 父类 AbstractBeanFactory 中
    private final List beanPostProcessors = new CopyOnWriteArrayList<>();
    是一个BeanPostProcessor类型的集合

    spring在bean生命周期的不同阶段,会调用上面这个列表中的BeanPostProcessor中的一些方法,来对生命周期进行扩展,bean生命周期中的所有扩展点都是依靠这个集合中的BeanPostProcessor来实现的

    Bean实例化之前会调用一段代码:
    org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInstantiation

    protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
    	for (BeanPostProcessor bp : getBeanPostProcessors()) {
    		if (bp instanceof InstantiationAwareBeanPostProcessor) {
    			InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
    			Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
    			if (result != null) {
    				return result;
    			}
    		}
    	}
    	return null;
    }
    

    上面代码中轮询beanPostProcessors列表,如果类型是InstantiationAwareBeanPostProcessor, 尝试调用InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation获取bean的实例对象,如果能够获取到,那么将返回值作为当前bean的实例,那么spring自带的实例化bean的过程就被跳过了.

    这个地方给开发者提供了一个扩展点,允许开发者在这个方法中直接返回bean的一个实例

    Bean实例化操作
    这个过程可以干什么?

    这个过程会通过反射来调用bean的构造器来创建bean的实例。
    org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostProcessor#determineCandidateConstructors
    这个方法会返回候选的构造器列表,也可以返回空.

    protected Constructor<?>[] determineConstructorsFromBeanPostProcessors(Class<?> beanClass, String beanName)
    			throws BeansException {
    
    		if (beanClass != null && hasInstantiationAwareBeanPostProcessors()) {
    			for (BeanPostProcessor bp : getBeanPostProcessors()) {
    				if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
    					SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
    					Constructor<?>[] ctors = ibp.determineCandidateConstructors(beanClass, beanName);
    					if (ctors != null) {
    						return ctors;
    					}
    				}
    			}
    		}
    		return null;
    	}
    

    具体需要使用哪个构造器,spring为开发者提供了一个接口,允许开发者自己来判断用哪个构造器。
    重要的实现类 org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor
    可以将@Autowired标注的方法作为候选构造器返回
    到目前为止bean实例化阶段结束了

    阶段7:合并后的BeanDefinition处理

    这块的源码如下
    org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyMergedBeanDefinitionPostProcessors

    protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
    	for (BeanPostProcessor bp : getBeanPostProcessors()) {
    		if (bp instanceof MergedBeanDefinitionPostProcessor) {
    			MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
    			bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
    		}
    	}
    }
    

    会调用MergedBeanDefinitionPostProcessor接口的postProcessMergedBeanDefinition方法

    第一个参数为beanDefinition,表示合并之后的RootBeanDefinition,我们可以在这个方法内部对合并之后的BeanDefinition进行再次处理

    实现类
    org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor
    在 postProcessMergedBeanDefinition 方法中对 @Autowired、@Value 标注的方法、字段进行缓存

    org.springframework.context.annotation.CommonAnnotationBeanPostProcessor
    在 postProcessMergedBeanDefinition 方法中对 @Resource 标注的字段、@Resource 标注的方法、 @PostConstruct 标注的字段、 @PreDestroy标注的方法进行缓存

    阶段8:Bean属性设置阶段

    (1)调用 InstantiationAwareBeanPostProcessor 处理器的 postProcessAfterInstantiation 方法,判断控制程序是否继续进行属性填充

    (2)根据注入类型(byType/byName),提取依赖的,统一存入 PropertyValues 中

    (3)判断是否需要进行 BeanPostProcessor 和 依赖检查:

    如果有后置处理器,将会应用 InstantiationAwareBeanPostProcessor 处理器的postProcessProperties 方法,对属性获取完毕填充前,对属性进行再次处理。 使用 checkDependencies方法来进行依赖检查
    (4)将所有解析到的 PropertyValues 中的属性填充至 BeanWrapper 中

    实例化后阶段
    会调用InstantiationAwareBeanPostProcessor接口的postProcessAfterInstantiation这个方法,调用逻辑如下:
    org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization

    @Override
    public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
    		throws BeansException {
    
    	Object result = existingBean;
    	for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
    		result = beanProcessor.postProcessAfterInitialization(result, beanName);
    		if (result == null) {
    			return result;
    		}
    	}
    	return result;
    }
    

    postProcessAfterInstantiation方法返回false的时候,后续的Bean属性赋值前处理、Bean属性赋值都会被跳过

    Bean属性赋值前阶段
    这个阶段会调用InstantiationAwareBeanPostProcessor接口的postProcessPropertyValues方法,调用逻辑
    org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean

    if (hasInstAwareBpps || needsDepCheck) {
    	PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
    	if (hasInstAwareBpps) {
    		for (BeanPostProcessor bp : getBeanPostProcessors()) {
    			if (bp instanceof InstantiationAwareBeanPostProcessor) {
    				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
    				pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
    				if (pvs == null) {
    					return;
    				}
    			}
    		}
    	}
    	if (needsDepCheck) {
    		checkDependencies(beanName, mbd, filteredPds, pvs);
    	}
    }
    

    如果InstantiationAwareBeanPostProcessor中的postProcessPropertyValues返回空的时候,表示这个bean不需要设置属性,直接返回了,直接进入下一个阶段
    PropertyValues 保存了bean实例对象中所有属性值的设置,所以我们可以在postProcessPropertyValues 这个方法中对PropertyValues值进行修改。

    这个方法有2个比较重要的实现类

    AutowiredAnnotationBeanPostProcessor#postProcessPropertyValues在这个方法中对@Autowired、@Value标注的字段、方法注入值。
    CommonAnnotationBeanPostProcessor#postProcessPropertyValues在这个方法中对@Resource标注的字段和方法注入值。
    Bean属性赋值阶段
    这个过程比较简单了,循环处理PropertyValues中的属性值信息,通过反射调用set方法将属性的值设置到bean实例中。

    PropertyValues中的值是通过bean xml中property元素配置的,或者调用MutablePropertyValues中add方法设置的值。

    阶段9:Bean初始化阶段

    这个阶段分为5个小的阶段

    Bean Aware接口回调
    Bean初始化前操作
    Bean初始化操作
    Bean初始化后操作
    Bean初始化完成操作
    Bean Aware接口回调

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

    private void invokeAwareMethods(final String beanName, final Object bean) {
    		if (bean instanceof Aware) {
    			if (bean instanceof BeanNameAware) {
    				((BeanNameAware) bean).setBeanName(beanName);
    			}
    			if (bean instanceof BeanClassLoaderAware) {
    				((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
    			}
    			if (bean instanceof BeanFactoryAware) {
    				((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
    			}
    		}
    	}
    

    如果我们的bean实例实现了上面的接口,会按照下面的顺序依次进行调用,

    BeanNameAware:将bean的名称注入进去
    BeanClassLoaderAware:将BeanClassLoader注入进去
    BeanFactoryAware:将BeanFactory注入进去

    Bean初始化前操作
    这个阶段的源码
    org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization

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

    会调用BeanPostProcessor的postProcessBeforeInitialization方法,若返回null,当前方法将结束。

    通常称postProcessBeforeInitialization这个方法为:bean初始化前操作。

    这个接口有2个实现类,比较重要:
    org.springframework.context.support.ApplicationContextAwareProcessor
    org.springframework.context.annotation.CommonAnnotationBeanPostProcessor

    ApplicationContextAwareProcessor注入6个Aware接口对象
    如果bean实现了下面的接口,在ApplicationContextAwareProcessor#postProcessBeforeInitialization中会依次调用下面接口中的方法,将Aware前缀对应的对象注入到bean实例中。
    EnvironmentAware:注入Environment对象 EmbeddedValueResolverAware:注入EmbeddedValueResolver对象 ResourceLoaderAware:注入ResourceLoader对象 ApplicationEventPublisherAware:注入ApplicationEventPublisher对象 MessageSourceAware:注入MessageSource对象 ApplicationContextAware:注入ApplicationContext对象

    CommonAnnotationBeanPostProcessor调用@PostConstruct标注的方法
    CommonAnnotationBeanPostProcessor#postProcessBeforeInitialization中会调用bean中所有标注@PostConstruct注解的方法

    ReflectionUtils.doWithLocalMethods(targetClass, new ReflectionUtils.MethodCallback() {
    	@Override
    	public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException {
    		if (initAnnotationType != null) {
    			if (method.getAnnotation(initAnnotationType) != null) {
    				LifecycleElement element = new LifecycleElement(method);
    				currInitMethods.add(element);
    				if (debug) {
    					logger.debug("Found init method on class [" + clazz.getName() + "]: " + method);
    				}
    			}
    		}
    		if (destroyAnnotationType != null) {
    			if (method.getAnnotation(destroyAnnotationType) != null) {
    				currDestroyMethods.add(new LifecycleElement(method));
    				if (debug) {
    					logger.debug("Found destroy method on class [" + clazz.getName() + "]: " + method);
    				}
    			}
    		}
    	}
    })
    

    调用@PostConstruct标注的方法

    Bean初始化阶段
    2个步骤
    调用InitializingBean接口的afterPropertiesSet方法
    调用定义bean的时候指定的初始化方法。
    见:com.dn.spring.beandefinition.BeanDefinition5Test#test7

    Bean初始化后阶段
    这块的源码:
    org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization

    @Override
    public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
    throws BeansException {

    	Object result = existingBean;
    	for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
    		result = beanProcessor.postProcessAfterInitialization(result, beanName);
    		if (result == null) {
    			return result;
    		}
    	}
    	return result;
    }
    

    调用BeanPostProcessor接口的postProcessAfterInitialization方法,返回null的时候,会中断上面的操作。
    通常称 postProcessAfterInitialization 这个方法为:bean初始化后置操作。

    阶段10:所有单例bean初始化完成后阶段

    所有单例bean实例化完成之后,spring会回调下面这个接口:

    public interface SmartInitializingSingleton {
        void afterSingletonsInstantiated();
    }
    

    调用逻辑在下面这个方法中
    //确保所有非lazy的单例都被实例化,同时考虑到FactoryBeans。 //如果需要,通常在工厂设置结束时调用。 org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons

    这个方法内部会先触发所有非延迟加载的单例bean初始化,然后从容器中找到类型是SmartInitializingSingleton的bean,调用他们的afterSingletonsInstantiated方法。

    阶段11:Bean使用阶段

    调用getBean方法得到了bean之后

    阶段12:Bean销毁阶段

    触发bean销毁的几种方式

    调用org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#destroyBean
    调用org.springframework.beans.factory.config.ConfigurableBeanFactory#destroySingletons
    调用ApplicationContext中的close方法
    Bean销毁阶段会依次执行

    轮询beanPostProcessors列表,如果是DestructionAwareBeanPostProcessor这种类型的,会调用其内部的postProcessBeforeDestruction方法
    如果bean实现了org.springframework.beans.factory.DisposableBean接口,会调用这个接口中的destroy方法
    调用bean自定义的销毁方法
    DestructionAwareBeanPostProcessor接口

    public interface DestructionAwareBeanPostProcessor extends BeanPostProcessor {
    
        /**
         * bean销毁前调用的方法
         */
        void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException;
    
        /**
         * 用来判断bean是否需要触发postProcessBeforeDestruction方法
         */
        default boolean requiresDestruction(Object bean) {
            return true;
        }
    }
    

    总结:

    BeanDefination(bean定义配置-解析-注册):

    配置元信息(bean定义配置)-BeanDefinationReader(解析)-BeanDefinationRegistry(注册);
    配置元信息(bean定义配置):API的方式,Xml文件方式,注解的方式,properties文件
    BeanDefinationRegistry:;键值对方式,通过特定的Bean定义的id,映射到相应的BeanDefination

    Bean实例化阶段:Bean实例化分为3个阶段:前阶段(容器启动,Bean Class加载BeanDefination)、实例化阶段、后阶段;

    BeanFactoryPostProcessor:是容器启动阶段Spring提供的一个扩展点,主要对注册的BeanDefination进行一定程度上的修改与替换。
    例如类名、scope、属性、构造函数参数列表、依赖的bean、是否是单例类、是否是懒加载等,
    容器的启动阶段的最终产物就是注册到BeanDefinationRegistry中的一个个BeanDefination了,这就是Spring为Bean实例化所做的预热的工作。

    spring bean实例化之后,就开始注入属性,
    首先注入自定义的属性,比如标注@autowrite的这些属性,
    再调用各种Aware接口扩展方法,注入属性(spring特有的属性),
    比如BeanNameAware.setBeanName,设置Bean的ID或者Name;

    在这里插入图片描述

    a.实例化Bean
    容器通过获取BeanDefinition对象中的信息进行实例化。并且这一步仅仅是简单的实例化,并未进行依赖注入。

    对于BeanFactory容器,当客户向容器请求一个尚未初始化的bean时,或初始化bean的时候需要注入另一个尚未初始化的依赖时,容器就会调用createBean进行实例化。
    对于ApplicationContext容器,当容器启动结束后,便实例化所有的bean。

    实例化对象被包装在BeanWrapper对象中(可以认为是Bean的原生态),BeanWrapper提供了设置对象属性的接口,避免了使用反射机制设置属性。

    这里提到了4个组件:BeanFacotry\ApplicationContext\BeanDefinition\BeanWrapper

    b.设置对象属性(依赖注入)
    实例化后的对象被封装在BeanWrapper对象中,并且此时对象仍然是一个原生的状态,并没有进行依赖注入。
    紧接着,Spring根据BeanDefinition中的信息进行依赖注入。
    并且通过BeanWrapper提供的设置属性的接口完成依赖注入。

    c.注入Aware接口(给bean增加某种能力,申明是某种特殊的bean)
    Aware接口用于增强Bean能力容器需检测该对象是否实现了xxxAware接口,并将相关的xxxAware实例注入给bean。
    常见的Aware接口有:BeanNameAware\BeanFactoryAware\ApplicationContextAware至此,一个对象已经被正确构造。

    d.1.BeanPostProcessor(自定义处理,满足用户需求)
    经过上述几个步骤后,bean对象已经被正确构造,但如果你想要对象被使用前再进行一些自定义的处理,就可以通过BeanPostProcessor接口实现。 该接口提供了两个函数:

    postProcessBeforeInitialzation( Object bean, String beanName )
    当前正在初始化的bean对象会被传递进来,我们就可以对这个bean作任何处理。 这个函数会先于InitialzationBean执行,因此称为前置处理。所有Aware接口的注入就是在这一步完成的。

    postProcessAfterInitialzation( Object bean, String beanName )
    当前正在初始化的bean对象会被传递进来,我们就可以对这个bean作任何处理。 这个函数会在InitialzationBean完成后执行,因此称为后置处理。
    组件:BeanPostProcessor

    d.2.InitializingBean与init-method
    当BeanPostProcessor的前置处理完成后就会进入本阶段。 InitializingBean接口只有一个函数:afterPropertiesSet()这一阶段也可以在bean正式构造完成前增加我们自定义的逻辑,但它与前置处理不同,由于该函数并不会把当前bean对象传进来,因此在这一步没办法处理对象本身,只能增加一些额外的逻辑。
    若要使用它,我们需要让bean实现该接口,并把要增加的逻辑写在该函数中。然后Spring会在前置处理完成后检测当前bean是否实现了该接口,并执行afterPropertiesSet函数。
    当然,Spring为了降低对客户代码的侵入性,给bean的配置提供了init-method属性,该属性指定了在这一阶段需要执行的函数名。Spring便会在初始化阶段执行我们设置的函数。init-method本质上仍然使用了InitializingBean接口。

    e.DisposableBean和destroy-method
    和init-method一样,通过给destroy-method指定函数,就可以在bean销毁前执行指定的逻辑。

    关于Aware

    在设置属性阶段后,postProcessBeforeInitialization方法执行前,会执行很多Aware类型的接口,这种类型接口作用是加载资源到Spring容器中,Aware前面的名字就对应哪种资源,依次加载的是:

    BeanNameAware
    BeanClassLoaderAware
    BeanFactoryAware
    EnvironmentAware
    ResourceLoaderAware
    ApplicationEventPublisherAware
    ApplicationContextAware
    看到这里应该明白BeanFactory和ApplicationContext的区别了:
    BeanFactoryAware之前加载的资源都是公共的。BeanFactoryAware后面加载的资源都是ApplicationContext独有的。

    容器级扩展点(作用于所有bean):

    BeanFactoryPostProcessor接口:
    在循环初始化springbean之前,对BeanDefinition元数据做扩展处理
    InstantiationAwareBeanPostProcessor接口: 在对象实例化前后扩展,作用于所有bean
    BeanPostProcessor接口: 在对象初始化化前后扩展,作用于所有bean

    (2)、Bean扩展点(作用于单个bean):

    Aware接口: springBean实例化并且注入自定义属性之后 InitializingBean接口:
    springBean初始化时,执行构造方法结束,并且属性赋初始化值结束之后执行 DiposableBean接口:
    springBean销毁之前执行。

    (3)、Bean自身的方法

    包括了Bean本身调用的方法
    通过配置文件中的init-method和destroy-method指定的方法(或者用注解的方式)
    (4)、包括了AspectJWeavingEnabler, ConfigurationClassPostProcessor,
    CustomAutowireConfigurer等等非常有用的工厂后处理器接口的方法。
    工厂后处理器也是容器级的。在应用上下文装配配置文件之后立即调用。

    展开全文
  • Spring Bean 生命周期

    千次阅读 多人点赞 2020-09-24 14:02:10
    一、Spring核心模块介绍 1. Spring Core: Core封装包是框架的最基础部分,提供IOC和依赖注入特性。这里的基础概念是BeanFactory,它提供对Factory模式的经典实现来消除对程序性单例模式的需要,并真正地允许你...
  • 本篇文章主要介绍了浅谈Spring bean 生命周期验证,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • Spring bean 生命周期

    2020-01-05 17:43:34
    且关闭Spring   IOC容器时才会被调用 ,注意:该方法不能有参数 scope默认singleton 原因: 其中并无销毁方法。 改进: 输出结果可得 以下为其他内容: 1.bean的继承关系 ...
  • Spring Bean生命周期

    千次阅读 2019-07-09 20:19:57
    Spring Bean生命周期生命周期 生命周期 生命周期过程总概述: 通过构造方法或工厂方法创建bean对象——>为bean属性赋值——>调用 bean 的初始化方法,即init-method指定方法——>bean实例化完毕,可以使用...
  • 一个对象转为Bean并由Spring IOC管理的过程如下,即一个Bean生命周期如下 如图所示: 如果简单来讲,笼统概括的话就四步: 1.实例化 2.设置属性值 3.初始化 4.销毁 但是详细来说,会有很多细节需要注意,...
  • Spring Bean生命周期详解

    千次阅读 2020-04-18 23:06:58
    文章目录Spring bean生命周期13个环节阶段1:Bean元信息配置阶段阶段2:Bean元信息解析阶段阶段3:Spring Bean注册阶段 Spring bean生命周期13个环节 阶段1:Bean元信息配置阶段 阶段2:Bean元信息解析阶段 阶段3:...
  • 主要介绍了Spring bean生命周期配置过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • spring bean生命周期详解,源码分析

    千次阅读 2020-07-14 13:28:43
    目录如何获取beanClassPathXmlApplicationContext方法refresh源码分析finishBeanFactoryInitialization(beanFactory):spring bean的完整生命周期进阶版spring bean的完整生命周期 如何获取bean 首先,我们在代码中...
  • 了解 Spring 容器管理的 Spring Bean 生命周期,包括对 Spring 容器和 IoC 的理解。 同时了解 Spring bean 生命周期回调处理程序和后处理器。 Spring Framework 提供了几种回调方法来创建 bean 和一些方法来销毁 ...
  • Spring Bean生命周期.pdf

    2021-04-01 08:38:43
    Springbean生命周期
  • 主要给大家介绍了SpringBean生命周期和作用域及实现方式的相关资料,文中介绍的非常详细,对大家具有一定的参考价值,需要的朋友们下面来一起看看吧。
  • 一、Spring Bean的概念 Spring bean通常来说是指被Spring容器所管理的java对象;而spring容器就是负责实例化、配置和装配Spring bean; 二、Spring Bean容器 Spring Bean容器可以获取Spring Bean,通过BeanFacroty...
  • 目录 1 生命周期流程 2 Bean生命周期验证 1 生命周期流程 在spring中,从BeanFactory或ApplicationContext取得的实例为Singleton,也就是预设为每一个Bean的别名只能维持一...Spring Bean的完整生命周期从创建S
  • SpringBean生命周期简单版 单例对象在加载Spring配置文件的时候就创建出来了,非单例对象在每一次使用的时候通过getBean创建。 容器关闭之前,调用bean的销毁方法。 实例化bean对象(通过工厂),设置对象属性...
  • 3、Spring Bean生命周期

    2020-01-04 11:10:05
    Spring Bean生命周期只有四个阶段,每个阶段又有对应的扩展点,如下: 实例化 Instantiation 属性赋值 Populate 初始化 Initialization 销毁 Destruction 实例化 -> 属性赋值 -> 初始化 -> 销毁。 主要...
  • 关于spring bean生命周期,是深入学习spring的基础,也是难点,本篇文章将采用代码+图文结论的方式来阐述spring bean生命周期,本篇文章将阐述清楚下图。 一 项目结构及源码 1.程序目录结构 2....
  • 一文读懂 Spring Bean生命周期

    万次阅读 多人点赞 2021-07-05 23:02:56
    今天我们来说一说 Spring Bean生命周期,小伙伴们应该在面试中经常遇到,这是正常现象。因为 Spring Bean生命周期是除了 IoC、AOP 几个核心概念之外最重要概念,大家务必拿下。可 Spring 源代码又比较复杂,...
  • Spring bean生命周期demo

    2016-07-14 21:37:26
    Spring bean生命周期demo
  • 本篇文章主要介绍了详解Springbean生命周期回调方法,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • Bean生命周期概括起来有四个阶段: 实例化 -> 属性赋值 -> 初始化 -> 销毁 具体如下图所示: 1、实例化 实例化一个Bean,即new。 2、IOC依赖注入 按照Spring上下文对实例化的Bean进行配置。 - 3、...
  • Spring Bean生命周期,好像人的一生。。

    万次阅读 多人点赞 2022-03-15 11:43:41
    Spring原来是一个社会,Bean就是身不由己的“社会人”……

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 89,009
精华内容 35,603
关键字:

springbean的生命周期

spring 订阅