IOC 容器中 Bean 的生命周期方法
- Spring IOC 容器可以管理 Bean 的生命周期, Spring 允许在 Bean 生命周期的特定点执行定制的任务.
- Spring IOC 容器对 Bean 的生命周期进行管理的过程:
-
-
- 为 Bean 的属性设置值和对其他 Bean 的引用
-
-
-
- 在 Bean 的声明里设置 init-method 和 destroy-method 属性, 为 Bean 指定初始化和销毁方法.
下面先介绍一下工厂方法创建Bean实例
beans-factory.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 通过静态工厂方法配置 bean. 注意不是配置静态工厂方法实例, 而是配置 bean 实例 -->
<!--
class 属性 : 指向静态工厂方法的全类名
factory-method : 指向静态工厂方法的名字
constructor-arg : 如果工厂方法需要传入参数, 则使用 constructor-arg 来配置参数
-->
<bean id="car1"
class="com.Spring.beans.factory.StaticCarFactory"
factory-method="getCar">
<constructor-arg value="audi"></constructor-arg>
</bean>
<!-- 配置工厂的实例 -->
<!--
在 bean 的 factory-bean 属性里指定拥有该工厂方法的 Bean
在 factory-method 属性里指定该工厂方法的名称
使用 construtor-arg 元素为工厂方法传递方法参数
-->
<bean id="carFactory" class="com.Spring.beans.factory.InstanceCarFactory"></bean>
<!-- 通过实例工厂方法来配置 bean -->
<bean id="car2" factory-bean="carFactory" factory-method="getCar">
<constructor-arg value="ford"> </constructor-arg>
</bean>
</beans>
Car.java
package com.Spring.beans.factory;
public class Car {
private String brand;
private double price;
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return "Car [brand=" + brand + ", price=" + price + "]";
}
public Car() {
System.out.println("无参构造器");// TODO Auto-generated constructor stub
}
public Car(String brand, double price) {
super();
this.brand = brand;
this.price = price;
}
}
InstanceCarFactory.java
package com.Spring.beans.factory;
import java.util.HashMap;
import java.util.Map;
/**
* 实例工厂方法 :
* @author hasee
*
*/
public class InstanceCarFactory {
private Map<String, Car> cars = null;
public InstanceCarFactory() {
cars = new HashMap<>();
cars.put("audi", new Car("audi",300000));
cars.put("ford", new Car("ford",400000));
}
public Car getCar(String name) {
return cars.get(name);
}
}
StaticCarFactory.java
package com.Spring.beans.factory;
import java.util.HashMap;
import java.util.Map;
/**
* 静态工厂方法 : 直接调用某一个类的静态方法就可以返回 Bean 的实例
* @author hasee
*
*/
public class StaticCarFactory {
private static Map<String, Car> cars = new HashMap<>();
static {
cars.put("audi", new Car("audi", 3000000));
cars.put("ford", new Car("ford", 4000000));
}
//静态工厂方法
public static Car getCar(String name) {
return cars.get(name);
}
}
创建 Bean 后置处理器
- Bean 后置处理器允许在调用初始化方法前后对 Bean 进行额外的处理.
- Bean 后置处理器对 IOC 容器里的所有 Bean 实例逐一处理, 而非单一实例. 其典型应用是: 检查 Bean 属性的正确性或根据特定的标准更改 Bean 的属性.
- 对Bean 后置处理器而言, 需要实现 BeanPostProcessor 接口. 在初始化方法被调用前后, Spring 将把每个 Bean 实例分别传递给上述接口- 的以下两个方法:
-
- public Object postProcessAfterInitialization
-
- public Object postProcessBeforeInitialization
Spring IOC 容器对 Bean 的生命周期进行管理的过程:
- 通过构造器或工厂方法创建 Bean 实例
- 为 Bean 的属性设置值和对其他 Bean 的引用
- 将 Bean 实例传递给 Bean 后置处理器的 postProcessBeforeInitialization 方法
- 调用 Bean 的初始化方法
- 将 Bean 实例传递给 Bean 后置处理器的 postProcessAfterInitialization方法
- Bean 可以使用了
- 当容器关闭时, 调用 Bean 的销毁方法
beans-cycle.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="car" class="com.Spring.beans.cycle.Car"
init-method="init"
destroy-method="destory">
<property name="brand" value="Audi"></property>
</bean>
<!-- 配置 bean 的后置处理器 -->
<bean class="com.Spring.beans.cycle.MyBeanPostProcessor"></bean>
</beans>
MyBeanPostProcessor.java
package com.Spring.beans.cycle;
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 {
// TODO Auto-generated method stub
System.out.println("AfterInitializatio: " + arg1);
return arg0;
}
@Override
public Object postProcessBeforeInitialization(Object arg0, String arg1) throws BeansException {
// TODO Auto-generated method stub
System.out.println("BeforeInitializatio: " + arg1);
return arg0;
}
}
Car.java
package com.Spring.beans.cycle;
public class Car {
public Car() {
System.out.println("Car's COnstructor"); // TODO Auto-generated constructor stub
}
private String brand;
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
System.out.println("setBrand...");
this.brand = brand;
}
public void init() {
System.out.println("init...");
}
public void destory() {
System.out.println("destory...");
}
}
Main.java
package com.Spring.beans.cycle;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans-cycle.xml");
Car car = (Car) ctx.getBean("car");
System.out.println(car);
//关闭 IOC 容器
ctx.close();
}
}