spring知识三-----SpEL&生命周期&bean配置方式

SpEL—–熟悉

SpEL概述

spring的表达式语言。用在配置文件中，是一个支持运行时查询和操作对象图的强大的表达式语言。他的语法类似于EL表达式。SpEL使用 #{ } 作为定界符，所有在大框号中的字符都将被认为是 SpEL。SpEL 为 bean 的属性进行动态赋值提供了便利。

SpEL可以实现的功能：

1、通过 bean 的 id 对 bean 进行引用
2、引用对象中的属性以及调用方法
3、计算表达式的值
4、正则表达式的匹配

    
<bean id="address" class="com.wf.springspel.Address">
    <property name="city" value="#{'henan'}">property>
    <property name="street" value="luoyang">property>
bean>


<bean id="car" class="com.wf.springspel.Car">
    <property name="brand" value="Audi">property>
    <property name="price" value="1000000">property>
    <property name="carlength" value="#{T(java.lang.Math).PI*8 }">property>
bean>

<bean id="user" class="com.wf.springspel.User">
    <property name="name" value="tom">property>
    
    <property name="car" value="#{car}">property>
    
    
    <property name="city" value="#{address.city}">property>
    
    <property name="info" value="#{car.price>30000?'老板':'员工'}">property>

bean>

SpEL 语法

SpEL：字面量

字面量的表示：
整数：<property name="count" value="#{5}"/>
小数：<property name="frequency" value="#{89.7}"/>
科学计数法：<property name="capacity" value="#{1e4}"/>
String可以使用单引号或者双引号作为字符串的定界符号：
<property name=“name” value="#{'Chuck'}"/> 或 <property name='name' value='#{"Chuck"}'/>
Boolean：<property name="enabled" value="#{false}"/>

引用 Bean、属性和方法

<property name="car" value="#{car}">property>

<property name="city" value="#{address.city}">property>

<property name="city" value="#{address.toString()}">property>

<property name="city" value="#{address.toString().toUpperCase()}">property>

运算符的操作

<property name="add" value="#{account.count+125}">property>
<property name="remainder" value="#{account.total % account.count}">property>


<construtor-arg name="name" value="#{performer.fisrtName+':'+performer.lasrName}" />

<property name="equal" value="#{account.count == 125}">property>
<property name="hasCapacity" value="#{account.count le 125}">property>

<property name="largeCircle" value="#{shape.kind == 'circle' and shape.perimeter gt 1000}">property>

<property name="info" value="#{car.price>30000?'老板':'员工'}">property>

<construtor-arg name="email" value="#{admin.email matches '[a-z0-9]' " />

静态方法或静态属性操作

<property name="carlength" value="#{T(java.lang.Math).PI*8 }">property>

Bean生命周期—–了解

简单的生命周期过程

类似于Servlet，spring也可以进行生命周期管理。
Spring IOC 容器可以管理 Bean 的生命周期, Spring 允许在 Bean 生命周期的特定点执行定制的任务。
Spring IOC 容器对 Bean 的生命周期进行管理的过程:
1、通过构造器或工厂方法创建 Bean 实例(构造器调用)；
2、为 Bean 的属性设置值和对其他 Bean 的引用(setter方法调用)；
3、调用 Bean 的初始化方法；
4、Bean 的使用；
5、当容器关闭时, 调用 Bean 的销毁方法；
注意：在 Bean 的声明里设置 init-method 和 destroy-method 属性, 为 Bean 指定初始化和销毁方法。
注意：ApplicationContext没有提供close方法，我们可以利用他的实现类进行来关闭。
【ClassPathXmlApplicationContext cxt = new ClassPathXmlApplicationContext(“beans-cycle.xml”);】

//  类
public class Car {

    private String brand;

    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        System.out.println("setter value.....");
        this.brand = brand;
    }

    public Car() {
        System.out.println("Car constructors...... ");
}
    public void init(){ // 名称不固定init2也是可以
        System.out.println("Car init.....");
    }
    public void destory(){
        System.out.println("car destory......");
    }

    @Override
    public String toString() {
        return "Car [brand=" + brand + "]";
    }
}

// 配置
   
"car" class="com.wf.springcycle.Car" init-method="init" destroy-method="destory">
    "brand" value="Auto">

创建 Bean 后置处理器的生命周期过程

Bean 后置处理器允许在调用初始化方法前后对 Bean 进行额外的处理。
Bean 后置处理器对 IOC 容器里的所有 Bean 实例逐一处理, 而非单一实例。
其典型应用是: 检查 Bean 属性的正确性或根据特定的标准更改 Bean 的属性.
对Bean 后置处理器应用，需要实现【BeanPostProcessor 】接口，在初始化方法被调用前后, Spring 将把每个 Bean 实例分别传递给上述接口的以下两个方法【postProcessAfterInitialization】和【postProcessBeforeInitialization】中。
Spring IOC 容器对 Bean 的生命周期进行管理的过程:
1、通过构造器或工厂方法创建 Bean 实例；
2、为 Bean 的属性设置值和对其他 Bean 的引用；
3、将 Bean 实例传递给 Bean 后置处理器的 postProcessBeforeInitialization 方法；
4、调用 Bean 的初始化方法；
5、将 Bean 实例传递给 Bean 后置处理器的 postProcessAfterInitialization方法；
6、Bean 的使用；
7、当容器关闭时, 调用 Bean 的销毁方法；

