Spring4深入理解IOC&DI03----Bean配置--SpEL,IOC 容器中 Bean 的生命周期

参考代码下载github:https://github.com/changwensir/java-ee/tree/master/spring4

一、SpEL

  --• Spring 表达式 语言 （简称 SpEL ）：是 一个 支持运行时查询和操作对象图的强大的表达式语言 。

  --• 语法类似于 EL ： SpEL 使用 # {…} 作为定界符，所有在大框号中的字符都将被认为是 SpEL

  --• SpEL 为 bean 的属性进行动态赋值提供了便利

  --• 通过 SpEL 可以实现：

    – 通过 bean 的 id 对 bean 进行 引用

    – 调用 方法以及引用对象中的属性

    – 计算 表达式的值

    – 正则表达式 的 匹配

1).SpEL：字面量

• 字面 量的 表示：

– 整数： < propertyname="count" value=" #{5 } "/>

– 小数： < propertyname="frequency" value=" #{89.7 } "/>

– 科学计数 法： < propertyname="capacity" value=" #{1e4 } "/>

– String 可以使用单引号或者双引号作为字符串的定界符 号 ： < propertyname =“name” value = " #{'Chuck'} "/> 或 name='name'value=' #{"Chuck "} '/>

– Boolean ： name="enabled"value=" #{false} "/>

2).引用 Bean、属性和方法

3).SpEL支持的运算符号

创建PersonSpEL类，其它的类自行创建

public class PersonSpEL {
    private Car car;
    private String name;

    //根据car的price确定Info
    private String info;
    //引用address bean的city的属性
    private String city;

//省去get,set方法
}

    @Test
    public void testSpEL() {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("Spring4_IOC/beans-spel.xml");
        Address address = (Address) ctx.getBean("address");
        System.out.println(address);

        Car car1 = (Car) ctx.getBean("car");
        System.out.println(car1);

        PersonSpEL person = (PersonSpEL) ctx.getBean("person");
        System.out.println(person);
    }

二、IOC 容器中 Bean 的生命周期方法

  --• Spring IOC 容器可以管理 Bean 的生命周期 ,Spring 允许在 Bean 生命周期的特定点执行定制的任务 .

  --• Spring IOC 容器对 Bean 的生命周期进行管理的过程 :

    – 通过构造器或工厂方法创建 Bean 实例

    – 为 Bean 的属性设置值和对其他 Bean 的引用

    – 调用 Bean 的初始化方法

    – Bean 可以使用了

    – 当容器关闭时 , 调用 Bean 的销毁 方法

  --• 在 Bean 的声明里设置 init -method 和 destroy-method 属性 , 为 Bean 指定初始化和销毁方法 .

public class CarCycle {
    private String brand;

    public CarCycle() {
        System.out.println("CarCycle's constructor...");
    }

    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 destroy() {
        System.out.println("destroy...");
    }
//省去toString方法
}

    @Test
    public void testCycle() {
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("Spring4_IOC/beans-cycle.xml");
        CarCycle car = (CarCycle) ctx.getBean("car");
        System.out.println("---->"+car);

        //关闭IOC容器
        ctx.close();
    }

CarCycle's constructor... setBrand... init... ---->CarCycle{brand='Audi'} destroy...

1-2.Bean后置处理器

  • Bean 后置处理器允许在调用初始化方法前后对 Bean 进行额外的处理 .

  • Bean 后置处理器对 IOC 容器里的所有 Bean 实例逐一处理 , 而非单一实例 . 其典型应用是 : 检查 Bean 属性的正确性或根据特定的标准更改 Bean 的属性 .

  • 对 Bean 后置处理器而言 , 需要实现 interface.BeanPostProcessor接口 . 在初始化方法被调用前后 ,Spring 将把每个 Bean 实例分别传递给上述接口的以下两个方法 :

/**
 * MyBeanPostProcessor
 * Bean 后置处理器允许在调用初始化方法前后对 Bean 进行额外的处理.
 * Bean 后置处理器对 IOC 容器里的所有 Bean 实例逐一处理, 而非单一实例.
 * 其典型应用是: 检查 Bean 属性的正确性或根据特定的标准更改 Bean 的属性.
 */
public class MyBeanPostProcessor implements BeanPostProcessor {
    public Object postProcessBeforeInitialization(Object o, String s) throws BeansException {
        System.out.println("postProcessBeforeInitialization..." + o+","+s);
        //过滤
        if ("car".equals(o)){
        }
        return o;
    }

    public Object postProcessAfterInitialization(Object o, String s) throws BeansException {
        System.out.println("postProcessAfterInitialization..." + o+","+s);
        CarCycle car = new CarCycle();
        car.setBrand("Ford");
        return car;
    }
}

在beans-cycle里增加如下内容

测试方法同上，结果如下：

CarCycle's constructor... setBrand... postProcessBeforeInitialization...CarCycle{brand='Audi'},car init... postProcessAfterInitialization...CarCycle{brand='Audi'},car CarCycle's constructor... setBrand... ---->CarCycle{brand='Ford'} destroy...