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

    千次阅读 2016-02-20 11:43:04
    Bean生命周期 基本概述  生命周期一直是很重要的内容,从以前Java对象、Servlet的生命周期可以看出,只有理解了其生命周期,才能知道应该在哪阶段完成哪阶段的事。Bean被载入到容器的时候,它的生命周期就...

    Bean生命周期

    基本概述

        生命周期一直是很重要的内容,从以前Java对象、Servlet的生命周期可以看出,只有理解了其生命周期,才能知道应该在哪阶段完成哪阶段的事。Bean被载入到容器的时候,它的生命周期就开始了。

     

     

    Bean生命周期

    Bean在应用上下文的生命周期

    原理图


    详细步骤

    1实例化(当程序加载applicationContext.xml文件),把bean(前提是scope=singleton)实例化到内存

    2调用该BeansetXxx()方法,设置属性。

    3如果实现了bean名字关注接口(BeanNameAware),则可以通过setBeanName获取id

    4如果实现了bean工厂关注接口(BeanFactoryAware),则可以获取BeanFactory

    5如果实现了ApplicationContextAware接口,则可以获得ApplicationContext

    6如果bean和一个后置处理器关联,则会自动去调用postProcessBeforeInitialization()方法。

    7如果实现InitializingBean接口,则会调用afterPropertiesSet方法。

    8如果配置<bean init-method=”init” /> 则可以在bean自定义初始化方法。

    9如果bean和一个后置处理器关联,则会自动去调用postProcessAfterInitialization()方法。

    10使用bean

    11、容器关闭。

    12、可以通过实现DisposableBean接口来调用destory()方法。

    13、可以在<bean destory-method=”fun1”/> 调用自定义的销毁方法。

    PS:实际开发中的流程往往没这么复杂,一般是1->2->6->9->10->11

     

    BeanBean工厂的生命周期

        BeanBean工厂的生命周期和在应用上下文的生命周期是不一样的。因为和应用上下文是无关的,所以没有应用上下文中的第5步、第6步和第9步。

     

    原理图


    案例

    Spring配置文件

    <?xml version="1.0" encoding="utf-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    	xmlns:aop="http://www.springframework.org/schema/aop"
    	xmlns:tx="http://www.springframework.org/schema/tx"
    	xsi:schemaLocation="
    			http://www.springframework.org/schema/beans 
    			http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
    			http://www.springframework.org/schema/aop 
    			http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
    			http://www.springframework.org/schema/tx 
    			http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
    	<!-- 在容器文件中配置bean(service/dao/domain/action/数据源) -->
    	<bean id="personService" init-method="init" destroy-method="myDestory" class="com.pc.beanlife.PersonService">
    		<!-- 这里注入属性,前提是有setName才能成功 -->
    		<property name="name" value="zs" />
    	</bean>
    	<!-- 配置后置处理器(类似filter) -->
    	<bean id="myBeanPostProcesseor" class="com.pc.beanlife.MyBeanPostProcesseor" />
    </beans>

    Bean类文件

    package com.pc.beanlife;
    
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.BeanFactory;
    import org.springframework.beans.factory.BeanFactoryAware;
    import org.springframework.beans.factory.BeanNameAware;
    import org.springframework.beans.factory.DisposableBean;
    import org.springframework.beans.factory.InitializingBean;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    /**
     * 
     * @author Switch
     * @function Bean类
     * @description
     *
     */
    public class PersonService implements BeanNameAware,BeanFactoryAware,ApplicationContextAware,InitializingBean,DisposableBean{
    	private String name;
    	
    	public PersonService() {
    		System.out.println("无参构造方法被调用");
    	}
    	
    	public PersonService(String name) {
    		System.out.println("有参构造方法被调用");
    	}
    	
    	public void printOk(){
    		System.out.println(name + " is Ok");
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		System.out.println("调用set方法设置属性");
    		this.name = name;
    	}
    
    	// 该方法可以给name表示正被实例化的Bean的id
    	@Override
    	public void setBeanName(String name) {
    		// TODO Auto-generated method stub
    		System.out.println("setBeanName 被调用,值是" + name);
    	}
    
    	// 该方法可以传递beanFactory
    	@Override
    	public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
    		// TODO Auto-generated method stub
    		System.out.println("setBeanFactory " + beanFactory);
    		
    	}
    
    	// 该方法可以设置上下文
    	@Override
    	public void setApplicationContext(ApplicationContext applicationContext)
    			throws BeansException {
    		// TODO Auto-generated method stub
    		System.out.println("setApplicationContext " + applicationContext);
    	}
    
    	// 该方法可以在InitializingBean使用
    	@Override
    	public void afterPropertiesSet() throws Exception {
    		// TODO Auto-generated method stub
    		System.out.println("afterPropertiesSet");
    	}
    	
    	// 自定义的初始化方法
    	public void init() {
    		System.out.println("调用自定义的初始化方法");
    	}
    
    	// 可以在这关闭数据连接,socket,文件流,释放资源等等。。。
    	@Override
    	public void destroy() throws Exception {
    		// TODO Auto-generated method stub
    		System.out.println("调用destroy()");
    	}
    	
    	// 自定义我们的销毁方法
    	public void myDestory() {
    		System.out.println("调用自定义的销毁方法");
    	}
    }

    后置处理器文件

    package com.pc.beanlife;
    
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.config.BeanPostProcessor;
    /**
     * 
     * @author Switch
     * @function 后置处理器,相当于Web开发中的过滤器
     * @description 当Bean创建完毕,初始化之前时会调用Before方法,初始化之后会调用After方法
     *
     */
    public class MyBeanPostProcesseor implements BeanPostProcessor {
    	// 后置处理之后的过滤
    	@Override
    	public Object postProcessBeforeInitialization(Object bean, String beanName)
    			throws BeansException {
    		// TODO Auto-generated method stub
    		System.out.println("postProcessBeforeInitialization方法被调用");
    		return bean;
    	}
    
    	// 后置处理之前的过滤
    	@Override
    	public Object postProcessAfterInitialization(Object bean, String beanName)
    			throws BeansException {
    		// TODO Auto-generated method stub
    		System.out.println("postProcessAfterInitialization方法被调用");
    		return bean;
    	}
    }

    测试文件

    package com.pc.beanlife;
    
    import org.springframework.beans.factory.BeanFactory;
    import org.springframework.beans.factory.xml.XmlBeanFactory;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.springframework.core.io.ClassPathResource;
    /**
     * 
     * @author Switch
     * @function 测试类
     * @description
     *
     */
    public class Test {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		// 通过ApplicationContext加载Bean
    		System.out.println("------------在ApplicationContext中Bean的生命周期------------");
    		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("com/pc/beanlife/beans.xml");
    		// 获取Bean
    		PersonService personService = (PersonService) applicationContext.getBean("personService");
    		personService.printOk();
    		
    		// 通过BeanFactory加载Bean
    		System.out.println("------------在BeanFactory中Bean的生命周期------------");
    		BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("com/pc/beanlife/beans.xml"));
    		PersonService personService2 = (PersonService) beanFactory.getBean("personService");
    		personService2.printOk();
    	}
    }

    日志文件

    ------------在ApplicationContext中Bean的生命周期------------
    无参构造方法被调用
    调用set方法设置属性
    setBeanName 被调用,值是personService
    setBeanFactory org.springframework.beans.factory.support.DefaultListableBeanFactory@1f8b81e3: defining beans [personService,myBeanPostProcesseor]; 
    root of factory hierarchy
    setApplicationContext org.springframework.context.support.ClassPathXmlApplicationContext@771c8a71: display name [org.springframework.context.support.
    ClassPathXmlApplicationContext@771c8a71]; startup date [Sat Feb 20 11:34:05 CST 2016]; root of context hierarchy
    postProcessBeforeInitialization方法被调用
    afterPropertiesSet
    调用自定义的初始化方法
    postProcessAfterInitialization方法被调用
    zs is Ok
    ------------在BeanFactory中Bean的生命周期------------
    无参构造方法被调用
    调用set方法设置属性
    setBeanName 被调用,值是personService
    setBeanFactory org.springframework.beans.factory.xml.XmlBeanFactory@6c4fc156: defining beans [personService,myBeanPostProcesseor]; root of factory 
    hierarchy
    afterPropertiesSet
    调用自定义的初始化方法
    zs is Ok


    PS:通过上面所示Log信息,可以看出BeanApplicationContextBeanFactory中的生命周期是不相同的。


    展开全文
  • 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生命周期--综述

    千次阅读 2020-06-03 00:02:17
    其他网址 ...spring bean 生命周期事件-一尾思念的鱼-51CTO博客 另见《精通Spring4.x 企业应用开发实战》=>4.5 Bean生命周期 BeanFactory中Bean生命周期 ApplicationContext中Bean生命周期

    Bean生命周期

    其他网址

    通过源码看Bean的创建过程
    spring bean 生命周期事件-一尾思念的鱼-51CTO博客

    BeanFactory中Bean的生命周期

    其他网址

    《精通Spring4.x 企业应用开发实战》=> 4.5.1 BeanFactory中Bean的生命周期
    《深入浅出SpringBoot2.x》=> 3.4 生命周期

    生命周期流程图

    大致流程

    1. 应用启动的时候检查需要被Spring管理的bean;
    2. 实例化、设置属性值
    3. 根据实现的接口,依次设置beanName,BeanFactory,ApplicationContext应用上下文。
    4. 根据实现的接口,依次调用初始化前方法,自定义初始化方法,初始化后方法。
    5. bean已经可以用了,存活直到上下文也被销毁。
    6. 销毁的时候调用destroy方法和自定义的销毁方法。

    ApplicationContext中Bean的生命周期

    其他网址

    另见:《精通Spring4.x 企业应用开发实战》=> 4.5.2 ApplicationContext中Bean的生命周期

    scope

    其他网址

    Spring中bean的scope详解 - HelloSUN - 博客园

    springbeanscope的几种类型_bruce_sky的专栏-CSDN博客_bean的scope有几种类型

    另见:《深入浅出Spring Boot 2.x》=> 3.7 Bean的作用域      《跟我学Spring3》=> 3.4 Bean的作用域

    简介

            Spring容器最初提供了两种bean的scope类型:singleton和prototype。Spring2.0以后,又引入了另外三种scope类型:request、session、application和global session,这三种只能在web 应用中才可以使用。

    作用域类型 适用范围 描述
    singleton 所有Spring应用

            Spring的默认scope。

            在Spring的IoC容器中只存在一个对象实例,所有该对象的引用都共享这个实例。

            一般情况下,无状态的bean使用该scope。

    prototype 所有Spring应用

            每次对该bean的请求都会创建一个新的实例。

            一般情况下,有状态的bean使用该scope。

    request Spring Web应用         每次http请求将会有各自的bean实例,类似于prototype。
    session Spring Web应用         每个http session对应一个bean实例。
    application Spring Web应用         Web工程生命周期。
    global session Spring Web应用

            global session作用域类似于标准的HTTP Session作用域,不过它仅仅在基于portlet的web应用中才有意义。如果在非 portlet 环境将视为 session 作用域。

           实践中基本用不到。

    用法

    问:scope类型什么时候声明为singleton,何时声明为prototype?

    无状态的bean使用该scope。有状态的bean使用prototype。有状态和无状态会话bean的本质区别是它们的生命周期。

    有状态:bean保持了用户的信息,即“有状态”。

    无状态 :bean一旦实例化就被加进会话池中,各个用户都可以共用。由于没有特定的用户,那么也就不能保持某一用户的状态,所以叫无状态bean。但无状态会话bean 并非没有状态,如果它有自己的属性(变量),那么这些变量就会受到所有调用它的用户的影响,这是在实际应用中必须注意的。

    在ssh2 项目中 , struts2的action交由spring管理的时候 ,spring默认是singleton的 ,而struts2的action显然是有状态的 ,所以必须显示设置为 scope=“prototype”;
    但是对那些Dao的实现类推介scope=“singleton” ,因为这些类没有状态,用singleton只需维护一个实例,显然性能高一些。

    ③比较:

    用singleton 的性能要高一些 ,因为只有一个实例;

    ④实际应用举例:

    之前在开发过程中遇到了一个问题,当request发起下一个请求的时候,action中的属性值并没有清除,而是继续采用上次使用过的参数值进行查询并响应,导致数据查询不真实或失败。对此,有同事告诉我说,需要在spring配置文件的bean中添加属性scope=prototype。结果还真的有用。

    详解

    singleton

    当一个bean的作用域设置为singleton, 那么Spring IOC容器中只会存在一个共享的bean实例,并且所有对bean的请求,只要id与该bean定义相匹配,则只会返回bean的同一实例。换言之,当把 一个bean定义设置为singleton作用域时,Spring IOC容器只会创建该bean定义的唯一实例。这个单一实例会被存储到单例缓存(singleton cache)中,并且所有针对该bean的后续请求和引用都 将返回被缓存的对象实例,这里要注意的是singleton作用域和GOF设计模式中的单例是完全不同的,单例设计模式表示一个ClassLoader中 只有一个class存在,而这里的singleton则表示一个容器对应一个bean,也就是说当一个bean被标识为singleton时 候,spring的IOC容器中只会存在一个该bean。

    配置示例

    <bean id="role" class="spring.chapter2.maryGame.Role" scope="singleton"/> 

    或者

    <bean id="role" class="spring.chapter2.maryGame.Role" singleton="true"/>

    或者 

    @Scope("singleton")

    或者

    @Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)

    prototype

            prototype作用域部署的bean,每一次请求(将其注入到另一个bean中,或者以程序的方式调用容器的getBean()方法)都会产生一个新的bean实例,相当与一个new的操作,对于prototype作用域的bean,有一点非常重要,那就是Spring不能对一个prototype bean的整个生命周期负责,容器在初始化、配置、装饰或者是装配完一个prototype实例后,将它交给客户端,随后就对该prototype实例不闻不问了。不管何种作用域,容器都会调用所有对象的初始化生命周期回调方法,而对prototype而言,任何配置好的析构生命周期回调方法都将不会被调用。 清除prototype作用域的对象并释放任何prototype bean所持有的昂贵资源,都是客户端代码的职责。(让Spring容器释放被singleton作用域bean占用资源的一种可行方式是,通过使用 bean的后置处理器,该处理器持有要被清除的bean的引用。)

    配置实例:

    <bean id="role" class="spring.chapter2.maryGame.Role" scope="prototype"/>
    

    或者

    <beanid="role" class="spring.chapter2.maryGame.Role" singleton="false"/>

    或者

    @Scope("prototype")

    或者

    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)

    request

    request表示该针对每一次HTTP请求都会产生一个新的bean,同时该bean仅在当前HTTP request内有效,配置实例:request、session、global session使用的时候首先要在初始化web的web.xml中做如下配置:如果你使用的是Servlet 2.4及以上的web容器,那么你仅需要在web应用的XML声明文件web.xml中增加下述ContextListener即可:

     <web-app>
       ...
      <listener>
    <listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>
      </listener>
       ...
    </web-app>

    如果是Servlet2.4以前的web容器,那么你要使用一个javax.servlet.Filter的实现:

    <web-app>
     ..
     <filter> 
        <filter-name>requestContextFilter</filter-name> 
        <filter-class>org.springframework.web.filter.RequestContextFilter</filter-class>
     </filter> 
     <filter-mapping> 
        <filter-name>requestContextFilter</filter-name> 
        <url-pattern>/*</url-pattern>
     </filter-mapping>
       ...
    </web-app>

    接着既可以配置bean的作用域了:

    <bean id="role" class="spring.chapter2.maryGame.Role" scope="request"/>

    或者

    @Scope(WebApplicationContext.SCOPE_REQUEST)
    

    session

    session作用域表示该针对每一次HTTP请求都会产生一个新的bean,同时该bean仅在当前HTTP session内有效,配置实例:配置实例:和request配置实例的前提一样,配置好web启动文件就可以如下配置:

    <bean id="role" class="spring.chapter2.maryGame.Role" scope="session"/>

    或者

    @Scope(WebApplicationContext.SCOPE_SESSION)
    

    application

    application作用域表示该针对整个web项目生命周期:

    <bean id="role" class="spring.chapter2.maryGame.Role" scope="application"/>

    或者

    @Scope(WebApplicationContext.SCOPE_APPLICATION)
    

    global session

    global session作用域类似于标准的HTTP Session作用域,不过它仅仅在基于portlet的web应用中才有意义。Portlet规范定义了全局Session的概念,它被所有构成某个 portlet web应用的各种不同的portlet所共享。在global session作用域中定义的bean被限定于全局portlet Session的生命周期范围内。如果你在web中使用global session作用域来标识bean,那么web会自动当成session类型来使用。配置实例:和request配置实例的前提一样,配置好web启动文件就可以如下配置:

    <bean id="role" class="spring.chapter2.maryGame.Role" scope="global session"/>

    展开全文
  • Spring Bean生命周期

    2018-04-23 18:51:34
    spring 的两大核心,IOC与AOP,IOC主要用来管理bean的依赖,耦合代码,但是spring的bean的生命周期也是需要深入理解的,bean...Spring Bean生命周期 关于bean的生命周期大致分为三个类型: - bean自身的方法 ...

    spring 的两大核心,IOC与AOP,IOC主要用来管理bean的依赖,耦合代码,但是spring的bean的生命周期也是需要深入理解的,bean交给spring管理了,但是项目中难免会要在bean加载或者销毁的时候对bean做一些操作,所以更需要对bean的生命周期更深入的了解。

    Spring Bean生命周期

    关于bean的生命周期大致分为三个类型:

    • bean自身的方法
      主要配置文件的init-method和destroy-method配置的方法,以及bean对象自己调用的方法
    • bean级生命周期接口方法
      主要调用实现的一些接口方法
      InitializingBean,BeanNameAware,BeanFactoryAware,ApplicationContextAware,DisposableBean
    • 容器级生命周期接口方法
      主要调用后置处理器实现中重写的方法

    通过代码校验bean生命周期中执行各个方法的顺序

    定义一个测试类,实现bean级生命周期的接口。

    public class SpringTest implements InitializingBean ,BeanNameAware,BeanFactoryAware,ApplicationContextAware,DisposableBean{
    	
    	public void initMethod(){
    		System.out.println("执行配置文件中的init-method方法");
    	}
    	
    	public SpringTest(){
    		System.out.println("执行测试类的初始化方法");
    	}
    
    	@Override
    	public void afterPropertiesSet() throws Exception {
    		System.out.println("执行InitializingBean的afterProperties方法");
    	}
    
    	@Override
    	public void setBeanName(String name) {
    		System.out.println("执行BeanNameAware的setbeanName方法"+name);
    	}
    
    	@Override
    	public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
    		System.out.println("执行BeanFactoryAware方法");
    	}
    
    	public void testMethod() {
    		System.out.println("执行测试类自己的方法");
    		
    	}
    
    	@Override
    	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    		System.out.println("执行测试类的ApplicationContextAware方法");
    	}
    
    	@Override
    	public void destroy() throws Exception {
    		System.out.println("执行销毁方法");
    		
    	}
    	
    	public void destoryMethod(){
    		System.out.println("执行销毁配置文件的方法");
    	}
    }
    
    

    定义一个后置处理器

    public class MyBeanPostProcessor implements BeanPostProcessor {
    
    	@Override
    	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    		System.out.println("后置处理器在init之后执行");
    		return bean;
    	}
    	
    	@Override
    	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    		System.out.println("后置处理器在init之前执行");
    		return bean;
    	}
    
    }
    

    xml中配置bean以及后置处理器

    <bean id="myBeanPostProcessor" class="com.springmvc.MyBeanPostProcessor"></bean>
    <bean id="springTest" class="com.springmvc.SpringTest" init-method="initMethod" destroy-method="destoryMethod"></bean>
    

    定义一个main方法初始化容器,获取bean,然后销毁容器

    public static void main(String[] args) {
    		ApplicationContext context = new  ClassPathXmlApplicationContext("spring.xml");
    		SpringTest test = (SpringTest) context.getBean("springTest");
    		test.testMethod();
    		//销毁容器
    		((ClassPathXmlApplicationContext)context).registerShutdownHook();
    	}
    

    执行之后打印信息如下:
    打印信息

    根据如上打印信息,可以知道Spring Bean的生命周期:
    1.初始化bean,调用构造方法
    2.如果实现了BeanNameAware接口,调用其setBeanName方法
    3.如果实现了BeanFactoryAware接口,调用其setBeanFactory方法
    4.如果实现了ApplicationContextAware,调用其setApplicationContext方法
    5.如果配置了后置处理器,调用其postProcessBeforeInitialization方法
    6.如果实现了InitializingBean调用其afterPropertiesSet方法
    7.如果xml中配置了init方法,调用init方法
    8.如果配置了后置处理器,调用其postProcessAfterInitialization方法
    9.调用bean的自己的方法
    10销毁的时候如果实现了DisDisposableBean,则调用其destroy方法
    11如果xml中配置了的destroy方法,调用其destroy方法

    关于bean的生命周期就是以上的几个步骤,需要具体做的操作,可以根据具体的业务需求来修改bean或者context的一些属性,但是项目中一般情况是不需要修改的

    展开全文
  • IOC容器中bean的生命周期,iocbean生命周期 一、Bean的生命周期 Spring IOC容器可以管理Bean的生命周期,允许在Bean生命周期的特定点执行定制的任务。 Spring IOC容器对Bean的生命周期进行管理的过程...
  • Spring Bean生命周期详解

    万次阅读 多人点赞 2016-08-12 17:40:08
    Spring Bean生命周期详解
  • SpringBean生命周期

    2019-12-10 00:23:39
    Spring 容器中 Bean生命周期流程如图 1 所示。 Bean 生命周期的整个执行过程描述如下。 1)根据配置情况调用 Bean 构造方法或工厂方法实例化 Bean。 2)利用依赖注入完成 Bean 中所有属性值的配置注入。 3)...
  • SpringBean生命周期详解

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

    千次阅读 2018-05-01 14:12:46
    Spring Bean生命周期理解 Spring Bean生命周期理解 BeanFactory接口是Spring的首要核心接口,要学习Spring必须对此接口深度理解。在阅读此接口源码的时候,刚好发现了接口文档对应的就是SpringBean的生命周期...
  • Spring Bean 生命周期

    2018-10-19 11:36:10
    Spring Bean 生命周期 前言 Spring Bean生命周期在整个 Spring 中占有很重要的位置,掌握这些可以加深对 Spring 的理解。 首先看下生命周期图: 再谈生命周期之前有一点需要先明确: Spring 只帮我们管理...
  • spring管理bean生命周期

    2016-06-03 13:58:29
    Spring IOC容器可以管理Bean的生命周期,Spring允许在Bean生命周期的特定点执行定制的任务。 Spring IOC容器对Bean的生命周期进行管理的过程: 1.通过构造器或工厂方法创建Bean实例 2.为Bean的属性设置值和对...
  • spring bean生命周期spring bean生命周期之单例spring bean生命周期之原型(prototype)spring bean生命周期之具有原型bean依赖单例beanspring bean之Request, session, application,以及WebSocket生命周期spring bean...
  • SpringBoot Bean生命周期

    2020-05-12 15:07:17
    首先上一张自制的自认为比较全的Spring Bean生命周期流程图: 测试代码: 测试bean @Data public class BeanLifeCycle implements InitializingBean, DisposableBean, BeanFactoryAware, BeanNameAware { ...
  • 文章目录Bean生命周期概述Demo Bean生命周期概述 说到Spring Bean的生命周期,其实就是探究Spring Bean实例化经历哪些步骤了 本篇博文先给个整体的解读,下文将从源码上来探究Spring Bean的生命周期过程。 Demo ...
  • Spring bean 生命周期管理

    千次阅读 2016-02-08 21:20:06
    Spring bean 生命周期管理    For a bean to get into a usable state after instantiation, it needs to perform some initialization. Likewise, some clean up may be necessary when the bean is no lon
  • spring bean生命周期

    2014-06-03 20:50:21
    Spring IOC容器可以管理Bean的生命周期,Spring允许在Bean生命周期的特定点执行定制的任务Spring IOC容器对Bean的生命周期进行管理的过程: 通过构造器或工厂方法创建Bean实例为Bean的属性设置值和对其他Bean的...
  • 谈谈我对Spring Bean 生命周期的理解 https://www.jb51.net/article/136825.htm Spring 中Bean的作用域及生命周期 https://cloud.tencent.com/developer/article/1377825 Spring Bean生命周期在整个 Spring ...
  • Spring ApplicationContext容器的Bean生命周期有13步,而后三步容器关闭和实现接口的destroy()方法和自定义的销毁方法是不可见的。 在前九步【new ClassPathXmlApplicationContext("xx.xml"),加载容器...
  • Spring 配置使用 - Bean 生命周期

    千次阅读 2016-10-08 22:49:54
    基本概念Spring 中的 Bean生命周期,指的是 Bean 从创建到销毁的过程。下面来探究下几个有关 Bean 生命周期配置的属性。lazy-initlazy-init 表示延迟加载 Bean,默认在 Spring IoC 容器初始化时会实例化所有在...
  • Spring Boot IoC(五)Bean生命周期

    千次阅读 2018-10-22 18:53:27
    五、Bean生命周期 简介 之前的Ioc学习中,我们只是关心如何正确的将Bean装配到Ioc容器中,而没有关心IoC容器如何装配和销毁bean的过程。有时候我们也需要自定义初始化或者销毁Bean的过程,以满足一些Bean的特殊...
  • springBean生命周期

    千次阅读 多人点赞 2020-12-18 14:46:36
    一、springBean生命周期 1、 启动spring容器,也就是创建beanFactory(bean工厂), 一般用的是beanFactory的子类applicationcontext, applicationcontext比一般的beanFactory要多很多功能,比如aop、事件等。 通过...
  • Spring bean生命周期

    2019-10-18 13:55:16
    文章目录Spring生命周期图个人大白话理解相关注解InitializingBeanPostConstruct*AwareBeanPostProcessorDisposableBean参考博客 Spring生命周期图 个人大白话理解 创建类: 当需要实例化的时候,首先给类创建地址...
  • Spring源码分析_2 Bean生命周期原理

    千次阅读 2021-01-22 22:32:17
    Spring源码分析_2Bean生命周期原理 ...
  • 文章目录Spring Bean 生命周期Spring 中的设计模式1. 代 理 模 式2. 单例模式3. 模板方法模式4. 前端控制器模式5. 视图帮助(View Helper )6. 依赖注入7. 工厂模式 Spring Bean 生命周期 Spring Bean的完整生命周期...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 95,250
精华内容 38,100
关键字:

bean的生命周期