Spring Bean的生命周期

原创已于 2023-11-23 11:05:47 修改 · 205 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#spring #java #后端

于 2017-12-26 10:00:31 首次发布

1 spring介绍

Spring框架是一个开源的Java平台，广泛用于构建各种类型的应用程序。自2003年首次发布以来，Spring已经成为了Java企业级开发的事实标准之一。它提供了一个全面的编程和配置模型，旨在简化现代Java应用开发，特别是企业级应用。

Spring框架已经成为Java企业级应用开发的基石。它以其强大的功能、灵活性和模块化而著称，为开发现代Java应用程序提供了一个坚实的基础。随着不断的更新和社区的发展，Spring继续保持其在企业级Java开发中的领导地位，不断推动Java生态系统的发展。

1.1 核心特性

轻量级和最小侵入性： Spring是轻量级的，不会强迫使用特定的编程模型，旨在尽可能减少对应用代码的侵入。
依赖注入（DI）： Spring的核心是依赖注入容器，它管理应用中的组件（称为beans），并通过构造器、工厂方法或属性来组装它们的依赖关系。
面向切面编程（AOP）：支持面向切面编程，将如事务管理、日志记录等横切关注点与业务逻辑分离。
模块化： Spring具有模块化结构，允许开发者根据需求选择和使用不同的模块。
事务管理：提供了一致的事务管理接口，支持声明式事务管理。
MVC框架： Spring MVC提供了一个丰富的模型-视图-控制器（MVC）框架，用于构建Web应用程序。
数据访问与集成：提供了对JDBC、Hibernate、JPA等数据访问技术的支持，简化了数据库操作。

1.2 架构和组件

核心容器：包含依赖注入（DI）容器，是Spring框架的基础部分。
数据访问/集成层：包括JDBC、ORM、OXM、JMS和事务模块，用于简化数据库交互。
Web和MVC层：提供了构建Web应用程序的基础，包括Spring MVC和Spring WebFlux。
AOP和设备支持：提供了面向切面编程的实现，以及对消息传递、邮件、任务调度、JMX的支持。
测试模块：提供了测试Spring组件的工具，支持JUnit和TestNG。

1.3 使用Spring框架

应用程序开发：开发者可以使用Spring来构建从简单的独立应用程序到复杂的企业级应用程序。
配置： Spring提供了基于XML、注解和Java的配置选项。
集成： Spring可以与许多其他技术和框架集成，包括Web服务、消息传递服务和持久化技术。

1.4 性能优化

轻量级设计： Spring的轻量级设计意味着对内存和其他资源的消耗相对较小。
单例Beans：默认情况下，Spring中的Beans是单例的，这减少了对象创建的开销。
代理和索引：在AOP和DI中使用代理和索引技术，优化了性能。

1.5 安全性和事务管理

Spring Security：提供了一个全面的安全解决方案，用于认证和授权。
声明式事务管理：支持声明式事务管理，简化了事务管理代码。

1.6 社区和生态系统

强大的社区：拥有活跃的开发者社区，提供支持、文档和大量的资源。
扩展和插件：社区贡献了大量的扩展和插件，进一步丰富了Spring的功能。
与其他框架的集成：与如Hibernate、Quartz、Kafka等其他流行框架的集成，扩展了其在不同领域的应用。

Spring作为当前Java最流行、最强大的轻量级框架，受到了程序员的热烈欢迎。准确的了解Spring Bean的生命周期是非常必要的。我们通常使用ApplicationContext作为Spring容器。这里，我们讲的也是 ApplicationContext中Bean的生命周期。而实际上BeanFactory也是差不多的，只不过处理器需要手动注册。

2 spring bean的生命周期

2.1 生命周期流程图

Spring Bean的完整生命周期从创建Spring容器开始，直到最终Spring容器销毁Bean，这其中包含了一系列关键点。

若容器注册了以上各种接口，程序那么将会按照以上的流程进行。下面将仔细讲解各接口作用。

2.2 各种接口方法分类

Bean的完整生命周期经历了各种方法调用，这些方法可以划分为以下几类：

2.2.1 Bean自身的方法　　

包括了Bean本身调用的方法和通过配置文件中<bean>的init-method和destroy-method指定的方法

2.2.2 Bean级生命周期接口方法

包括了BeanNameAware、BeanFactoryAware、InitializingBean和DiposableBean这些接口的方法

2.2.3 容器级生命周期接口方法　　

包括了InstantiationAwareBeanPostProcessor 和 BeanPostProcessor 这两个接口实现，一般称它们的实现类为“后处理器”。

2.4、工厂后处理器接口方法

包括了AspectJWeavingEnabler, ConfigurationClassPostProcessor, CustomAutowireConfigurer等等非常有用的工厂后处理器　　接口的方法。工厂后处理器也是容器级的。在应用上下文装配配置文件之后立即调用。

2.3 举例说明

我们用一个简单的Spring Bean来演示一下Spring Bean的生命周期。

