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后续整理！
