6.Spring系列之Bean的配置3

一、配置Bean的两种方式之使用XML配置Bean

---

1.在IOC容器中引入外部属性文件

在IOC容器中，当配置 Bean 时, 有时需要在 Bean 的配置里引入系统部署的相关信息(例如：文件路径、 数据源配置信息等).，而这些部署细节实际上需要和Bean配置相分离，Spring 提供了一个 PropertyPlaceholderConfigurer 的 BeanFactory 后置处理器，这个处理器允许Bean的部分配置转移到属性文件中，可以在IOC容器中使用形式为 ${var} 的变量，PropertyPlaceholderConfigurer 从属性文件里加载属性， 并使用这些属性来替换变量，Spring 还允许在属性文件中使用 ${propName}，以实现属性之间的相互引用。

注意：随着Spring的版本迭代，2.5之后的版本引入外部属性文件有了简化，可通过 <context:property-placeholder> 元素来引入外部属性文件：

首先，我们引入c3p0和mysql驱动jar包：

c3p0-0.9.1.2.jar、mysql-connector-java-5.1.7-bin.jar

接着，创建db.properties配置文件，里面配置着mysql连接信息：

jdbc.user=xxx
jdbc.password=123456
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.jdbcUrl=jdbc:mysql://xxx:3306/spring

接着，在IOC容器中引入外部属性文件以及配置数据库连接信息：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
    
    <!-- 引入外部资源文件 -->
    <context:property-placeholder location="classpath:db.properties"/>
    
    <!-- 使用c3p0连接池,配置数据库连接信息 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="${jdbc.user}"></property>
        <property name="password" value="${jdbc.password}"></property>
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
        <property name="driverClass" value="${jdbc.driverClass}"></property>
    </bean>
</beans>

最后，开始测试程序：

public class Main {

    @SuppressWarnings("resource")
    public static void main(String[] args) throws SQLException {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 测试数据库是否能连接
        DataSource dataSource = (DataSource) ctx.getBean("dataSource");
        System.out.println(dataSource.getConnection());
        // 运行后输出：com.mchange.v2.c3p0.impl.NewProxyConnection@376b4233
        // 代表连接成功
    }
}

2.IOC容器中Bean的生命周期

Spring IOC 容器不但可以管理 Bean 的生命周期, 而且允许在Bean生命周期过程中执行定制的任务。

Spring IOC 容器对 Bean 的生命周期进行管理的过程:

• 通过构造器或工厂方法创建 Bean 实例
• 为 Bean 的属性设置值和对其他 Bean 的引用
• 调用 Bean 的初始化方法
• Bean 可以使用了
• 当容器关闭时, 调用 Bean 的销毁方法

在 Bean 的声明里设置 init-method 和 destroy-method 属性, 为 Bean 指定初始化和销毁方法.

①.创建一个Bean名为Address：

public class Address {
　　private String city;
　　public Address() {
　　　　System.out.println("Adddress Constructor...");
　　}
　　public String getCity() {
　　　　return city;
　　}
　　public void setCity(String city) {
　　　　System.out.println("setCity...");
　　　　this.city = city;
　　}
　　public void init(){
　　　　System.out.println("init...");
　　}
　　public void destory(){
　　　　System.out.println("destory...");
　　}
}

②.在IOC容器中，配置Bean的init-method和destroy-method：

<bean id="address" class="com.spring.model.Address" init-method="init" destroy-method="destory">
　　<property name="city" value="XiaMen"/>
</bean>

③.测试程序

public class Main {
　　private static ClassPathXmlApplicationContext ctx = null;
　　static{
　　　　// 静态代码块初始化
　　　　ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
　　}
　　public static void main(String[] args) {
　　　　Address address = ctx.getBean(Address.class);
　　　　System.out.println(address);
　　　　ctx.close();
　　}
}

执行结果：

Adddress Constructor...
setCity...
init...
com.spring.autowire.Address@5f4e2d
destory...

 

我们还可以更细粒度的定义bean的生命周期方法：

①.创建bean的后置处理器

Bean 后置处理器允许在调用初始化方法前后对 Bean 进行额外的处理，Bean 后置处理器对 IOC 容器里的所有 Bean 实例逐一处理, 而非单一实例. 其典型应用是: 检查 Bean 属性的正确性或根据特定的标准更改 Bean 的属性。

对Bean 后置处理器而言, 需要实现org.springframework.beans.factory.config包下的接口BeanPostProcessor接口，在初始化方法被调用前后, Spring 将把每个 Bean 实例分别传递给上述接口的以下两个方法:

postProcessAfterInitialization(Object bean,String beanName)
postProcessBeforeInitialization(Object bean,String beanName)

②.添加 Bean 后置处理器后 Bean 的生命周期变更为：

• 通过构造器或工厂方法创建 Bean 实例
• 为 Bean 的属性设置值和对其他 Bean 的引用
• 将 Bean 实例传递给 Bean 后置处理器的 postProcessBeforeInitialization 方法
• 调用 Bean 的初始化方法
• 将 Bean 实例传递给 Bean 后置处理器的 postProcessAfterInitialization方法
• Bean 可以使用了
• 当容器关闭时, 调用 Bean 的销毁方法 

③.案例

1.创建一个Bean，以上方的Address Bean为例；

2.创建MyBeanPostProcessor实现BeanPostProcessor

public class MyBeanPostProcessor implements BeanPostProcessor{
　　@Override
　　public Object postProcessBeforeInitialization(Object bean, String beanName)throws BeansException {
　　　　System.out.println("before: " + bean + "," + beanName);
　　　　return bean;
　　}
　　
　　@Override
　　public Object postProcessAfterInitialization(Object bean, String beanName)throws BeansException {
　　　　System.out.println("after: " + bean + "," + beanName);
　　　　return bean;
　　}
}

3.在IOC容器中配置Bean以及配置Bean的后置处理器

<bean id="address" class="com.spring.model.Address" init-method="init" destroy-method="destory">
　　<property name="city" value="XiaMen"/>
</bean>
<!-- 配置bean的后置处理器 -->
<bean class="com.spring.model.MyBeanPostProcessor"/>

4.测试程序

public class Main {
　　private static ClassPathXmlApplicationContext ctx = null;
　　static{
　　　　ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
　　}
　　public static void main(String[] args) {
　　　　Address address = ctx.getBean(Address.class);
　　　　System.out.println(address);
　　　　ctx.close();
　　}
}

5.执行结果

执行结果：
Adddress Constructor...
setCity...
before: com.spring.model.Address@e80763,address
init...
after: com.spring.model.Address@e80763,address
com.spring.model.Address@e80763
destory...
发现bean的后置处理器在bean的初始化前后执行

那么，看了上述哪里，bean的后置处理器强大在哪儿？例如：我们完全可以将整个Bean替换掉，将address bean的属性修改

@Override
public Object postProcessAfterInitialization(Object bean, String beanName)throws BeansException {
　　System.out.println("after: " + bean + "," + beanName);
　　Address address = new Address();
　　address.setCity("BeiJing");
　　return address;
}

这样获取的bean属性，不再是XiaMen，而是BeiJing，但是一般我们在后置处理器中针对某些bean进行处理，例如：

if("address".equals(beanName)){
     ......
}

注意：

两个参数：bean为bean实例本身；beanName为IOC容器中配置的Bean的id；

返回值：是实际上返回给用户的那个Bean，注意可以在以上两个方法中修改返回的Bean，甚至返回一个新的Bean。

 

通过工厂方法配置 Bean、通过 FactoryBean 配置 Bean后续整理！