（1）首先是一个简单的Spring Bean，调用Bean自身的方法和Bean级生命周期接口方法，为了方便演示，它实现了BeanNameAware、BeanFactoryAware、InitializingBean和DiposableBean这4个接口，同时有2个方法，对应配置文件中<bean>的init-method和destroy-method。如下：

package springBeanTest;
 
   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;
  
   /**
    * @author qsk
    */
   public class Person implements BeanFactoryAware, BeanNameAware,
           InitializingBean, DisposableBean {
   
       private String name;
       private String address;
       private int phone;
   
       private BeanFactory beanFactory;
       private String beanName;
   
       public Person() {
           System.out.println("【构造器】调用Person的构造器实例化");
       }
 
       public String getName() {
           return name;
       }
 
       public void setName(String name) {
           System.out.println("【注入属性】注入属性name");
           this.name = name;
       }
   
       public String getAddress() {
           return address;
       }
 
       public void setAddress(String address) {
           System.out.println("【注入属性】注入属性address");
           this.address = address;
       }
 
       public int getPhone() {
           return phone;
       }
  
       public void setPhone(int phone) {
           System.out.println("【注入属性】注入属性phone");
           this.phone = phone;
       }
   
       @Override
       public String toString() {
           return "Person [address=" + address + ", name=" + name + ", phone="
                   + phone + "]";
       }
   
       // 这是BeanFactoryAware接口方法
       @Override
       public void setBeanFactory(BeanFactory arg0) throws BeansException {
           System.out.println("【BeanFactoryAware接口】调用BeanFactoryAware.setBeanFactory()");
           this.beanFactory = arg0;
       }
 
       // 这是BeanNameAware接口方法
       @Override
       public void setBeanName(String arg0) {
           System.out.println("【BeanNameAware接口】调用BeanNameAware.setBeanName()");
           this.beanName = arg0;
       }
 
       // 这是InitializingBean接口方法
       @Override
       public void afterPropertiesSet() throws Exception {
           System.out.println("【InitializingBean接口】调用InitializingBean.afterPropertiesSet()");
       }
   
       // 这是DiposibleBean接口方法
       @Override
       public void destroy() throws Exception {
           System.out.println("【DiposibleBean接口】调用DiposibleBean.destory()");
       }
 
       // 通过<bean>的init-method属性指定的初始化方法
       public void myInit() {
           System.out.println("【init-method】调用<bean>的init-method属性指定的初始化方法");
       }
 
       // 通过<bean>的destroy-method属性指定的初始化方法
       public void myDestory() {
           System.out.println("【destroy-method】调用<bean>的destroy-method属性指定的初始化方法");
       }
   }

（2）演示BeanPostProcessor接口的方法，如下：

package springBeanTest;
  
   import org.springframework.beans.BeansException;
   import org.springframework.beans.factory.config.BeanPostProcessor;
   
   public class MyBeanPostProcessor implements BeanPostProcessor {
   
       public MyBeanPostProcessor() {
           super();
           System.out.println("这是BeanPostProcessor实现类构造器！！");
           // TODO Auto-generated constructor stub
       }
   
       @Override
       public Object postProcessAfterInitialization(Object arg0, String arg1)
               throws BeansException {
           System.out
           .println("BeanPostProcessor接口方法postProcessAfterInitialization对属性进行更改！");
           return arg0;
       }
 
       @Override
       public Object postProcessBeforeInitialization(Object arg0, String arg1)
               throws BeansException {
           System.out
           .println("BeanPostProcessor接口方法postProcessBeforeInitialization对属性进行更改！");
           return arg0;
       }
   }

如上，BeanPostProcessor接口包括2个方法postProcessAfterInitialization和postProcessBeforeInitialization，这两个方法的第一个参数都是要处理的Bean对象，第二个参数都是Bean的name。返回值也都是要处理的Bean对象。这里要注意。

（3）InstantiationAwareBeanPostProcessor 接口本质是BeanPostProcessor的子接口，一般我们继承Spring为其提供的适配器类InstantiationAwareBeanPostProcessor Adapter来使用它，如下：

