Spring管理Bean-IOC-03

2.基于XML配置bean

2.15bean的生命周期

bean对象的创建是由JVM完成的，然后执行如下方法：

1. 执行构造器
2. 执行set相关方法
3. 调用bean的初始化方法（需要配置）
4. 使用bean
5. 当容器关闭时，调用bean的销毁方法（需要配置）

例子

House：

package com.li.bean;

/**
 * @author 李
 * @version 1.0
 */
public class House {
    private String name;

    public House() {
        System.out.println("House() 构造器被执行...");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        System.out.println("House setName()=" + name);
        this.name = name;
    }

    //说明：初始化方法是自定义的，名字随意，只要配置的时候指定名称就行了
    public void init() {
        System.out.println("House init() 被执行...");
    }

    //说明：销毁的方法是也自定义的，名字随意
    public void destroy() {
        System.out.println("House destroy() 被执行...");
    }
}

beans.xml：

<!--配置House对象，演示bean的生命周期
    1.init-method 指定bean的初始化方法，该方法在bean执行setter方法后执行
    2.init-method指定方法执行的时机，由spring容器来控制
    3.destroy-method 指定bean的销毁方法，该方法在容器关闭的时候被执行
    4.destroy-method指定方法执行的时机，也是由spring容器来控制
-->
<bean class="com.li.bean.House" id="house"
      init-method="init"
      destroy-method="destroy">
    <property name="name" value="北京大豪宅"/>
</bean>

测试方法：

//测试bean的生命周期
@Test
public void testBeanLife() {
    ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
    House house = ioc.getBean("house", House.class);
    System.out.println("使用house=" + house);

    //关闭容器
    // 1.ioc的编译类型 ApplicationContext ，运行类型 ClassPathXmlApplicationContext
    // 2.因为 ClassPathXmlApplicationContext 实现了接口 ConfigurableApplicationContext
    // 3.而ConfigurableApplicationContext接口有 close方法
    // 4.因此将ioc转成 ConfigurableApplicationContext 类型，调用close方法，关闭容器
    ((ConfigurableApplicationContext)ioc).close();
}

使用细节：

1. 初始化方法和销毁方法由程序员自定义（包括方法名称，在配置bean的时候指定即可）
2. 销毁方法只有当关闭容器时才会被调用

2.16配置bean的后置处理器

1. 在spring的ioc容器，可以配置bean的后置处理器（后置处理器其实就是一个java对象）
2. 该处理器会在bean 初始化方法调用前 和 初始化方法调用后 被调用
3. 程序员可以在后置处理器中编写自己的业务代码

例子

1.House类（见2.15），该方法设置了构造函数，bean初始化方法等

2.创建后置处理器MyBeanPostProcessor：

后置处理器需要实现BeanPostProcessor接口，该接口中有两个重要的方法，对应我们之前说的 “初始化方法调用前和初始化方法调用后被调用”

package com.li.bean;

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

/**
 * @author 李
 * @version 1.0
 * 这是一个后置处理器，必须实现接口 BeanPostProcessor
 */
public class MyBeanPostProcessor implements BeanPostProcessor {