public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override //bean代表容器创建的实例，beanName代表bean的id 
    public Object postProcessAfterInitialization(Object bean, String beanName)
            throws BeansException {
        System.out.println("后置处理器postProcessAfterInitialization"+bean+"..."+beanName);
        if("car".equals(beanName)){
            System.out.println("car is changing");
            Car car = (Car) bean;
            car.setBrand("DaBen");
        }       
        return bean;
    }
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName)
            throws BeansException {
        System.out.println("前置处理器postProcessAfterInitialization"+bean+"..."+beanName);
        return bean;
    }
}

// 配置


class="com.wf.springcycle.MyBeanPostProcessor">
bean>

Bean的配置方式——熟悉

通过全类名进行反射配置—掌握

我们对于bean的配置一般都是利用全类名进行反射。【常用的，最基本的】

通过工厂方法—熟悉

【静态工厂方法&实例工厂方法，我们需要额外的创建一个工厂类】

静态工厂方法
调用静态工厂方法创建 Bean是将对象创建的过程封装到静态方法中. 当客户端需要对象时, 只需要简单地调用静态方法, 而不同关心创建对象的细节，要声明通过静态方法创建的 Bean, 需要在 Bean 的 class 属性里指定拥有该工厂的方法的类, 同时在 factory-method 属性里指定工厂方法的名称. 最后, 使用 【constrctor-arg】元素为该方法传递方法参数。

//创建工厂类
/*静态工厂方法：通过调用静态的工厂方法，进行初始化bean*/
public class CarStaticFactory {
    static Map cars=new HashMap();
    // 谨记在声明集合时，进行初始化。。
    static{
        cars.put("Audi", new Car("Audi", 30000));
        cars.put("DaZh", new Car("DaZh", 30000));
        cars.put("XianDai", new Car("XianDai", 30000));
    }
    //封装到静态方法中获取对象
    public static Car getCar(String name){      
        return cars.get(name);
    }   
}


//配置
    

"car01" class="com.wf.springfactory.CarStaticFactory" factory-method="getCar">
    "name" value="Audi">    

实例工厂方法
实例工厂方法: 将对象的创建过程封装到另外一个对象实例的方法里. 当客户端需要请求对象时, 只需要简单的调用该实例方法而不需要关心对象的创建细节.
要声明通过实例工厂方法创建的 Bean，需要在 bean 的 factory-bean 属性里指定拥有该工厂方法的 Bean，在 factory-method 属性里指定该工厂方法的名称，使用 construtor-arg 元素为工厂方法传递方法参数。

/*实例工厂方法：通过创建实例工厂，然后调用工厂的实例方法，进行初始化bean*/

public class CarInstanceFactory {

    static Map<String, Car> cars=new HashMap<String, Car>();    
    public  Car getCar(String name){        
        return cars.get(name);
    }
    public CarInstanceFactory() {
        cars.put("Audi", new Car("Audi", 30000));
        cars.put("DaZh", new Car("DaZh", 30000));
        cars.put("XianDai", new Car("XianDai", 30000));
    }
}


<bean id="CarInstanceFactory" class="com.wf.springfactory.CarInstanceFactory" >
bean>

<bean id="car02" factory-bean="CarInstanceFactory" factory-method="getCar">
    <constructor-arg value="Audi"> constructor-arg>
bean>

FactoryBean —掌握

【整合其余框架会利用， quartz】需要自定义 FactoryBean。
Spring 中有两种类型的 Bean, 一种是普通Bean, 另一种是工厂Bean, 即FactoryBean。
工厂 Bean 跟普通Bean不同, 其返回的对象不是指定类的一个实例, 其返回的是该工厂 Bean 的 getObject 方法所返回的对象 。

在利用FactoryBean配置时，我们需要实现Spring给我们提供的FactoyBean接口。，并且重写其中的方法。

//自定义FactoryBean需要实现spring提供的FactoryBean接口
// 如果设置有属性，可以通过配置文件的property属性进行赋值
//  整合quartz需要使用
public class CarFactoryBean implements FactoryBean<Car> {
    @Override  // 返回  bean 对象
    public Car getObject() throws Exception {
        // TODO Auto-generated method stub
        return new Car("BMW", 200000)  ;
    }
    @Override   // 返回bean的类型
    public Class getObjectType() {
        // TODO Auto-generated method stub
        return Car.class;
    }
    @Override   //  是否是单例
    public boolean isSingleton() {
        // TODO Auto-generated method stub
        return true;
    }
}

<bean id="car03" class="com.wf.springfactory.CarFactoryBean">
bean>

源码可以在我的资源中查看 或者 github地址
https://github.com/wangfa1994/SpringLearning/tree/spring003