【Spring学习笔记-4】bean 的生命周期、后置处理器、属性注入、自动装配

目录

bean 的生命周期

配置 bean 的后置处理器

通过属性文件给 bean 注入值

基于 XML 的 bean 的自动装配

---

bean 的生命周期

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

1. 执行构造器

2. 执行 set 相关方法

3. 调用 bean 的初始化的方法（需要配置）

4. 使用 bean

5. 当容器关闭时候，调用 bean 的销毁方法（需要配置）

简单示例：

        1、创建 MyBean01 类

public class MyBean01 {
    private String name;

    public MyBean01() {
        System.out.println("构造器MyBean01() 被调用。。。");
    }

    public MyBean01(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
        System.out.println("setName(String name) 被调用。。。");
    }

    public void myInit(){
        System.out.println("初始化方法myInit() 被调用。。。");
    }

    public void myDestory(){
        System.out.println("销毁方法myDestory() 被调用。。。");
    }



    @Override
    public String toString() {
        return "MyBean01{" +
                "name='" + name + '\'' +
                '}';
    }
}

        2、配置 xml文件

    <bean id="myBean01" class="com.asl.spring.bean01.MyBean01"
          init-method="myInit" destroy-method="myDestory">
        <property name="name" value="myBean01~~~"/>
    </bean>

        3、测试

    @Test
    public void getMyBean01(){
        ApplicationContext ioc = new ClassPathXmlApplicationContext("bean02.xml");
        MyBean01 myBean01 = ioc.getBean("myBean01", MyBean01.class);
        System.out.println("myBean01= " + myBean01);
        ((ConfigurableApplicationContext)ioc).close();//关闭ioc容器
    }

运行结果：

使用细节

1. 初始化 init 方法和 destory 方法, 是程序员自己来指定

2. 销毁方法就是当关闭容器时，才会被调用

---

配置 bean 的后置处理器

说明

1. 在 spring 的 ioc 容器中可以配置 bean 的后置处理器

2. 该处理器/对象会在 bean 初始化方法调用前和初始化方法调用后被调用

3. 程序员可以在后置处理器中编写自己的业务代码

简单示例：

        1、创建 MyBeanPostProcessor类（自定义的后置处理器, 需要实现 BeanPostProcessor接口）

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

//自定义的后置处理器, 需要实现 BeanPostProcessor接口
public class MyBeanPostProcessor implements BeanPostProcessor {
    /**
     * 调用时段: 在Bean的init方法前 被调用
     * @param bean 传入的在IOC容器中创建/配置Bean
     * @param beanName 传入的在IOC容器中创建/配置Bean的id
     * @return Object 程序员对传入的bean 进行修改/处理时使用，并返回
     *              如果返回null，即没有做修改
     * @throws BeansException
     */

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessBeforeInitialization()被调用.. bean="
                + bean + " beanName=" + beanName);

        //初步体验案例: 如果类型是MyBean01，neme属性统一改成 修改后的beanName~
        //对多个对象进行处理/编程==>切面编程
        if(bean instanceof MyBean01) {
            ((MyBean01)bean).setName("修改后的beanName~");
        }
        return null;
    }

    /**
     * 调用时段: 在Bean的init方法后 被调用
     * @param bean 传入的在IOC容器中创建/配置Bean
     * @param beanName 传入的在IOC容器中创建/配置Bean的id
     * @return Object 程序员对传入的bean 进行修改/处理时使用，并返回
     *              如果返回null，即没有做修改
     * @throws BeansException
     */

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

        2、配置 xml文件

    <bean id="myBeanPostProcessor" class="com.asl.spring.bean01.MyBeanPostProcessor"/>

    <bean id="myBean01" class="com.asl.spring.bean01.MyBean01"
          init-method="myInit" destroy-method="myDestory">
        <property name="name" value="myBean01~~~"/>
    </bean>

        3、测试

    @Test
    public void myBeanPostProcessorTest(){
        ApplicationContext ioc = new ClassPathXmlApplicationContext("bean02.xml");
        MyBean01 myBean01 = ioc.getBean("myBean01", MyBean01.class);
        System.out.println("myBean01= " + myBean01);
        ((ConfigurableApplicationContext)ioc).close();//关闭ioc容器
    }

运行结果：

其它说明

1、使用 AOP(反射+动态代理+IO+容器+注解) 执行到这个方法

2、后置处理器可以对 IOC 容器中所有的对象进行统一处理，比如 日志处理/权限的校验/安全的验证/事务管理... 

3、后置处理器是针对容器的所有对象

---

通过属性文件给 bean 注入值

简单示例：

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

name=jackBean

        2、配置 xml文件

    <context:property-placeholder location="classpath:my.properties"/>
    <bean id="jackBean" class="com.asl.spring.bean01.MyBean02">
        <property name="name" value="${name}"/>
    </bean>

        3、测试

    @Test
    public void getjackBeanTest(){
        ApplicationContext ioc = new ClassPathXmlApplicationContext("bean02.xml");
        MyBean02 myBean02 = ioc.getBean("jackBean", MyBean02.class);
        System.out.println("jackBean= " + myBean02);
    }

运行结果：

 

---

基于 XML 的 bean 的自动装配

简单示例：

        1、创建相关类

OrderDao

package com.asl.spring.autowireBean;

public class OrderDao {
    public void save(){
        System.out.println("OrderDao save() 保存了一个订单。。。");
    }
}

OrderService  

package com.asl.spring.autowireBean;

public class OrderService {

    private OrderDao orderDao;

    public OrderDao getOrderDao() {
        return orderDao;
    }

    public void setOrderDao(OrderDao orderDao) {
        this.orderDao = orderDao;
    }

    public void save() {
        orderDao.save();
    }
}

 OrderAction 

package com.asl.spring.autowireBean;

public class OrderAction {
    private OrderService orderService;

    public OrderService getOrderService() {
        return orderService;
    }

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

    public void save(){
        orderService.save();
    }
}

         2、配置xml 文件

    <bean id="orderAction" autowire="byName" class="com.asl.spring.autowireBean.OrderAction"/>
    <bean id="orderService" autowire="byName" class="com.asl.spring.autowireBean.OrderService"/>
    <bean id="orderDao" class="com.asl.spring.autowireBean.OrderDao"/>

        3、测试

    @Test
    public void autowireBeanTest(){
        ApplicationContext ioc = new ClassPathXmlApplicationContext("bean03.xml");
        OrderAction orderAction = ioc.getBean("orderAction", OrderAction.class);
        System.out.println("orderAction= " + orderAction);
        orderAction.save();
    }

运行结果：