spring中bean初始化过程

本文详细介绍了Spring框架中Bean的生命周期,包括Bean的实例化、配置、初始化和销毁等关键步骤。通过具体示例展示了如何实现特定接口以进行Bean生命周期的自定义操作。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

在传统的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()方法被调用。

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()方法被调用。 

 

举例:(这里只是演示Bean工厂的例子)
1.HelloWorld.java

Java代码 复制代码
  1. package com.spring.lifecycle;   
  2.   
  3. import org.springframework.beans.BeansException;   
  4. import org.springframework.beans.factory.BeanFactory;   
  5. import org.springframework.beans.factory.BeanFactoryAware;   
  6. import org.springframework.beans.factory.BeanNameAware;   
  7. import org.springframework.beans.factory.DisposableBean;   
  8. import org.springframework.beans.factory.InitializingBean;   
  9. import org.springframework.beans.factory.config.BeanPostProcessor;   
  10.   
  11. public class HelloWorld implements BeanNameAware,BeanFactoryAware, BeanPostProcessor,InitializingBean,DisposableBean{   
  12.   
  13.     private String hello;   
  14.   
  15.     public void setBeanName(String arg0) {   
  16.         System.out.println("调用BeanNameAware的setBeanName()..." );   
  17.     }   
  18.   
  19.     public String getHello() {   
  20.         return hello;   
  21.     }   
  22.   
  23.     public void setHello(String hello) {   
  24.         this.hello = hello;   
  25.         System.out.println("调用setHello()..." );   
  26.     }   
  27.   
  28.     public void customInit() {   
  29.         System.out.println("调用customInit()...");   
  30.     }   
  31.   
  32.     public void customDestroy() {   
  33.         System.out.println("调用customDestroy()...");   
  34.     }   
  35.   
  36.     public Object postProcessAfterInitialization(Object arg0, String arg1)   
  37.             throws BeansException {   
  38.         System.out.println("调用BeanPostProcessor的postProcessAfterInitialization()...");   
  39.         return null;   
  40.     }   
  41.   
  42.     public Object postProcessBeforeInitialization(Object arg0, String arg1)   
  43.             throws BeansException {   
  44.         System.out.println("调用BeanPostProcessor的postProcessBeforeInitialization()...");   
  45.         return null;   
  46.     }   
  47.   
  48.     public void destroy() throws Exception {   
  49.         System.out.println("调用DisposableBean的destory()...");   
  50.     }   
  51.   
  52.     public void afterPropertiesSet() throws Exception {   
  53.         System.out.println("调用InitializingBean的afterPropertiesSet()...");   
  54.     }   
  55.   
  56.     public void setBeanFactory(BeanFactory arg0) throws BeansException {   
  57.         System.out.println("调用BeanFactoryAware的setBeanFactory()...");   
  58.     }   
  59. }  

2.测试程序

Java代码 复制代码
  1. package com.spring.springtest;   
  2.   
  3. import junit.framework.TestCase;   
  4.   
  5. import org.springframework.beans.factory.BeanFactory;   
  6. import org.springframework.context.support.ClassPathXmlApplicationContext;   
  7.   
  8. import com.spring.lifecycle.HelloWorld;   
  9.   
  10. public class TestLifeCycle extends TestCase {   
  11.     private BeanFactory bf;   
  12.   
  13.     protected void setUp() throws Exception {   
  14.         bf = new ClassPathXmlApplicationContext("applicationContext.xml");   
  15.     }   
  16.   
  17.     public void testLifeCycle() throws Exception {   
  18.         HelloWorld hello = (HelloWorld) bf.getBean("helloWorld");   
  19.         assertEquals("hello world!", hello.getHello());   
  20.         hello.destroy();   
  21.     }   
  22. }  

3.applicationContext.xml

Xml代码 复制代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">  
  3. <beans>  
  4.     <bean id="helloWorld" class="com.spring.lifecycle.HelloWorld"  
  5.         init-method="customInit" destroy-method="customDestroy">  
  6.         <property name="hello" value="hello world!"></property>  
  7.     </bean>  
  8. </beans>  

4.运行结果:

引用
调用setHello()...
调用BeanNameAware的setBeanName()...
调用BeanFactoryAware的setBeanFactory()...
调用InitializingBean的afterPropertiesSet()...
调用customInit()...
调用DisposableBean的destory()...
### Spring Bean 初始化流程及生命周期详解 #### 1. 实例化 (Instantiation) 当应用程序启动时,Spring 容器会根据配置文件或注解中的定义创建相应的 Bean 对象。这一阶段的主要工作是由容器调用无参构造函数或者工厂方法来生成对象实例[^1]。 #### 2. 属性注入 (Property Population) 在完成实例化之后,Spring 容器会对新创建的对象进行依赖注入操作。这一步骤涉及将其他 Beans 或者基本类型的值赋给当前 Bean 的成员变量。通过 XML 配置、Java 注解(如 `@Autowired` 和 `@Value`),可以实现自动装配功能[^2]。 #### 3. 初始化前回调接口处理 如果某个类实现了特定的接口比如 `BeanNameAware`, `BeanFactoryAware` 等,则在此期间这些方法会被依次触发执行以便让开发者能够获取到更多关于上下文环境的信息并作出相应调整。 #### 4. 自定义初始化逻辑 紧接着上述过程的是允许用户指定自己的初始化动作的时间点。可以通过两种方式达成此目的: - **实现 InitializingBean 接口**: 如果一个 bean 类实现了该接口的话,在其 life cycle 中就会被通知去调用 afterPropertiesSet 方法来进行额外设置。 ```java public class MyBean implements InitializingBean { @Override public void afterPropertiesSet() throws Exception { System.out.println("Custom initialization logic executed."); } } ``` - **声明 init-method 属性**: 可以在 xml 文件里为每一个单独定义好的 bean 设置专属的方法名称作为它的初始入口;或者是利用 Java Config 来标注 @PostConstruct 注解达到同样效果[^3]^。 #### 5. 使用阶段 一旦所有的准备工作都已完成——即完成了前面提到的所有步骤以后,这个 Bean 就处于可用状态了。它可以响应来自客户端的各种请求直到它最终退出服务为止. #### 6. 销毁(仅限单例模式下的非永久存活期beans) 对于那些具有有限生命期限(Scope=prototype除外)的 beans 而言,当它们不再需要继续存在下去的时候,将会经历最后一个环节—销毁。类似于初始化部分也有多种途径可供选择如何优雅地结束资源占用等问题: - **实现 DisposableBean 接口** ```java public class MyDisposableBean implements DisposableBean{ @Override public void destroy()throws Exception{ // Cleanup code here. } } ``` - **配置 destroy-method** 综上所述,Spring Framework 提供了一套完整的机制用于控制 Managed Objects(Like Beans)在整个应用运行周期内的行为表现形式. ```java // Example of using PostConstruct and PreDestroy annotations for custom lifecycle methods. import javax.annotation.PostConstruct; import javax.annotation.PreDestroy; public class LifecycleDemo { private String message; public LifecycleDemo(String msg){ this.message=msg; } @PostConstruct public void init(){ System.out.println("Initializing Bean with Message:"+message); } @PreDestroy public void cleanup(){ System.out.println("Destroying Bean..."); } } ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值