Spring中bean用法（2）：生命周期

一：基本流程

把一个bean纳入到Spring IoC容器之中，这个bean的生命周期就会交由容器进行管理

1.Bean的建立

由BeanFactory读取Bean定义文件，并生成各个实例。

2.Setter注入

执行Bean的属性依赖注入。

3.BeanNameAware的setBeanName()

如果Bean类实现了org.springframework.beans.factory.BeanNameAware接口，则执行其setBeanName()方法。

4.BeanFactoryAware的setBeanFactory()

如果Bean类实现了org.springframework.beans.factory.BeanFactoryAware接口，则执行其setBeanFactory()方法。

5.BeanPostProcessors的processBeforeInitialization()

容器中如果有实现org.springframework.beans.factory.BeanPostProcessors接口的实例，则任何Bean在初始化之前都会执行这个实例的processBeforeInitialization()方法。

6.InitializingBean的afterPropertiesSet()

如果Bean类实现了org.springframework.beans.factory.InitializingBean接口，则执行其afterPropertiesSet()方法。

7.Bean定义文件中定义init-method

在Bean定义文件中使用“init-method”属性设定方法名称，如下：

<bean id="demoBean" class="com.yangsq.bean.DemoBean" init-method="initMethod">

.......

</bean>

这时会执行initMethod()方法，注意，这个方法是不带参数的。

8.BeanPostProcessors的processAfterInitialization()

容器中如果有实现org.springframework.beans.factory.BeanPostProcessors接口的实例，则任何Bean在初始化之前都会执行这个实例的processAfterInitialization()方法。

9.DisposableBean的destroy()

在容器关闭时，如果Bean类实现了org.springframework.beans.factory.DisposableBean接口，则执行它的destroy()方法。

10.Bean定义文件中定义destroy-method

在容器关闭时，可以在Bean定义文件中使用“destory-method”定义的方法

二：使用案例

1.案例截图

2.基本代码

package com.cloud.beanlife;

import javax.annotation.PostConstruct;

import javax.annotation.PreDestroy;

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.InitializingBean;

import org.springframework.context.ApplicationContext;

import org.springframework.context.ApplicationContextAware;

public class PersonService implements BeanNameAware,BeanFactoryAware,ApplicationContextAware,InitializingBean{

private String name;

private Integer age;

public PersonService(){

System.out.println("实例化对象");

}

public PersonService(String abc){

System.out.println("实例化对象");

}

public String getName() {

return name;

}

public void setName(String name) {

System.out.println("调用了setName函数");

this.name = name;

}

public Integer getAge() {

return age;

}

public void setAge(Integer age) {

this.age = age;

}

public void sayhello(){

System.out.println("hello:"+name+"的年龄是"+age);

}

//该方法可以传递ApplicationContext

@Override

public void setApplicationContext(ApplicationContext arg0)

throws BeansException {

System.out.println("setApplicationContext "+arg0);

}

//可以通过注解的方式配置<bean init-method="init">初始化方法

@PostConstruct

public void init(){

System.out.println("自己的init方法");

}

//该方法可以传递beanFactory

@Override

public void setBeanFactory(BeanFactory arg0) throws BeansException {

System.out.println("setBeanFactory "+arg0);

}

//该方法的arg0表示正在被实例化的bean的id 是多少

@Override

public void setBeanName(String arg0) {

System.out.println("setBeanName被调用 值是"+arg0);

}

@Override

public void afterPropertiesSet() throws Exception {

System.out.println("afterPropertiesSet");

}

//可以通过注解的方式配置<bean destroy-method="mydestory">销毁方法

@PreDestroy

public void mydestroy(){

System.out.println("生命周期结束，释放各种资源");

}

}

package com.cloud.beanlife;

import org.springframework.beans.BeansException;

import org.springframework.beans.factory.config.BeanPostProcessor;

public class MyBeanPostProcessor implements BeanPostProcessor {

@Override

public Object postProcessAfterInitialization(Object arg0, String arg1)

throws BeansException {

System.out.println("postProcessAfterInitialization 函数被调用");

System.out.println(arg0+"被创建的 时间是"+new java.util.Date());

return arg0;

}

@Override

public Object postProcessBeforeInitialization(Object arg0, String arg1)

throws BeansException {

System.out.println("postProcessBeforeInitialization 函数被调用");

return arg0;

}

}

3.配置代码

<?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:context="http://www.springframework.org/schema/context"

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/context http://www.springframework.org/schema/context/spring-context-2.5.xsd

http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

<bean id="personService" destroy-method="mydestroy" class="com.cloud.beanlife.PersonService">

<property name="name" value="Spring"/>

<property name="age">

<value>25</value>

</property>

</bean>

<bean id="personService2" class="com.cloud.beanlife.PersonService">

<property name="name" value="小明"/>

</bean>

<!-- 配置自己的处理器，类似于过滤器 -->

<bean id="myBeanPostProcessor" class="com.cloud.beanlife.MyBeanPostProcessor">

</bean>

</beans>

4.测试代码

package com.cloud.beanlife;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestLife {

public static void main(String[] args) {

//bena的生命周期

ApplicationContext ac=new ClassPathXmlApplicationContext("com/cloud/beanlife/beans.xml");

PersonService ps=(PersonService) ac.getBean("personService");

ps.sayhello();

}

}

5.测试结果

实例化对象

调用了setName函数

setBeanName被调用 值是personService

setBeanFactory org.s[email protected]9a082e2: defining beans [personService,personService2,myBeanPostProcessor]; root of factory hierarchy

setApplicationContext org[email protected]735cda3f: display name [org[email protected]735cda3f]; startup date [Thu Aug 27 16:43:00 CST 2015]; root of context hierarchy

postProcessBeforeInitialization 函数被调用