package springBeanTest;
  
   import java.beans.PropertyDescriptor;
   
   import org.springframework.beans.BeansException;
   import org.springframework.beans.PropertyValues;
   import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter;
   
   public class MyInstantiationAwareBeanPostProcessor extends
           InstantiationAwareBeanPostProcessorAdapter {
   
       public MyInstantiationAwareBeanPostProcessor() {
           super();
           System.out
                   .println("这是InstantiationAwareBeanPostProcessorAdapter实现类构造器！！");
       }
 
       // 接口方法、实例化Bean之前调用
       @Override
       public Object postProcessBeforeInstantiation(Class beanClass,
               String beanName) throws BeansException {
           System.out
                   .println("InstantiationAwareBeanPostProcessor调用postProcessBeforeInstantiation方法");
           return null;
     }
 
       // 接口方法、实例化Bean之后调用
       @Override
       public Object postProcessAfterInitialization(Object bean, String beanName)
               throws BeansException {
           System.out
                   .println("InstantiationAwareBeanPostProcessor调用postProcessAfterInitialization方法");
           return bean;
       }
   
       // 接口方法、设置某个属性时调用
       @Override
       public PropertyValues postProcessPropertyValues(PropertyValues pvs,
               PropertyDescriptor[] pds, Object bean, String beanName)
               throws BeansException {
           System.out
                   .println("InstantiationAwareBeanPostProcessor调用postProcessPropertyValues方法");
           return pvs;
       }
   }

 这个有3个方法，其中第二个方法postProcessAfterInitialization就是重写了BeanPostProcessor的方法。第三个方法postProcessPropertyValues用来操作属性，返回值也应该是PropertyValues对象。

（4）演示工厂后处理器接口方法，如下：

package springBeanTest;
  
   import org.springframework.beans.BeansException;
   import org.springframework.beans.factory.config.BeanDefinition;
   import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
   import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
  
   public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
  
       public MyBeanFactoryPostProcessor() {
           super();
           System.out.println("这是BeanFactoryPostProcessor实现类构造器！！");
       }
   
       @Override
       public void postProcessBeanFactory(ConfigurableListableBeanFactory arg0)
               throws BeansException {
           System.out
                   .println("BeanFactoryPostProcessor调用postProcessBeanFactory方法");
           BeanDefinition bd = arg0.getBeanDefinition("person");
           bd.getPropertyValues().addPropertyValue("phone", "110");
       }
   
   }

（5）配置文件如下beans.xml，使用ApplicationContext,处理器不用手动注册：

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

    <bean id="beanPostProcessor" class="springBeanTest.MyBeanPostProcessor">
    </bean>

    <bean id="instantiationAwareBeanPostProcessor" class="springBeanTest.MyInstantiationAwareBeanPostProcessor">
    </bean>

    <bean id="beanFactoryPostProcessor" class="springBeanTest.MyBeanFactoryPostProcessor">
    </bean>
    
    <bean id="person" class="springBeanTest.Person" init-method="myInit"
        destroy-method="myDestory" scope="singleton" p:name="张三" p:address="广州"
        p:phone="15900000000" />

</beans>

（6）下面测试一下：

package springBeanTest;
  
   import org.springframework.context.ApplicationContext;
   import org.springframework.context.support.ClassPathXmlApplicationContext;
   
   public class BeanLifeCycle {
   
       public static void main(String[] args) {
   
           System.out.println("现在开始初始化容器");
           
           ApplicationContext factory = new ClassPathXmlApplicationContext("springBeanTest/beans.xml");
           System.out.println("容器初始化成功");    
           //得到Preson，并使用
           Person person = factory.getBean("person",Person.class);
           System.out.println(person);
           
           System.out.println("现在开始关闭容器！");
           ((ClassPathXmlApplicationContext)factory).registerShutdownHook();
       }
   }

关闭容器使用的是实际是AbstractApplicationContext的钩子方法。

我们来看一下结果：

现在开始初始化容器
2014-5-18 15:46:20 org.springframework.context.support.AbstractApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@19a0c7c: startup date [Sun May 18 15:46:20 CST 2014]; root of context hierarchy
2014-5-18 15:46:20 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [springBeanTest/beans.xml]
这是BeanFactoryPostProcessor实现类构造器！！
BeanFactoryPostProcessor调用postProcessBeanFactory方法
这是BeanPostProcessor实现类构造器！！
这是InstantiationAwareBeanPostProcessorAdapter实现类构造器！！
2014-5-18 15:46:20 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
信息: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@9934d4: defining beans [beanPostProcessor,instantiationAwareBeanPostProcessor,beanFactoryPostProcessor,person]; root of factory hierarchy
InstantiationAwareBeanPostProcessor调用postProcessBeforeInstantiation方法
【构造器】调用Person的构造器实例化
InstantiationAwareBeanPostProcessor调用postProcessPropertyValues方法
【注入属性】注入属性address
【注入属性】注入属性name
【注入属性】注入属性phone
【BeanNameAware接口】调用BeanNameAware.setBeanName()
【BeanFactoryAware接口】调用BeanFactoryAware.setBeanFactory()
BeanPostProcessor接口方法postProcessBeforeInitialization对属性进行更改！
【InitializingBean接口】调用InitializingBean.afterPropertiesSet()
【init-method】调用<bean>的init-method属性指定的初始化方法
BeanPostProcessor接口方法postProcessAfterInitialization对属性进行更改！
InstantiationAwareBeanPostProcessor调用postProcessAfterInitialization方法
容器初始化成功
Person [address=广州, name=张三, phone=110]
现在开始关闭容器！
【DiposibleBean接口】调用DiposibleBean.destory()
【destroy-method】调用<bean>的destroy-method属性指定的初始化方法