IoC容器装配Bean（xml配置方式）（Bean的生命周期）

1、Spring管理Bean，实例化Bean对象 三种方式

第一种：使用类构造器实例化（默认无参数）

package cn.itcast.spring.initbean;

/**
 * 使用构造方法 实例化
 * 
 * @author seawind
 * 
 */
public class Bean1 {

}

    <!-- Bean 实例化第一种 方式 构造器 -->
    <bean id="bean1" class="cn.itcast.spring.initbean.Bean1"></bean>

第二种：使用静态工厂方法实例化（简单工厂模式）

package cn.itcast.spring.initbean;
/**
 * 使用静态工厂方法进行Bean 实例化
 * 
 * @author seawind
 * 
 */
public class Bean2 {

}

package cn.itcast.spring.initbean;
// 工厂类
public class Bean2Factory {
    public static Bean2 getBean2() {
        return new Bean2();
    }
}

    <!-- Bean 实例化第二种 方式 静态工厂方法 -->
    <bean id="bean2" class="cn.itcast.spring.initbean.Bean2Factory" factory-method="getBean2" />

第三种：使用实力工厂方法实例化（工厂方法模式）

package cn.itcast.spring.initbean;
/**
 * 通过实例 工厂方法进行构造
 * 
 * @author seawind
 * 
 */
public class Bean3 {

}

package cn.itcast.spring.initbean;
public class Bean3Factory {
    public Bean3 getBean3() {
        return new Bean3();
    }
}

    <!-- Bean 实例化 第三种 方式  实例工厂方法 -->
    <bean id="bean3factory" class="cn.itcast.spring.initbean.Bean3Factory"></bean>
    <bean id="bean3" factory-bean="bean3factory" factory-method="getBean3"></bean>

测试三种方式

package cn.itcast.spring.initbean;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 实例化 Bean 三种方式
 * 
 * @author seawind
 * 
 */
public class SpringTest {
    @Test
    // 实例工厂方法 实例化 Bean
    public void demo3() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
                "applicationContext.xml");
        Bean3 bean3 = (Bean3) applicationContext.getBean("bean3");
        System.out.println(bean3);
    }

    @Test
    // 使用 静态工厂方法实例化Bean
    public void demo2() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
                "applicationContext.xml");
        Bean2 bean2 = (Bean2) applicationContext.getBean("bean2");
        System.out.println(bean2);
    }

    @Test
    // 使用Bean 的构造方法 实例化Bean
    public void demo1() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
                "applicationContext.xml");
        // Bean1 bean1 = (Bean1) applicationContext.getBean("bean1");
        // Spring3 集合 JDK5 泛型特性
        Bean1 bean1 = applicationContext.getBean("bean1", Bean1.class);

        System.out.println(bean1);
    }
}

 2、Bean的id属性和name属性

在使用Spring 配置Bean
    <bean id="helloService" class=".....HelloService" />
    <bean name="helloService" class="....HelloSerivce" />

* 在配置Bean过程中 id 属性 和 name 属性 都行 ，都可以通过 applicationContext.getBean(id/name) 来获得一个Bean实例

配置id 必须唯一，通常不含有特殊字符， 比如以/开始，以数字开始
配置name 属性，不必须唯一， 可以含有特殊字符

*  为什么要有name属性 ？
    比如 struts1 整合 spring 需要将 请求路径 配置到spring 中
        <bean id="/login" class="..... UserAction" />  ------ 在早期Spring版本 是报错的
        <bean name="/login" class="..... UserAction" /> ------ 以前整合都是这样写的

3、 Bean的作用域
在配置 <bean> 元素时， 通过 scope 属性 指定 Bean的作用域
    singleton ： 代表Bean 在整个Spring 容器环境中 是单例的
    prototype : 多例 （原型模式） ， 在一个Spring 容器中，每次使用Bean 都会返回一个新的实例
    request ： 相当于 构造对象，保存request数据范围 （request.setAttribute()）
    session ： 相当于 构造对象，保存session数据范围 （session.setAttribute()） 以后再次使用，同一个Session无需构造  

* 在实际开发中 只需要掌握 singleton 和 prototype 就可以了 ----- 默认值是 singleton   

4、Bean 生命周期
在配置 <bean> 通过 init-method destroy-method 定义Bean的初始化 和 销毁的方法

　　applicationContext.xml: <bean id="product" class="cn.itcast.spring.lifecycle.Product" init-method="myinit" destroy-method="mydestroy"></bean>
    
    public class Product {
        public Product() {
            System.out.println("执行 Product的 构造 ...");
        }

        public void myinit() {
            System.out.println("Product对象初始化....");
        }

        public void mydestroy() {
            System.out.println("Product对象销毁....");
        }
    }

@Test
    // 配置 init-method 和 destroy-method 执行 bean 的初始化和销毁 方法
    public void demo1() {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext(
                "applicationContext.xml");
        Product product = (Product) applicationContext.getBean("product");
        System.out.println(product);

        // 如果销毁 Spring 手动 调用 close方法
        applicationContext.close();
    }

有构造方法，为什么要有init ？

 　　java语言不建议在构造器 编写复杂处理逻辑，通常在构造器 只会成员变量赋值。初始化

