精华内容
下载资源
问答
  • Bean生命周期

    2021-03-17 21:22:43
    Bean生命周期Bean生命周期概述演示指定方法IOC容器启动BeanPostProcessor 应用 Bean 生命周期概述演示 bean -创建- 初始化- 销毁 容器管理bean生命周期 我们可以自定义初始化和销毁方法 初始化-对象创建完成并赋值好...

    Bean

    生命周期概述演示

    bean -创建- 初始化- 销毁
    容器管理bean生命周期
    我们可以自定义初始化和销毁方法
    初始化-对象创建完成并赋值好,初始化(单实例)
    销毁- 单实例:容器关闭时,多实例:手动

    指定方法

    1.指定初始化@Bean(initMethod = “init”, destroyMethod = “destroy”)
    2.继承InitializingBean, DisposableBean接口,实现方法,可以定义初始化和销毁逻辑
    3.方法上注解@PostConstruct, @PreDestroy
    4.BeanPostProcessor [接口],bean后置处理器,bean初始化前后工作
    postProcessBeforeInitialization初始化前;postProcessAfterInitialization初始化后

    IOC容器启动

    创建ioc,AnnotationConfigApplicationContext构造器 --> refresh方法初始化–>finishBeanFactoryInitialization初始化所有单实例bean–>preInstantiateSingletons–>getBean–doGetBean–>doCreateBean–>(populateBean赋值先)initializeBean–>前置处理applyBeanProcessBeforeInitialization+InitMethods执行初始化+后置处理applyBeanPostProcessAfterInitialization

    BeanPostProcessor 应用

    ApplicationContextAwareProcessor
    bean实现ApplicationContextAware 回调setApplicationContext方法,传入IOC容器对象
    BeanValidationPostProcessor 校验页面提交值,在初始化前后分别Override方法执行doValidate
    InitDestroyAnnotationBeanPostProcessor 处理注解 ,在applyBeanProcessBeforeInitialization里找到方法的注解,如init,调用反射,执行init
    AutoWiredAnnotationBeanPostProcessor @Autowired

    Aware接口

    回调函数,在创建对象的时候调用接口规定的方法注入组件(bean)
    例如ApplicationContextAware
    setApplicationContext(ApplicationContext applicationContext)传入容器,保存在对象中使用,为对象增加组件
    ApplicationContextAwareProcessor处理函数,继承自BeanPostProcessor

    展开全文
  • bean生命周期

    2019-05-27 09:03:46
    文章目录bean生命周期 bean生命周期 Spring中的IOC容器可以管理Bean生命周期,默认情况下,IOC容器初始化时便会把bean实例化。 通过以下实例过程来体会Bean的生命周期 1.Student类 package text; public class ...

    文章目录

    bean生命周期

    Spring中的IOC容器可以管理Bean生命周期,默认情况下,IOC容器初始化时便会把bean实例化。

    通过以下实例过程来体会Bean的生命周期
    1.Student类

    package text;
    
    public class Student {
    
    	private String name;
    	static{
    		System.out.println("静态代码块");
    	}
    	{
    		System.out.println("非静态代码块");
    	}
    	public Student() {
    		System.out.println("构造方法");
    	}
    	public void setName(String name) {
    		System.out.println("setter方法");//通过setter方法为对象中的属性设置初始值
    	}
    	public void init() {//这里方法名可以不叫init,只需要与application.xml中的init-method属性中的属性值相同即可
    		System.out.println("init方法");//由构造方法调用,故先执行构造方法再执行init()方法
    	}
    	public void destroy() {//同理,这里方法名可以不叫destroy,只需要与application.xml中的destroy-method属性中的属性值相同即可
    		System.out.println("destroy方法");//当容器正常关闭的时候执行
    	}
    }
    

    2.配置一个文件,这里命名为“application.xml”

    这里在Bean声明中设置init-method和destroy-method属性可以调用init()初始化和destroy()销毁方法
    
    <?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 class="text.Student" init-method="init" destroy-method="destroy">
    		<property name="name" value="tom"></property>
    	</bean>
    </beans>
    
    public class Test {
    
    	public static void main(String[] args) {
    		ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
    		applicationContext.close();
    	}
    }
    

    4.运行结果
    在这里插入图片描述
    5.得出结论
    从以上图片可以看出,按一下顺序执行
    ①静态代码块在类加载的时候执行
    ②非静态代码块在第一次创建对象的时候执行
    ③通过构造方法来创建Bean实例
    ④通过setter方法设置属性
    ⑤执行init初始化方法
    ⑥正常关闭后,执行destroy方法

    展开全文
  • Bean 生命周期

    2020-01-09 18:58:15
    Bean生命周期流程 1.实例化Bean 实例化Bean对于BeanFactory容器,当客户向容器请求一个尚未初始化的bean时,或初始化bean的时候需要注入另一个尚未初始化的依赖时,容器就会调用createBean进行实例化。 ...

    对于普通的Java对象,当new的时候创建对象,当它没有任何引用的时候被垃圾回收机制回收。而由Spring IoC容器托管的对象,它们的生命周期完全由容器控制。

    bean生命周期

    Bean生命周期流程

    1.实例化Bean

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

    对于ApplicationContext容器,当容器启动结束后,便实例化所有的bean。

    容器通过获取BeanDefinition对象中的信息进行实例化。并且这一步仅仅是简单的实例化,并未进行依赖注入。 实例化对象被包装在BeanWrapper对象中,BeanWrapper提供了设置对象属性的接口,从而避免了使用反射机制设置属性。

    2.设置对象属性(依赖注入)

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

    3.注入Aware接口

    紧接着,Spring会检测该对象是否实现了xxxAware接口,并将相关的xxxAware实例注入给bean。

    • 如果这个Bean实现了BeanNameAware接口,会调用它实现的setBeanName(String beanId)方法,此处传递的是Spring配置文件中Bean的ID
    • 如果这个Bean实现了BeanFactoryAware接口,会调用它实现的setBeanFactory(),传递的是Spring工厂本身(可以用这个方法获取到其他Bean)
    • 如果这个Bean实现了ApplicationContextAware接口,会调用setApplicationContext(ApplicationContext)方法,传入Spring上下文,ApplicationContext是BeanFactory的子接口,有更多的实现方法

    4.BeanPostProcessor

    当经过上述几个步骤后,bean对象已经被正确构造,但如果你想要对象被使用前再进行一些自定义的处理,就可以通过BeanPostProcessor接口实现。

    该接口提供了两个函数:

    • postProcessBeforeInitialzation( Object bean, String beanName )

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

    • postProcessAfterInitialzation( Object bean, String beanName )

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

    5.InitializingBean与init-method

    当BeanPostProcessor的前置处理完成后就会进入本阶段。

    InitializingBean接口只有一个函数:

    • afterPropertiesSet()

    这一阶段也可以在bean正式构造完成前增加我们自定义的逻辑,但它与前置处理不同,由于该函数并不会把当前bean对象传进来,因此在这一步没办法处理对象本身,只能增加一些额外的逻辑。 若要使用它,我们需要让bean实现该接口,并把要增加的逻辑写在该函数中。然后Spring会在前置处理完成后检测当前bean是否实现了该接口,并执行afterPropertiesSet函数。

    当然,Spring为了降低对客户代码的侵入性,给bean的配置提供了init-method属性,该属性指定了在这一阶段需要执行的函数名。Spring便会在初始化阶段执行我们设置的函数。init-method本质上仍然使用了InitializingBean接口。

    6. DisposableBean和destroy-method

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

    代码示例

    注解方式

    package com.easy.bean;
    
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.stereotype.Component;
    
    import javax.annotation.PostConstruct;
    import javax.annotation.PreDestroy;
    
    @Component
    @Slf4j
    public class AnnotationBean {
        @PostConstruct
        public void start() {
            log.info("AnnotationBean 开始初始化");
        }
    
        @PreDestroy
        public void destroy() {
            log.info("AnnotationBean 开始销毁");
        }
    }

    InitializingBean, DisposableBean 接口

    package com.easy.bean;
    
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.DisposableBean;
    import org.springframework.beans.factory.InitializingBean;
    import org.springframework.stereotype.Service;
    
    @Service
    @Slf4j
    public class SpringLifeCycleService implements InitializingBean, DisposableBean {
    
        @Override
        public void afterPropertiesSet() throws Exception {
            log.info("SpringLifeCycleService 开始");
        }
    
        @Override
        public void destroy() throws Exception {
            log.info("SpringLifeCycleService 销毁");
        }
    }

    自定义初始化和销毁方法

    package com.easy.bean;
    
    import lombok.extern.slf4j.Slf4j;
    
    @Slf4j
    public class SpringLifeCycle {
        public void start() {
            log.info("SpringLifeCycle 开始初始化");
        }
    
        public void destroy() {
            log.info("SpringLifeCycle 开始销毁");
        }
    }

    配置添加

    package com.easy.bean;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    @Configuration
    public class LifeCycleConfig {
        @Bean(initMethod = "start", destroyMethod = "destroy")
        public SpringLifeCycle create() {
            SpringLifeCycle springLifeCycle = new SpringLifeCycle();
            return springLifeCycle;
        }
    }

    或者通过xml配置如下

    <bean class="com.easy.bean.SpringLifeCycle" init-method="start" destroy-method="destroy"></bean>

    实现 xxxAware 接口

    package com.easy.bean;
    
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.BeansException;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    import org.springframework.stereotype.Component;
    
    @Component
    @Slf4j
    public class SpringLifeCycleAware implements ApplicationContextAware {
    
        private ApplicationContext applicationContext;
    
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            this.applicationContext = applicationContext;
            log.info("SpringLifeCycleAware 开始");
        }
    }

    这样在 springLifeCycleAware 这个 bean 初始化会就会调用 setApplicationContext 方法,并可以获得 applicationContext 对象。

    BeanPostProcessor 增强处理器

    实现 BeanPostProcessor 接口,Spring 中所有 bean 在做初始化时都会调用该接口中的两个方法,可以用于对一些特殊的 bean 进行处理

    package com.easy.bean;
    
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.config.BeanPostProcessor;
    import org.springframework.stereotype.Component;
    
    @Component
    @Slf4j
    public class SpringLifeCycleProcessor implements BeanPostProcessor {
    
        /**
         * 预初始化 初始化之前调用
         *
         * @param bean
         * @param beanName
         * @return
         * @throws BeansException
         */
        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            if ("annotationBean".equals(beanName)) {
                log.info("SpringLifeCycleProcessor 开始初始化 beanName={}", beanName);
            }
            return bean;
        }
    
        /**
         * 后初始化  bean 初始化完成调用
         *
         * @param bean
         * @param beanName
         * @return
         * @throws BeansException
         */
        @Override
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
            if ("annotationBean".equals(beanName)) {
                log.info("SpringLifeCycleProcessor 初始化结束 beanName={}", beanName);
            }
            return bean;
        }
    }

    运行示例查看控制台输出

    2020-01-09 17:46:37.022  INFO 9544 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
    2020-01-09 17:46:37.023  INFO 9544 --- [           main] o.s.web.context.ContextLoader            : Root WebApplicationContext: initialization completed in 1642 ms
    2020-01-09 17:46:37.081  INFO 9544 --- [           main] com.easy.bean.SpringLifeCycleProcessor   : SpringLifeCycleProcessor 开始初始化 beanName=annotationBean
    2020-01-09 17:46:37.089  INFO 9544 --- [           main] com.easy.bean.AnnotationBean             : AnnotationBean 开始初始化
    2020-01-09 17:46:37.089  INFO 9544 --- [           main] com.easy.bean.SpringLifeCycleProcessor   : SpringLifeCycleProcessor 初始化结束 beanName=annotationBean
    2020-01-09 17:46:37.090  INFO 9544 --- [           main] com.easy.bean.SpringLifeCycleAware       : SpringLifeCycleAware 开始
    2020-01-09 17:46:37.091  INFO 9544 --- [           main] com.easy.bean.SpringLifeCycleService     : SpringLifeCycleService 开始
    2020-01-09 17:46:37.093  INFO 9544 --- [           main] com.easy.bean.SpringLifeCycle            : SpringLifeCycle 开始初始化
    2020-01-09 17:46:37.279  INFO 9544 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'applicationTaskExecutor'

    资料

    Spring Boot、Cloud 学习项目

    展开全文
  • bean 生命周期Spring 只帮我们管理单例模式 Bean 的完整生命周期,对于 prototype 的 bean ,Spring 在创建好交给使用者之后则不会再管理后续的生命周期。注解方式在 bean 初始化时会经历几个阶段,首先可以使用注解...

    bean 生命周期

    624bea671bef24fa05b75bedc07ea970.png
    Spring 只帮我们管理单例模式 Bean 的完整生命周期,对于 prototype 的 bean ,Spring 在创建好交给使用者之后则不会再管理后续的生命周期。

    注解方式

    在 bean 初始化时会经历几个阶段,首先可以使用注解@PostConstruct,@PreDestroy来在 bean 的创建和销毁阶段进行调用:

    @Component
    public class AnnotationBean {
        private final static Logger LOGGER = LoggerFactory.getLogger(AnnotationBean.class);
        @PostConstruct
        public void start(){
            LOGGER.info("AnnotationBean start");
        }
        @PreDestroy
        public void destroy(){
            LOGGER.info("AnnotationBean destroy");
        }
    }

    InitializingBean, DisposableBean 接口

    还可以实现InitializingBean,DisposableBean这两个接口,也是在初始化以及销毁阶段调用:

    @Service
    public class SpringLifeCycleService implements InitializingBean,DisposableBean{
        private final static Logger LOGGER = LoggerFactory.getLogger(SpringLifeCycleService.class);
        @Override
        public void afterPropertiesSet() {
            LOGGER.info("SpringLifeCycleService start");
        }
        @Override
        public void destroy() {
            LOGGER.info("SpringLifeCycleService destroy");
        }
    }

    自定义初始化和销毁方法

    也可以自定义方法用于在初始化、销毁阶段调用:

    @Configuration
    public class LifeCycleConfig {
        @Bean(initMethod = "start", destroyMethod = "destroy")
        public SpringLifeCycle create(){
            SpringLifeCycle springLifeCycle = new SpringLifeCycle() ;
            return springLifeCycle ;
        }
    }
    public class SpringLifeCycle{
        private final static Logger LOGGER = LoggerFactory.getLogger(SpringLifeCycle.class);
        public void start(){
            LOGGER.info("SpringLifeCycle start");
        }
        public void destroy(){
            LOGGER.info("SpringLifeCycle destroy");
        }
    }

    以上是在 SpringBoot 中可以这样配置,如果是原始的基于 XML 也是可以使用:

    <bean class="com.crossoverjie.spring.SpringLifeCycle" init-method="start" 
      destroy-method="destroy" />

    来达到同样的效果。

    实现 *Aware 接口

    *Aware 接口可以用于在初始化 bean 时获得 Spring 中的一些对象,如获取 Spring 上下文等。

    @Component
    public class SpringLifeCycleAware implements ApplicationContextAware {
        private final static Logger LOGGER = LoggerFactory.getLogger(SpringLifeCycleAware.class);
        private ApplicationContext applicationContext ;
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) {
            this.applicationContext = applicationContext ;
            LOGGER.info("SpringLifeCycleAware start");
        }
    }

    这样在 springLifeCycleAware 这个 bean 初始化会就会调用 setApplicationContext 方法,并可以获得 applicationContext 对象。

    BeanPostProcessor 增强处理器

    实现 BeanPostProcessor 接口,Spring 中所有 bean 在做初始化时都会调用该接口中的两个方法,可定义一个注解,然后在这个方法里拦截所有该注解,做一些特殊的处理。

    ioc

    fd8d91a4e244b01178c0f52bad02a88e.png

    ioc 类图

    056f60e12f33501e8eaf8748f51236e9.png
    展开全文
  • Spring Bean生命周期.pdf

    2021-04-01 08:38:43
    Springbean生命周期
  • spring bean生命周期

    2017-07-27 01:01:00
    bean生命周期
  • 掌握bean生命周期的各个阶段,初始化和销毁回调方法。我们将学习使用XML配置和注释配置来控制bean生命周期事件。Bean的声明周期当容器启动时–-需要基于Java或XML bean定义实例化Spring bean。还需要执行一些初始化...
  • IOC容器中bean的生命周期,iocbean生命周期 一、Bean的生命周期 Spring IOC容器可以管理Bean的生命周期,允许在Bean生命周期的特定点执行定制的任务。 Spring IOC容器对Bean的生命周期进行管理的过程...
  • Spring Bean生命周期

    2019-03-10 12:02:03
    Spring Bean生命周期 今天我们将研究Spring Bean生命周期。Spring Bean是任何Spring应用程序中最重要的部分。SpringApplicationContext负责初始化spring bean配置文件中定义的Spring Beans。 目录[隐藏] 1 ...
  • Spring bean 生命周期

    2019-05-30 13:43:36
    Spring bean 生命周期bean生命周期流程图bean实例生命周期的执行过程如下不考虑这些接口时,的生命周期bean的作用域 bean生命周期流程图 bean实例生命周期的执行过程如下 对bean实例化创建bean; 通过反射调用set...
  • spring bean 生命周期

    2021-01-12 17:24:30
    spring bean 生命周期
  • Spring的Bean生命周期

    2018-05-31 00:05:04
    Bean生命周期
  • Spring bean生命周期

    2020-01-30 20:45:04
    我们将学习使用XML配置以及注释配置来控制bean生命周期事件。 目录 1. Bean生命周期 2.生命周期回调方法 1.Bean的生命周期 当容器启动时–需要基于Java或XML bean定义实例化Spring bean。可能还需要执行一些...
  • Spring bean生命周期demo

    2016-07-14 21:37:26
    Spring bean生命周期demo
  • Spring Bean 生命周期

    2021-03-15 21:11:34
    Spring Bean 生命周期 前言 Spring Bean生命周期在整个 Spring 中占有很重要的位置,掌握这些可以加深对 Spring 的理解。 首先看下生命周期图: 再谈生命周期之前有一点需要先明确: Spring 只帮我们管理单例...
  • 缘由在之前我解析Spring IoC原理的文章,我顺带...整体阶段Spring中Bean的生命周期主要分为以下几个大阶段:实例化属性赋值初始化使用中销毁下面分阶段详细讲解下实例化实例化是Bean生命周期的第一个阶段,在这一阶...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,390
精华内容 4,956
关键字:

bean生命周期