    /**
     * 调用时机：在Bean初始化方法前被调用（bean没有配置初始化方法，此方法也会被调用）
     *
     * @param bean     传入 在IOC容器中创建/配置的Bean
     * @param beanName 在IOC容器中创建/配置的Bean的id
     * @return Object 返回 bean（返回前程序员可以对bean进行修改/处理，再返回）
     * @throws BeansException
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessBeforeInitialization()被调用..." +
                "bean=" + bean + " beanName=" + beanName);
        return bean;
    }

    /**
     * 调用时机：在Bean初始化方法后被调用（bean没有配置初始化方法，此方法也会被调用）
     *
     * @param bean     传入 在IOC容器中创建/配置的Bean
     * @param beanName 在IOC容器中创建/配置的Bean的id
     * @return Object 返回 bean（返回前程序员可以对bean进行修改/处理，再返回）
     * @throws BeansException
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization()被调用..." +
                "bean=" + bean + " beanName=" + beanName);
        return bean;
    }
}

3.beans02.xml：

因为后置处理器对象会作用在容器配置文件的所有bean对象中，因此这里新创建一个容器文件beans02.xml，为了输出干净，该配置文件中只配置了house一个bean对象

<!--配置House对象-->
<bean class="com.li.bean.House" id="house"
      init-method="init" destroy-method="destroy">
    <property name="name" value="海景大豪宅"/>
</bean>

<!--配置后置处理器对象
    1.当我们在beans02.xml容器配置文件 配置了MyBeanPostProcessor后
    2.该后置处理器对象，就会作用在该容器文件的所有Bean对象中
-->
<bean class="com.li.bean.MyBeanPostProcessor" id="myBeanPostProcessor"/>

4.测试方法：

//测试bean的后置处理器
@Test
public void testBeanPostProcessor() {
    ApplicationContext ioc = new ClassPathXmlApplicationContext("beans02.xml");
    House house = ioc.getBean("house", House.class);
    System.out.println("使用house=" + house);
    //关闭容器
    ((ClassPathXmlApplicationContext)ioc).close();
}

输出如下：postProcessBeforeInitialization()和postProcessAfterInitialization()方法分别在bean的初始化方法前后调用

细节说明：

1. 怎么执行到这个方法？==>使用AOP（反射+动态代理+IO+容器+注解）
2. 有什么用？==>可以对IOC容器中所有对象进行统一处理，如：日志处理/权限校验/安全的验证/事务管理
3. 针对容器的所有对象吗？ 是的==>切面编程特点

后置处理器是一个比较难理解的知识点，后面会实现这个机制，深入理解

2.17通过属性文件给bean注入值

在spring的ioc容器中，可以通过属性文件给bean注入值

例子

1.在src目录下创建my.properties文件

monsterId=1000
name=jack
skill=hello

2.在beans.xml中配置：

使用配置文件的方式需要引入命名空间：

<!--指定属性文件
    1.注意要引入命名空间才能使用
    2.location="classpath:my.properties" 表示指定属性文件的位置
        （注意需要带上"classpath"）
    3.这时我们的属性值通过${属性名} 获取
    4.这里的属性名就是my.properties中的 key
    -->
<context:property-placeholder location="classpath:my.properties"/>

<!--配置Monster对象
    通过属性文件给Monster对象赋值-->
<bean class="com.li.bean.Monster" id="monster1000">
    <property name="monsterId" value="${monsterId}"/>
    <property name="name" value="${name}"/>
    <property name="skill" value="${skill}"/>
</bean>

3.测试：

//通过属性文件给bean属性赋值
@Test
public void setBeanByFile() {
    ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
    Monster monster1000 = ioc.getBean("monster1000", Monster.class);
    System.out.println("monster1000=" + monster1000);
}

---

注意：如果properties文件中的value是中文，会出现乱码，需要将中文转为unicode编码：

2.18基于XML的bean自动装配

在spring的ioc容器中，可以实现自动装配bean

例子

1.OrderDAO

package com.li.dao;

/**
 * @author 李
 * @version 1.0
 * 这是一个DAO类
 */
public class OrderDAO {
    public void saveOrder() {
        System.out.println("保存一个订单...");
    }
}

2.OrderService

package com.li.service;

import com.li.dao.OrderDAO;

/**
 * @author 李
 * @version 1.0
 * 这是一个Service类
 */
public class OrderService {
    //OrderDAO属性
    private OrderDAO orderDAO;

    //getter
    public OrderDAO getOrderDAO() {
        return orderDAO;
    }

    //setter
    public void setOrderDAO(OrderDAO orderDAO) {
        this.orderDAO = orderDAO;
    }
}

3.OrderServlet：

package com.li.web;

import com.li.service.OrderService;

/**
 * @author 李
 * @version 1.0
 * Servlet即 Controller
 */
public class OrderServlet {
    //属性OrderService
    private OrderService orderService;

    //getter
    public OrderService getOrderService() {
        return orderService;
    }