完整Bean的生命周期
    1） instantiate bean对象实例化
    2） populate properties 封装属性（setXxxx方法执行）
    3） 如果Bean实现BeanNameAware 执行 setBeanName（String beanName）
    4） 如果Bean实现BeanFactoryAware 或者 ApplicationContextAware 设置工厂 setBeanFactory 或者上下文对象 setApplicationContext

　　　　　　* void setApplicationContext(ApplicationContext applicationContext)
    5） 如果存在类实现 BeanPostProcessor（后处理Bean） ，执行postProcessBeforeInitialization
    6） 如果Bean实现InitializingBean 执行 afterPropertiesSet
    7） 调用<bean init-method="init"> 指定初始化方法 init
    8） 如果存在类实现 BeanPostProcessor（处理Bean） ，执行postProcessAfterInitialization
    9） 执行业务处理
    10）如果Bean实现 DisposableBean 执行 destroy
    11）调用<bean destroy-method="customerDestroy"> 指定销毁方法 customerDestroy

　　　　3) 4) 知识点： 让Bean 了解Spring 容器
　　　　5) Bean的后处理器 BeanPostProcessor ，该类成为Bean的后处理器
  　　　　  * 后处理Bean 可以对 已经创建 Bean对象 进行代理增强

package cn.itcast.spring.lifecycle;

// 定义业务接口
 
public interface CustomerService {
    public void addCustomer();
}


package cn.itcast.spring.lifecycle;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

// CustomerService 一个实现类 
public class CustomerServiceImpl implements CustomerService, BeanNameAware,
        ApplicationContextAware, InitializingBean, DisposableBean {
    private String name;

    // 第一步
    public CustomerServiceImpl() {
        System.out.println("第一步 Bean的构造器执行....");
    }

    @Override
    public void addCustomer() {
        // 第九步 执行业务操作
        System.out.println("第九步 ，使用业务Bean 执行业务操作....");
        System.out.println("添加客户");
    }

    // 第二步
    public void setName(String name) {
        System.out.println("第二步  属性依赖注入....");
        this.name = name;
    }

    @Override
    // 第三步，如果 Bean 实现 BeanNameAware， Spring 就会将 <bean> 配置 id 属性 、name 属性 注入
    public void setBeanName(String beanName) {
        System.out.println("第三步 获得当前Bean在Spring 注册 Bean 名字 ：" + beanName);
    }

    @Override
    // 第四步 如果 Bean 实现 ApplicationContextAware， Spring 就会将Spring 应用上下文 注入给 Bean
    public void setApplicationContext(ApplicationContext applicationContext)
            throws BeansException {
        System.out.println("第四步 获得当前 Spring上下文 ：" + applicationContext);
        // 通过该对象 操作其它Bean
    }

    @Override
    // 第六步
    public void afterPropertiesSet() throws Exception {
        System.out.println("第六步 属性封装完成 ....");
    }

    // 第七步 通过配置文件，指定初始化方法
    public void myinit() {
        System.out.println("第七步  自定义初始化方法...");
    }

    @Override
    // 第十步 释放资源
    public void destroy() throws Exception {
        System.out.println("第十步， 不需要配置 调用释放资源方法");
    }

    // 第十一步
    public void mydestroy() {
        System.out.println("第十一步  自定义 释放资源方法");
    }

}

package cn.itcast.spring.lifecycle;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

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

// 自定义 一个 Bean的 后处理器

public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    // 提供两个方法，用户通过实现 两个方法，对原有Bean 进行增强
    // 第八步
    /**
     * beanName 就是 配置文件 <bean> id 属性
     * bean 增强前对象
     */
    public Object postProcessAfterInitialization(final Object bean,
            String beanName) throws BeansException {
        System.out.println("第八步 BeanPostProcessor 后处理Bean 初始化完成后增强....");
        // 通过beanName 判断要对哪个Bean 进行代理增强
        if (beanName.equals("customerService")) {
            // 增强
            return Proxy.newProxyInstance(bean.getClass().getClassLoader(),
                    bean.getClass().getInterfaces(), new InvocationHandler() {
                        @Override
                        public Object invoke(Object proxy, Method method,
                                Object[] args) throws Throwable {
                            if (method.getName().equals("addCustomer")) { // 增强
                                System.out
                                        .println("增强addCustomer=======================================");
                            }

                            // 不增强
                            return method.invoke(bean, args);
                        }
                    });
        }
        return bean;
    }

    @Override
    // 第五步
    public Object postProcessBeforeInitialization(Object bean, String beanName)
            throws BeansException {
        System.out.println("第五步BeanPostProcessor 后处理Bean 初始化完成前增强... ");
        return bean;
    }

}

@Test
    // 通过CustomerService 来理解Bean 的生命周期
    public void demo2() {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext(
                "applicationContext.xml");
        CustomerService customerService = (CustomerService) applicationContext
                .getBean("customerService");
        customerService.addCustomer();

        applicationContext.close();
    }


<!-- 可以配置Bean 初始化和销毁 调用方法 -->
    <bean id="customerService" class="cn.itcast.spring.lifecycle.CustomerServiceImpl" init-method="myinit" destroy-method="mydestroy">
        <property name="name" value="张三"></property>
    </bean>
    
    <!-- 配置后处理Bean ，不需要为Bean 指定id ，会对所有Bean 产生作用 -->
     <bean class="cn.itcast.spring.lifecycle.MyBeanPostProcessor"></bean>

结果：