afterPropertiesSet

postProcessAfterInitialization 函数被调用

[email protected]被创建的 时间是Thu Aug 27 16:43:01 CST 2015

实例化对象

调用了setName函数

setBeanName被调用 值是personService2

setBeanFactory org.s[email protected]9a082e2: defining beans [personService,personService2,myBeanPostProcessor]; root of factory hierarchy

setApplicationContext org[email protected]735cda3f: display name [org[email protected]735cda3f]; startup date [Thu Aug 27 16:43:00 CST 2015]; root of context hierarchy

postProcessBeforeInitialization 函数被调用

afterPropertiesSet

postProcessAfterInitialization 函数被调用

[email protected]被创建的 时间是Thu Aug 27 16:43:01 CST 2015

hello:Spring的年龄是25

版权声明：博主原创文章，转载请说明出处。http://blog.csdn.net/dzy21

时间： 2024-10-11 13:09:45

Spring中bean用法（2）：生命周期的相关文章

Spring中bean对象的生命周期

Spring提供了一些接口来提供一些方法,体现了bean对象在Spring容器中的生命周期 具体的过程可以体现为: 读取权限类名->构建一个类对象->用这个类对象通过无参构造器newInstance()构建对象 ↓ 调用set方法注入依赖 ↓ 如果这个Bean已经实现了BeanNameAware接口 调用它实现的setBeanName(String name)方法 此处传递的就是Spring配置文件中Bean的name值 ↓ 如果这个Bean已经实现了BeanFactoryAware接口 容器

Spring中bean用法（1）：基本用法

一:获取bean的方法 1.从ApplicationContex应用上下文容器中获取bean和从bean工厂容器中获取bean 具体案例: //从ApplicationContext中取bean ApplicationContextac=new ClassPathXmlApplicationContext("com/hsp/ioc/beans.xml"); //当我们去实例化beans.xml,该文件中配置的bean被实例(该bean scope是 singleton)从bean中取出

Spring中Bean的生命周期

Spring中Bean的生命周期过程: 1.Spring对Bean进行实例化(相当于程序中的new Xx()) 2.Spring将值和Bean的引用注入进Bean对应的属性中 3如果Bean实现了BeanNameAware接口,Spring将Bean的ID传递给setBeanName()方法 (实现BeanNameAware清主要是为了通过Bean的引用来获得Bean的ID,一般业务中是很少有在Bean的ID的) 4.如果Bean实现了BeanFactoryAware接口,Spring将调用se

JAVA面试题：Spring中bean的生命周期

Spring 中bean 的生命周期短暂吗? 在spring中,从BeanFactory或ApplicationContext取得的实例为Singleton,也就是预设为每一个Bean的别名只能维持一个实例,而不是每次都产生一个新的对象使用Singleton模式产生单一实例,对单线程的程序说并不会有什么问题,但对于多线程的程序,就必须注意安全(Thread-safe)的议题,防止多个线程同时存取共享资源所引发的数据不同步问题. 然而在spring中 可以设定每次从BeanFactory或Appl

Spring：Spring中bean的生命周期

Spring中,从BeanFactory或ApplicationContext取得的实例为Singleton(单例模式),就是预设为每一个Bean的别名只能维持一个实例,而不是每次都产生一个新的对象使用Singleton模式产生单一实例,对单线程的程序说并不会有什么问题,但对于多线程的程序,就必须注意安全(Thread-safe)的议题,防止多个线程同时存取共享资源所引发的数据不同步问题. 然而在spring中 可以设定每次从BeanFactory或ApplicationContext指定别名并

深究Spring中Bean的生命周期

一.Bean 的完整生命周期 在传统的Java应用中,bean的生命周期很简单,使用Java关键字 new 进行Bean 的实例化,然后该Bean 就能够使用了.一旦bean不再被使用,则由Java自动进行垃圾回收. 相比之下,Spring管理Bean的生命周期就复杂多了,正确理解Bean 的生命周期非常重要,因为Spring对Bean的管理可扩展性非常强,下面展示了一个Bean的构造过程 Bean 的生命周期 如上图所示,Bean 的生命周期还是比较复杂的,下面来对上图每一个步骤做文字描述:

Spring中Bean的生命中期与InitializingBean和DisposableBean接口

Spring提供了一些标志接口,用来改变BeanFactory中的bean的行为.它们包括InitializingBean和DisposableBean.实现这些接口将会导致BeanFactory调用前一个接口的afterPropertiesSet()方法,调用后一个接口destroy()方法,从而使得bean可以在初始化和析构后做一些特定的动作. 在内部,Spring使用BeanPostProcessors 来处理它能找到的标志接口以及调用适当的方法.如果你需要自定义的特性或者其他的Sprin

Spring文档苦读【3】【短生命周期的Bean注入长生命周期的Bean】

前言 在Spring 中,定义Bean的范围有多种.一种是经常用的Singleton,还有prototype,request,session,globalSession,application,websocket等等,但是我们如何把短生命周期的bean注入到我们长生命周期的bean中呢?例如,我如何把scope为session的bean注入到singleton的bean中呢? 有的同学可能会这样做 1 <!-- 短生命周期 --> 2 <bean id="userPrefere

Spring中bean的五个作用域简介(转载)

Spring上个版本的IoC容器支持两个不同的bean作用域(单例与原型).Spring 2.0改进了这一点,不仅提供了一些依赖于Spring部署环境(比如说,在web环境中的request和session作用域bean)的额外的作用域,而且提供了所谓的'钩子'('hooks')(因为找不到更好的表达)使Spring用户可以创造自己的作用域. 应该注意的是,即使单例与原型作用域beans的基本(内在)实现发生了变化,上述变化对最终用户来说是透明的...现有的配置不需要改变或放弃. 如何使用spr