精华内容
下载资源
问答
  • Java spring bean 生命周期

    千次阅读 2013-03-03 23:46:43
    Spring bean生命周期 在传统的Java应用中,Bean的生命周期非常简单。 Java的关键词new用来实例化Bean(或许他是非序列化的)。这样就够用了。 相反,Bean的生命周期在Spring容器中更加细致。 理解Spring Bean的...
    Spring bean生命周期
    在传统的Java应用中,Bean的生命周期非常简单。 
    Java的关键词new用来实例化Bean(或许他是非序列化的)。这样就够用了。 
    相反,Bean的生命周期在Spring容器中更加细致。 
    理解Spring Bean的生命周期非常重要,因为你或许要利用Spring提供的机会来订制Bean的创建过程。 
    
    1.容器寻找Bean的定义信息并且将其实例化。 
    
    2.受用依赖注入,Spring按照Bean定义信息配置Bean的所有属性。 
    
    3.如果Bean实现了BeanNameAware接口,工厂调用Bean的setBeanName()方法传递Bean的ID。 
    
    4.如果Bean实现了BeanFactoryAware接口,工厂调用setBeanFactory()方法传入工厂自身。 
    
    5.如果BeanPostProcessor和Bean关联,那么它们的postProcessBeforeInitialzation()方法将被调用。 
    
    6.如果Bean指定了init-method方法,它将被调用。 
    
    7.最后,如果有BeanPsotProcessor和Bean关联,那么它们的postProcessAfterInitialization()方法将被调用。 
    到这个时候,Bean已经可以被应用系统使用了,并且将被保留在Bean Factory中知道它不再需要。 
    
    有两种方法可以把它从Bean Factory中删除掉。 
    
    1.如果Bean实现了DisposableBean接口,destory()方法被调用。 
    
    2.如果指定了订制的销毁方法,就调用这个方法。 
    
    Bean在Spring应用上下文的生命周期与在Bean工厂中的生命周期只有一点不同, 
    唯一不同的是,如果Bean实现了ApplicationContextAwre接口,setApplicationContext()方法被调用。 
    
    只有singleton行为的bean接受容器管理生命周期。 
    non-singleton行为的bean,Spring容器仅仅是new的替代,容器只负责创建。 
    
    
    对于singleton bean,Spring容器知道bean何时实例化结束,何时销毁, 
    Spring可以管理实例化结束之后,和销毁之前的行为,管理bean的生命周期行为主要未如下两个时机: 
    Bean全部依赖注入之后 
    Bean即将销毁之前 
    
    1)依赖关系注入后的行为实现: 
    有两种方法:A.编写init方法  B.实现InitializingBean接口 
    afterPropertiesSet和init同时出现,前者先于后者执行,使用init方法,需要对配置文件加入init-method属性 
    
    2)bean销毁之前的行为 
    有两种方法:A.编写close方法  B.实现DisposableBean接口 
    destroy和close同时出现,前者先于后者执行,使用close方法,需要对配置文件加入destroy-method属性 

    展开全文
  • 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中的生命周期是不相同的。


    展开全文
  • Spring中bean作用域与生命周期

    万次阅读 多人点赞 2017-06-17 22:29:18
    在Spring中,那些组成应用程序的主体及由Spring IoC容器所管理的对象,被称之为bean。简单地讲,bean就是由IoC容器初始化、装配及管理的对象,除此之外,bean就与应用程序中的其他对象没有什么区别了。而bean的定义...

      在Spring中,那些组成应用程序的主体及由Spring IoC容器所管理的对象,被称之为bean。简单地讲,bean就是由IoC容器初始化、装配及管理的对象,除此之外,bean就与应用程序中的其他对象没有什么区别了。而bean的定义以及bean相互间的依赖关系将通过配置元数据来描述。

      Spring中的bean默认都是单例的,对于Web应用来说,Web容器对于每个用户请求都创建一个单独的Sevlet线程来处理请求,引入Spring框架之后,每个Action都是单例的,那么对于Spring托管的单例Service Bean,Spring的单例是基于BeanFactory也就是Spring容器的,单例Bean在此容器内只有一个,Java的单例是基于JVM,每个JVM内只有一个实例。

    1、bean的作用域

      创建一个bean定义,其实质是用该bean定义对应的类来创建真正实例的“配方”。把bean定义看成一个配方很有意义,它与class很类似,只根据一张“处方”就可以创建多个实例。不仅可以控制注入到对象中的各种依赖和配置值,还可以控制该对象的作用域。这样可以灵活选择所建对象的作用域,而不必在Java Class级定义作用域。Spring Framework支持五种作用域,分别阐述如下表。

      五种作用域中,request、session和global session三种作用域仅在基于web的应用中使用(不必关心你所采用的是什么web应用框架),只能用在基于web的Spring ApplicationContext环境。

      (1)当一个bean的作用域为Singleton,那么Spring IoC容器中只会存在一个共享的bean实例,并且所有对bean的请求,只要id与该bean定义相匹配,则只会返回bean的同一实例。Singleton是单例类型,就是在创建起容器时就同时自动创建了一个bean的对象,不管你是否使用,他都存在了,每次获取到的对象都是同一个对象。注意,Singleton作用域是Spring中的缺省作用域。要在XML中将bean定义成singleton,可以这样配置:

    <bean id="ServiceImpl" class="cn.csdn.service.ServiceImpl" scope="singleton">
    

      (2)当一个bean的作用域为Prototype,表示一个bean定义对应多个对象实例。Prototype作用域的bean会导致在每次对该bean请求(将其注入到另一个bean中,或者以程序的方式调用容器的getBean()方法)时都会创建一个新的bean实例。Prototype是原型类型,它在我们创建容器的时候并没有实例化,而是当我们获取bean的时候才会去创建一个对象,而且我们每次获取到的对象都不是同一个对象。根据经验,对有状态的bean应该使用prototype作用域,而对无状态的bean则应该使用singleton作用域。在XML中将bean定义成prototype,可以这样配置:

    <bean id="account" class="com.foo.DefaultAccount" scope="prototype"/>  
     <!--或者-->
    <bean id="account" class="com.foo.DefaultAccount" singleton="false"/> 
    

      (3)当一个bean的作用域为Request,表示在一次HTTP请求中,一个bean定义对应一个实例;即每个HTTP请求都会有各自的bean实例,它们依据某个bean定义创建而成。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义:

    <bean id="loginAction" class=com.foo.LoginAction" scope="request"/>
    

      针对每次HTTP请求,Spring容器会根据loginAction bean的定义创建一个全新的LoginAction bean实例,且该loginAction bean实例仅在当前HTTP request内有效,因此可以根据需要放心的更改所建实例的内部状态,而其他请求中根据loginAction bean定义创建的实例,将不会看到这些特定于某个请求的状态变化。当处理请求结束,request作用域的bean实例将被销毁。

      (4)当一个bean的作用域为Session,表示在一个HTTP Session中,一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义:

    <bean id="userPreferences" class="com.foo.UserPreferences" scope="session"/>
    

      针对某个HTTP Session,Spring容器会根据userPreferences bean定义创建一个全新的userPreferences bean实例,且该userPreferences bean仅在当前HTTP Session内有效。与request作用域一样,可以根据需要放心的更改所创建实例的内部状态,而别的HTTP Session中根据userPreferences创建的实例,将不会看到这些特定于某个HTTP Session的状态变化。当HTTP Session最终被废弃的时候,在该HTTP Session作用域内的bean也会被废弃掉。

      (5)当一个bean的作用域为Global Session,表示在一个全局的HTTP Session中,一个bean定义对应一个实例。典型情况下,仅在使用portlet context的时候有效。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义:

    <bean id="user" class="com.foo.Preferences "scope="globalSession"/>
    

      global session作用域类似于标准的HTTP Session作用域,不过仅仅在基于portlet的web应用中才有意义。Portlet规范定义了全局Session的概念,它被所有构成某个portlet web应用的各种不同的portlet所共享。在global session作用域中定义的bean被限定于全局portlet Session的生命周期范围内。

    2、bean的生命周期

      Spring中Bean的实例化过程:

      Bean的生命周期:

      Bean实例生命周期的执行过程如下:

    • Spring对bean进行实例化,默认bean是单例;

    • Spring对bean进行依赖注入;

    • 如果bean实现了BeanNameAware接口,Spring将bean的名称传给setBeanName()方法;

    • 如果bean实现了BeanFactoryAware接口,Spring将调用setBeanFactory()方法,将BeanFactory实例传进来;

    • 如果bean实现了ApplicationContextAware接口,它的setApplicationContext()方法将被调用,将应用上下文的引用传入到bean中;

    • 如果bean实现了BeanPostProcessor接口,它的postProcessBeforeInitialization()方法将被调用;

    • 如果bean中有方法添加了@PostConstruct注解,那么该方法将被调用;

    • 如果bean实现了InitializingBean接口,spring将调用它的afterPropertiesSet()接口方法,类似的如果bean使用了init-method属性声明了初始化方法,该方法也会被调用;

    • 如果在xml文件中通过<bean>标签的init-method元素指定了初始化方法,那么该方法将被调用;

    • 如果bean实现了BeanPostProcessor接口,它的postProcessAfterInitialization()接口方法将被调用;

    • 此时bean已经准备就绪,可以被应用程序使用了,他们将一直驻留在应用上下文中,直到该应用上下文被销毁;

    • 如果bean中有方法添加了@PreDestroy注解,那么该方法将被调用;

    • 若bean实现了DisposableBean接口,spring将调用它的distroy()接口方法。同样的,如果bean使用了destroy-method属性声明了销毁方法,则该方法被调用;

      这里特别说明一下Aware接口,Spring的依赖注入最大亮点就是所有的Bean对Spring容器的存在是没有意识的。但是在实际项目中,我们有时不可避免的要用到Spring容器本身提供的资源,这时候要让 Bean主动意识到Spring容器的存在,才能调用Spring所提供的资源,这就是Spring的Aware接口,Aware接口是个标记接口,标记这一类接口是用来“感知”属性的,Aware的众多子接口则是表征了具体要“感知”什么属性。例如BeanNameAware接口用于“感知”自己的名称,ApplicationContextAware接口用于“感知”自己所处的上下文。其实Spring的Aware接口是Spring设计为框架内部使用的,在大多数情况下,我们不需要使用任何Aware接口,除非我们真的需要它们,实现了这些接口会使应用层代码耦合到Spring框架代码中

      其实很多时候我们并不会真的去实现上面所描述的那些接口,那么下面我们就除去那些接口,针对bean的单例和非单例来描述下bean的生命周期:

    2.1 单例管理的对象

      当scope="singleton",即默认情况下,会在启动容器时(即实例化容器时)时实例化。但我们可以指定Bean节点的lazy-init="true"来延迟初始化bean,这时候,只有在第一次获取bean时才会初始化bean,即第一次请求该bean时才初始化。如下配置:

    <bean id="serviceImpl" class="cn.csdn.service.ServiceImpl" lazy-init="true"/>
    

      如果想对所有的默认单例bean都应用延迟初始化,可以在根节点beans设置default-lazy-init属性为true,如下所示:

    <beans default-lazy-init="true">
    

      默认情况下,Spring在读取xml文件的时候,就会创建对象。在创建对象的时候先调用构造器,然后调用init-method属性值中所指定的方法。对象在被销毁的时候,会调用destroy-method属性值中所指定的方法(例如调用Container.destroy()方法的时候)。写一个测试类,代码如下:

    public class LifeBean {
    	private String name;  
        
        public LifeBean(){  
            System.out.println("LifeBean()构造函数");  
        }  
        public String getName() {  
            return name;  
        }  
      
        public void setName(String name) {  
            System.out.println("setName()");  
            this.name = name;  
        }  
    
        public void init(){  
            System.out.println("this is init of lifeBean");  
        }  
          
        public void destory(){  
            System.out.println("this is destory of lifeBean " + this);  
        }  
    }
    

      life.xml配置如下:

    <bean id="life_singleton" class="com.bean.LifeBean" scope="singleton" 
    			init-method="init" destroy-method="destory" lazy-init="true"/>
    

      测试代码如下:

    public class LifeTest {
    	@Test 
    	public void test() {
    		AbstractApplicationContext container = 
    		new ClassPathXmlApplicationContext("life.xml");
    		LifeBean life1 = (LifeBean)container.getBean("life");
    		System.out.println(life1);
    		container.close();
    	}
    }
    

      运行结果如下:

    LifeBean()构造函数
    this is init of lifeBean
    com.bean.LifeBean@573f2bb1
    ……
    this is destory of lifeBean com.bean.LifeBean@573f2bb1
    

    2.2 非单例管理的对象

      当scope="prototype"时,容器也会延迟初始化bean,Spring读取xml文件的时候,并不会立刻创建对象,而是在第一次请求该bean时才初始化(如调用getBean方法时)。在第一次请求每一个prototype的bean时,Spring容器都会调用其构造器创建这个对象,然后调用init-method属性值中所指定的方法。对象销毁的时候,Spring容器不会帮我们调用任何方法,因为是非单例,这个类型的对象有很多个,Spring容器一旦把这个对象交给你之后,就不再管理这个对象了。

      为了测试prototype bean的生命周期life.xml配置如下:

    <bean id="life_prototype" class="com.bean.LifeBean" scope="prototype" init-method="init" destroy-method="destory"/>
    

      测试程序如下:

    public class LifeTest {
    	@Test 
    	public void test() {
    		AbstractApplicationContext container = new ClassPathXmlApplicationContext("life.xml");
    		LifeBean life1 = (LifeBean)container.getBean("life_singleton");
    		System.out.println(life1);
    		
    		LifeBean life3 = (LifeBean)container.getBean("life_prototype");
    		System.out.println(life3);
    		container.close();
    	}
    }
    

      运行结果如下:

     
    LifeBean()构造函数
    this is init of lifeBean
    com.bean.LifeBean@573f2bb1
    LifeBean()构造函数
    this is init of lifeBean
    com.bean.LifeBean@5ae9a829
    ……
    this is destory of lifeBean com.bean.LifeBean@573f2bb1
    

      可以发现,对于作用域为prototype的bean,其destroy方法并没有被调用。如果bean的scope设为prototype时,当容器关闭时,destroy方法不会被调用。对于prototype作用域的bean,有一点非常重要,那就是Spring不能对一个prototype bean的整个生命周期负责:容器在初始化、配置、装饰或者是装配完一个prototype实例后,将它交给客户端,随后就对该prototype实例不闻不问了。不管何种作用域,容器都会调用所有对象的初始化生命周期回调方法。但对prototype而言,任何配置好的析构生命周期回调方法都将不会被调用。清除prototype作用域的对象并释放任何prototype bean所持有的昂贵资源,都是客户端代码的职责(让Spring容器释放被prototype作用域bean占用资源的一种可行方式是,通过使用bean的后置处理器,该处理器持有要被清除的bean的引用)。谈及prototype作用域的bean时,在某些方面你可以将Spring容器的角色看作是Java new操作的替代者,任何迟于该时间点的生命周期事宜都得交由客户端来处理。

      Spring容器可以管理singleton作用域下bean的生命周期,在此作用域下,Spring能够精确地知道bean何时被创建,何时初始化完成,以及何时被销毁。而对于prototype作用域的bean,Spring只负责创建,当容器创建了bean的实例后,bean的实例就交给了客户端的代码管理,Spring容器将不再跟踪其生命周期,并且不会管理那些被配置成prototype作用域的bean的生命周期。

    2.3 引申

      在学习Spring IoC过程中发现,每次产生ApplicationContext工厂的方式是:

    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    

      这样产生ApplicationContext就有一个弊端,每次访问加载bean的时候都会产生这个工厂,所以这里需要解决这个问题。

      ApplicationContext是一个接口,它继承自BeanFactory接口,除了包含BeanFactory的所有功能之外,在国际化支持、资源访问(如URL和文件)、事件传播等方面进行了良好的支持。

      解决问题的方法很简单,在web容器启动的时候将ApplicationContext转移到ServletContext中,因为在web应用中所有的Servlet都共享一个ServletContext对象。那么我们就可以利用ServletContextListener去监听ServletContext事件,当web应用启动的是时候,我们就将ApplicationContext装载到ServletContext中。 Spring容器底层已经为我们想到了这一点,在spring-web-xxx-release.jar包中有一个已经实现了ServletContextListener接口的类ContextLoader,其源码如下:

    public class ContextLoaderListener extends ContextLoader implements ServletContextListener {
    	private ContextLoader contextLoader;
    
    	public ContextLoaderListener() {
    
    	}
    
    	public ContextLoaderListener(WebApplicationContext context) {
    		super(context);
    	}
    
    	public void contextInitialized(ServletContextEvent event) {
    		this.contextLoader = createContextLoader();
    		if (this.contextLoader == null) {
    			this.contextLoader = this;
    		}
    		this.contextLoader.initWebApplicationContext(event.getServletContext());
    	}
    
    	@Deprecated
    	protected ContextLoader createContextLoader() {
    		return null;
    	}
    
    	@Deprecated
    	public ContextLoader getContextLoader() {
    		return this.contextLoader;
    	}
    
    	public void contextDestroyed(ServletContextEvent event) {
    		if (this.contextLoader != null) {
    		this.contextLoader.closeWebApplicationContext(event.getServletContext());
    		}
    		ContextCleanupListener.cleanupAttributes(event.getServletContext());
    	}
    }
    

      这里就监听到了servletContext的创建过程, 那么 这个类又是如何将applicationContext装入到serveletContext容器中的呢?

      this.contextLoader.initWebApplicationContext(event.getServletContext())方法的具体实现中:

    public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
         if (servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE) != null) {
             throw new IllegalStateException(
                     "Cannot initialize context because there is already a root application context present - " +
                     "check whether you have multiple ContextLoader* definitions in your web.xml!");
         }
    
         Log logger = LogFactory.getLog(ContextLoader.class);
         servletContext.log("Initializing Spring root WebApplicationContext");
         if (logger.isInfoEnabled()) {
             logger.info("Root WebApplicationContext: initialization started");
         }
         long startTime = System.currentTimeMillis();
    
         try {
         	  // Store context in local instance variable, to guarantee that
              // it is available on ServletContext shutdown.
             if (this.context == null) {
                 this.context = createWebApplicationContext(servletContext);
             }
             if (this.context instanceof ConfigurableWebApplicationContext) {
                 ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;
                 if (!cwac.isActive()) {
                     // The context has not yet been refreshed -> provide services such as
                     // setting the parent context, setting the application context id, etc
                     if (cwac.getParent() == null) {
                         // The context instance was injected without an explicit parent ->
                         // determine parent for root web application context, if any.
                         ApplicationContext parent = loadParentContext(servletContext);
                         cwac.setParent(parent);
                     }
                     configureAndRefreshWebApplicationContext(cwac, servletContext);
                 }
             }
             servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
    
             ClassLoader ccl = Thread.currentThread().getContextClassLoader();
             if (ccl == ContextLoader.class.getClassLoader()) {
                 currentContext = this.context;
             }
             else if (ccl != null) {
                 currentContextPerThread.put(ccl, this.context);
             }
    
             if (logger.isDebugEnabled()) {
                 logger.debug("Published root WebApplicationContext as ServletContext attribute with name [" +
                         WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE + "]");
             }
             if (logger.isInfoEnabled()) {
                 long elapsedTime = System.currentTimeMillis() - startTime;
                 logger.info("Root WebApplicationContext: initialization completed in " + elapsedTime + " ms");
             }
    
             return this.context;
         }
         catch (RuntimeException ex) {
             logger.error("Context initialization failed", ex);
             servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
             throw ex;
         }
         catch (Error err) {
             logger.error("Context initialization failed", err);
             servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, err);
             throw err;
         }
     }
    

      这里的重点是servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context),用key:WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE value: this.context的形式将applicationContext装载到servletContext中了。另外从上面的一些注释我们可以看出: WEB-INF/applicationContext.xml, 如果我们项目中的配置文件不是这么一个路径的话 那么我们使用ContextLoaderListener 就会出问题, 所以我们还需要在web.xml中配置我们的applicationContext.xml配置文件的路径。

    <listener>
    	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    
    <context-param>
    	<param-name>contextConfigLocation</param-name>
    	<param-value>classpath:applicationContext.xml</param-value>
    </context-param>
    

      剩下的就是在项目中开始使用 servletContext中装载的applicationContext对象了: 那么这里又有一个问题,装载时的key是 WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE,我们在代码中真的要使用这个吗? 其实Spring为我们提供了一个工具类WebApplicationContextUtils,接着我们先看下如何使用,然后再去看下这个工具类的源码:

    WebApplicationContext applicationContext = WebApplicationContextUtils.getWebApplicationContext(request.getServletContext());
    

      接着来看下这个工具类的源码:

    public static WebApplicationContext getWebApplicationContext(ServletContext sc) {
    	return getWebApplicationContext(sc, WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
    }
    

      这里就能很直观清晰地看到 通过key值直接获取到装载到servletContext中的 applicationContext对象了。

      ContextLoaderListener监听器的作用就是启动Web容器时,自动装配ApplicationContext的配置信息,因为它实现了ServletContextListener这个接口,在web.xml配置这个监听器,启动容器时,就会默认执行它实现的方法。在ContextLoaderListener中关联了ContextLoader这个类,整个加载配置过程由ContextLoader来完成。

    展开全文
  • 14.笔记JAVA Spring框架学习————Bean生命周期.pdf
  • Java EE CDI bean生命周期介绍

    千次阅读 热门讨论 2015-03-31 11:27:24
    而赋予它的作用域通常就会决定了这个bean的整个生命周期。CDI提供的bean生命周期作用域 描述 ApplicationScoped 当我们使用一个作用域被定义为应用程序范围内的bean时那就意味着整个bea

            这篇博客主要介绍CDI提供的不同bean的生命周期及在项目中如何使用它们。


    介绍

            当一个bean被CDI初始化时,这个bean通常会有自己的作用域。而赋予它的作用域通常就会决定了这个bean的整个生命周期。CDI提供的bean的生命周期:

    作用域使用
    ApplicationScoped当我们使用一个作用域被定义为应用程序范围内的bean时那就意味着
    整个bean会存在于应用程序的整个生命周期内。一旦这个bean被初始
    化之后,每次客户端请求创建该bean,应用程序都会保证请求的是同
    一个实例。
    SessionScoped SessionScoped 主要用于web环境下应用的开发。当我们使用一个作
    用域为session的CDI bean时,表示bean实例的生命周期取决于每个
    Http Session。
    RequestScoped RequestScoped 主要用于web环境下应用的开发。当我们使用一个
    作用域为session的CDI bean时,表示bean实例的生命周期取决于每
    个Http 请求。
    ConversationScoped ConversationScoped主要用于web环境下应用的开发。如同其名一样,ConversationScoped标志客户端同服务端的一次交流 。他们可能被
    用于保持多个ajax请求或者不同页面请求与服务端交互的状态信息。

            注意:在Java EE7中介绍了一系列的CDI beans的作用域,如TransactionScoped,FlowScoped and ViewScoped.等等,更多信息参考
    Java EE 7 CDI bean scopes


    CDI同时也提供了另外两种pseudo-scopes:

    作用域使用
    Singleton
    如同其名一样,Singleton bean标志着单实例,如果一个bean被用作Singleton意味着从始至终仅仅有一个实例存在。
    Dependent
    Dependent scope bean的作用域与其被注入的bean的作用域一样。如当一个定义为Dependent的
    bean被注入到一个会话bean中,那么这个bean的作用域和生命周期同这个会话bean一样,当会话
    结束此bean的生命周期也就截止了。


    代理

        当一个被CDI容器管理的bean被注入到其他bean中时,CDI容器并不是注入的bean实例,而是注入的一个代理类。通常这个代理类会将客户端的相应请求再转发给相应的bean去处理。

    想想SessionScoped bean,如果不同的会话请求一个SessionScoped 会话实例,这些请求都会被交给同一个代理处理。当这些请求访问这些被代理的对象时,代理对象知道如何找到相应的对象实例并为相应的会话提供这却的服务。

        注意:单例的 pseduo-scope与这种代理模式正好相对应。当一个客户端请求一个单例的bean时,CDI容器会将这个bean的实例注入到相应的bean中而不再是一个代理。


    序列话

         一些被CDI容器管理的bean可以保持很长时间的生命周期,如SessionScoped、ConversationScoped,但是他们必须实现序列化接口。这是由于容器要释放一些资源,而这些资源往往需要连同bean的类信息持久化到物理磁盘上,等到程序再次需要的时候能够保证容器再次将这些bean的状态从物理磁盘中恢复出来。


    Singleton pseudo-scoped

        我们知道当我们使用Singlescoped 时,客户端会得到该对象实例的真正引用。因此当客户端请求的是序列化的,就必须保证这个实例是单例的。我们而保证这个单例的bean是一个正真的单例的方法如下:

        1.正如java序列话标准声明的那样,这个单例要实现writeReplace()和readResolve()方法。

        2.维护单例的引用对象的瞬时状态,当容器反序序列化该对像时,容器要保证重新注入该对象的引用。


    Dependent pseudo-scope

        如果没有特别声明的话,Dependent是CDI默认的作用域。Dependent意味着注入的bean与被注入的bean有相同的作用域。客户端不会共享实例,每个客户端拿到的将会是一个新的对象实例。


    view scope

        update:在java EE7中增加了viewscoped,详细信息请参考Java EE 7 CDI bean scopesJava EE CDI ViewScoped example.

        如果你熟悉JSF bean的作用域,您可能想知道哪个viewscoped bean符合这个模型。CDI不提供任何viewscoped但提供conversationscoped代替。
    conversationscoped与我们实现相同的功能,通常需要从一个viewscoped的JSF bean(bean之间保持状态的Ajax请求),更有可能保持不同的页面请求的相同的对话或状态。

        注:请记住,如果用户离开当前对话而没有结束这样的对话机会,托管bean将保持有效,直到它超时。所以如果你有一个真正的问题这些bean一直有效到超时,如果真需要像JSF viewscoped bean的bean,你应该参考下面的实现以代替:
         .Apache deltaspike(前缝面)
         .ViewAccessScope beans from MyFaces CODI

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

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

    千次阅读 2020-10-28 17:51:28
    SpringBean生命周期详解 一、简述: Spring是我们每天都在使用的框架,Bean是被Spring管理的Java对象,是Spring框架最重要的部分之一,那么让我们一起了解一下Spring中Bean的生命周期是怎样的吧 二、流程图 我们先从...
  • IOC容器中bean的生命周期,iocbean生命周期 一、Bean的生命周期 Spring IOC容器可以管理Bean的生命周期,允许在Bean生命周期的特定点执行定制的任务。 Spring IOC容器对Bean的生命周期进行管理的过程...
  • Spring中Bean生命周期的意义:可以利用Bean在其存活期间的特定时刻完成一些相关操作。...Bean生命周期管理: Spring容器可以管理Bean部分作用域的生命周期。 singleton作用域 Spring容器可以管理singleton作...
  • spring管理bean生命周期

    2016-06-03 13:58:29
    Spring IOC容器可以管理Bean的生命周期,Spring允许在Bean生命周期的特定点执行定制的任务。 Spring IOC容器对Bean的生命周期进行管理的过程: 1.通过构造器或工厂方法创建Bean实例 2.为Bean的属性设置值和对...
  • Spring Bean生命周期

    2019-07-09 20:19:57
    Spring Bean生命周期生命周期 生命周期 生命周期过程总概述: 通过构造方法或工厂方法创建bean对象——>为bean属性赋值——>调用 bean 的初始化方法,即init-method指定方法——>bean实例化完毕,可以使用...
  • springBean生命周期

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

    2014-06-03 20:50:21
    Spring IOC容器可以管理Bean的生命周期,Spring允许在Bean生命周期的特定点执行定制的任务Spring IOC容器对Bean的生命周期进行管理的过程: 通过构造器或工厂方法创建Bean实例为Bean的属性设置值和对其他Bean的...
  • java bean生命周期

    万次阅读 2018-12-13 09:47:49
    Spring 中bean生命周期短暂吗? 在spring中,从BeanFactory或ApplicationContext取得的实例为Singleton,也就是预设为每一个Bean的别名只能维持一个实例,而不是每次都产生一个新的对象使用Singleton模式产生单一...
  • Spring bean生命周期

    2013-12-11 17:07:52
     在传统的Java应用中,Bean生命周期非常简单。 Java的关键词new用来实例化Bean(或许他是非序列化的)。这样就够用了。 相反,Bean生命周期在Spring容器中更加细致。 理解Spring Bean生命周期非常重要...
  • 在Spring中,我们从Bean作用范围和实例化Bean时所经历的一系列阶段来描述Bean生命周期: 接下来,我们从BeanFactory和ApplicationContext两个方面来分析Bean生命周期: 一.如下通过一个图形化的方式进行描述...
  • spring bean生命周期总结

    万次阅读 2016-12-22 17:56:02
     Spring Bean的完整生命周期从创建Spring容器开始,直到最终Spring容器销毁Bean,这其中包含了一系列关键点。   若容器注册了以上各种接口,程序那么将会按照以上的流程进行。下面将仔细讲解各接口作用。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 81,677
精华内容 32,670
关键字:

bean生命周期java作用

java 订阅