    //setter
    public void setOrderService(OrderService orderService) {
        this.orderService = orderService;
    }
}

4.beans.xml：

• autowire="byType"方式

<!--配置OrderDAO对象-->
<bean class="com.li.dao.OrderDAO" id="orderDAO"/>

<!--配置OrderService对象
    1. 属性 autowire="byType" 表示在创建OrderService时，
       通过类型的方式，给对象的属性自动完成赋值/引用
    2. 比如OrderService对象有private OrderDAO属性，就会在容器中找有没有OrderDAO类型的对象
       如果有，就会自动进行装配（按照类型的方式来装配时，那么该容器中不能有超过一个OrderService对象）
-->
<bean autowire="byType" class="com.li.service.OrderService" id="orderService"/>

<!--配置OrderServlet对象，同理-->
<bean autowire="byType" class="com.li.web.OrderServlet" id="orderServlet"/>

• 使用autowire="byName"方式

<!--配置OrderDAO对象-->
<bean class="com.li.dao.OrderDAO" id="orderDAO"/>

<!--配置OrderService对象
   3.如果设置的是 autowire="byName" 表示通过名字完成自动装配
     比如下面的 autowire=" byName" class="com.li.service.OrderService"
    （1）spring会按照 OrderService对象的属性（如orderDAO）
    （2）找到这个属性的setXxx()方法的Xxx名称，在容器中找到相同id的对象来进行自动装配
    （3）例如我们的orderService对象中有一个setOrderDAO()，就会找id="orderDAO"的对象来进行自动装配
    （4）如果没有就装配失败
-->
<bean autowire="byName" class="com.li.service.OrderService" id="orderService"/>

<!--配置OrderServlet对象，同理-->
<bean autowire="byName" class="com.li.web.OrderServlet" id="orderServlet"/>

注意：autowire="byName"不是通过对象属性名来找到要自动装配的对象的，而是通过setXxx方法的名称来找，因为底层是反射实现的。因此如果对象的属性的setXxx方法的名称改变了，被自动装配的对象id也要随之改变

5.测试类：

//基于XML的bean自动装配
@Test
public void setBeanByAutowire() {
    ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
    OrderServlet orderServlet = ioc.getBean("orderServlet", OrderServlet.class);
    //验证是否自动装配上了OrderService
    System.out.println(orderServlet.getOrderService());
    //验证是否自动装配上了OrderDAO
    System.out.println(orderServlet.getOrderService().getOrderDAO());
}

可以看到orderServlet的orderService属性，以及属性的属性orderDAO成功装载了:（autowire="byType"/"byName"方式）

2.19Spring EL表达式

非重点，了解即可

1. Spring Expression Language，Spring表达式语言，简称SpEL。支持运行时查询并可以操作对象。
2. 和 JSP的EL表达式一样，SpEL根据Javabean风格的getXxx()、setXxx()方法定义的属性访问对象
3. SpEL使用#{}作为定界符，所有在大括号中的字符都将被认为是SpEL表达式

应用实例

SpELBean：

package com.li.bean;

/**
 * @author 李
 * @version 1.0
 */
public class SpELBean {
    private String name;
    private Monster monster;
    private String monsterName;
    private String crySound;
    private String bookName;
    private Double result;

    public SpELBean() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Monster getMonster() {
        return monster;
    }

    public void setMonster(Monster monster) {
        this.monster = monster;
    }

    public String getMonsterName() {
        return monsterName;
    }

    public void setMonsterName(String monsterName) {
        this.monsterName = monsterName;
    }

    public String getCrySound() {
        return crySound;
    }

    public void setCrySound(String crySound) {
        this.crySound = crySound;
    }

    public String getBookName() {
        return bookName;
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

    public Double getResult() {
        return result;
    }

    public void setResult(Double result) {
        this.result = result;
    }

    //cry方法返回字符串
    public String cry(String sound){
        return "发出"+sound+"的叫声";
    }

    //read方法返回字符串
    public static String read(String bookName){
        return "正在看"+bookName;
    }

    @Override
    public String toString() {
        return "SpELBean{" +
                "name='" + name + '\'' +
                ", monster=" + monster +
                ", monsterName='" + monsterName + '\'' +
                ", crySound='" + crySound + '\'' +
                ", bookName='" + bookName + '\'' +
                ", result=" + result +
                '}';
    }
}

配置beans03.xml：

<!--配置一个Monster对象-->
<bean class="com.li.bean.Monster" id="monster01">
    <property name="monsterId" value="100"/>
    <property name="name" value="蜈蚣精"/>
    <property name="skill" value="蜇人"/>
</bean>

<!--spring el 表达式使用-通过sp el给bean的属性赋值-->
<bean class="com.li.bean.SpELBean" id="spELBean">
    <!--sp el 给字面量-->
    <property name="name" value="#{'一只猫猫'}"/>
    <!--sp el 引用其他 bean（该bean要存在）-->
    <property name="monster" value="#{monster01}"/>
    <!--sp el 引用其他 bean 的属性值-->
    <property name="monsterName" value="#{monster01.name}"/>
    <!--sp el 调用普通方法，将该方法的返回值赋给 bean对象的属性-->
    <property name="crySound" value="#{spELBean.cry('喵喵喵')}"/>
    <!--sp el 调用静态方法，将该方法的返回值赋给 bean对象的属性
        注意：需要写上类全路径-->
    <property name="bookName" value="#{T(com.li.bean.SpELBean).read('红楼梦')}"/>
    <!--sp el 通过运算赋值-->
    <property name="result" value="#{89*1.0+33/3}"/>
</bean>

测试类：

//通过spring el 对属性赋值
@Test
public void setBeanBySpel() {
    ApplicationContext ioc = new ClassPathXmlApplicationContext("beans03.xml");
    SpELBean spELBean = ioc.getBean("spELBean", SpELBean.class);
    System.out.println(spELBean);
}