Spring学习（二）

SpEl

1. Spring 表达式语言（简称SpEL）：是一个支持运行时查询和操作对象图的强大的表达式语言。
2. 语法类似于 EL：SpEL 使用 #{…} 作为定界符，所有在大框号中的字符都将被认为是 SpEL语法类似于 EL：SpEL 使用 #{…} 作为定界符，所有在大框号中的字符都将被认为是 SpEL
3. SpEL 为 bean 的属性进行动态赋值提供了便利
4. 通过 SpEL 可以实现：
   1. 通过 bean 的 id 对 bean 进行引用
   2. 调用方法以及引用对象中的属性
   3. 计算表达式的值
   4. 正则表达式的匹配

配置文件

   <bean class="spel.Address" id="address">
        
        <property name="city" value="#{'周口'}">property>
        <property name="address" value="大庆路">property>
    bean>

    <bean class="spel.Car" id="car">
        <property name="name" value="aodi">property>
        
        <property name="price" value="#{T(java.lang.Math).PI * 300}">property>
        <property name="maxSpeed" value="300">property>
    bean>

    <bean class="spel.Person" id="person">
        <property name="name" value="张三">property>
        
        <property name="city" value="#{address.city}">property>
        
        <property name="info" value="#{car.price > 300000 ? '金领':'白领'}">property>
    bean>

测试类

    @Test
    public void testSpEL(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext-spel.xml");
        Car car = (Car) applicationContext.getBean("car");
        Person person = (Person) applicationContext.getBean("person");
        Address address = (Address) applicationContext.getBean("address");
        System.out.println(car);
        System.out.println(person);
        System.out.println(address);
    }
    
//	输出：Car{name='aodi', price=942, maxSpeed=300.0}
//		 Person{car=null, City='周口', info='白领', name='张三'}
//		 Address{city='周口', address='大庆路'}

补充

Spring中Bean的生命周期

1. 创建Bean
2. 给Bean的属性赋值
3. 初始化Bean（调用Bean的配置中指定的init-method方法）
4. 销毁Bean（调用Bean的配置中指定的init-method方法）
   测试
   配置文件

<bean class="cycle.Address" id="address" p:city="周口" p:address="大庆路" init-method="init" destroy-method="destroy">bean>

package cycle;

/**
 * @author Xxx
 * @Description: TODO
 * @date 2018/12/94:15 PM
 **/
public class Address {
    private String city;
    private String address;

    @Override
    public String toString() {
        return "Address{" +
                "city='" + city + '\'' +
                ", address='" + address + '\'' +
                '}';
    }

    public void init(){
        System.out.println("Address被初始化了");
    }

    public void destroy(){
        System.out.println("Address被销毁了");
    }

    public Address() {
        System.out.println("Address被创建了");
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        System.out.println("Address属性值被赋值了");
        this.city = city;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;

    }
}

测试类

    @Test
    public void test(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext-cycle.xml");
        Address address = (Address) applicationContext.getBean("address");       
        ((ClassPathXmlApplicationContext) applicationContext).destroy();
    }
    
// 输出：Address被创建了
//      Address属性值被赋值了
//		Address被初始化了
//		Address被销毁了

Spring中Bean的后置处理器

1. Bean 后置处理器允许在调用初始化方法前后对 Bean 进行额外的处理.
2. Bean 后置处理器对 IOC 容器里的所有 Bean 实例逐一处理, 而非单一实例. 其典型应用是: 检查 Bean 属性的正确性或根据特定的标准更改 Bean 的属性.
3. 对Bean 后置处理器而言, 需要实现BeanPostProcessor接口. 在初始化方法被调用前后, Spring 将把每个 Bean 实例分别传递给上述接口的以下两个方法:Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;，Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;

使用了Bean的后置处理器之后，Bean的生命周期将发生改变

1. 创建Bean
2. 给Bean的属性赋值
3. 将 Bean 实例传递给 Bean 后置处理器的 postProcessBeforeInitialization 方法
4. 初始化Bean（调用Bean的配置中指定的init-method方法）
5. 将 Bean 实例传递给 Bean 后置处理器的 postProcessAfterInitialization 方法
6. 销毁Bean（调用Bean的配置中指定的init-method方法）

测试：为上个例子加上Bean的后置处理器
创建后置处理器

package cycle;

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

/**
 * @author Xxx
 * @Description: TODO
 * @date 2018/12/108:42 PM
 **/
public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessBeforeInitialization"+"----"+beanName);
        return bean;
    }


    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization"+"----"+beanName);
        return bean;
    }
}

配置后置处理器

    
    <bean class="cycle.MyBeanPostProcessor" id="beanPostProcessor" >bean>

测试

    @Test
    public void test(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext-cycle.xml");
        Address address = (Address) applicationContext.getBean("address");       
        ((ClassPathXmlApplicationContext) applicationContext).destroy();
    }
    
// 输出：Address被创建了
//      Address属性值被赋值了
//		postProcessBeforeInitialization----address
//		Address被初始化了
//		postProcessAfterInitialization----address
//		Address被销毁了