深入了解Spring

1.Bean后处理器

Spring容器提供了一个接口InitializingBean，实现这个接口的bean只要重写afterPropertiesSet()或者在XML中添加init-method属性，就可以在Bean初始化前后执行特定行为。

InitializingBean是针对单个Bean起作用的，Spring还提供了另外一个接口叫BeanPostProcessor，这个接口是针对容器中所有Bean起作用的。

只要定义个普通的Bean实现这个接口，并实现postProcessBeforeInitialization()和postProcessAfterInitialization()两个方法，容器中所有的Bean都会受影响。

下面是一个实现了BeanPostProcessor的普通bean类，

 1 package spi;
 2 
 3 import org.springframework.beans.BeansException;
 4 import org.springframework.beans.factory.config.BeanPostProcessor;
 5 
 6 public class MyBeanPostProcessor implements BeanPostProcessor {
 7 
 8     @Override
 9     public Object postProcessBeforeInitialization(Object bean, String beanName)
10             throws BeansException {
11         System.out.println("Bean后处理器在初始化之前对 "+beanName+" 进行增强处理...");
12         return bean;
13     }
14 
15     @Override
16     public Object postProcessAfterInitialization(Object bean, String beanName)
17             throws BeansException {
18         System.out.println("Bean后处理器在初始化之后对 "+beanName+" 进行增强处理...");
19         if (bean instanceof Chinese) {
20             System.out.println("Bean后处理器将Chinese.beanName修改为'Java编程'.");
21             Chinese c = (Chinese)bean;
22             c.setBeanName("Java编程");
23         }
24         return bean;
25     }
26     
27 }

特意让这个bean修改chinese这个bean的属性，下面是chinese Bean的代码，

 1 package spi;
 2 
 3 import org.springframework.beans.factory.BeanNameAware;
 4 import org.springframework.beans.factory.InitializingBean;
 5 
 6 public class Chinese implements Person, InitializingBean {
 7     private Son son;
 8     private String beanName;
 9 
10     public void setBeanName(String beanName) {
11         System.out.println(beanName+":Spring正在执行setBeanName()方法注入依赖关系...");
12         this.beanName = beanName;
13         
14     }
15     public void info(){
16         System.out.println("我在XML中的id名称为："+beanName);
17     }
18     public int age;
19     private Axe axe;
20     public int getAge() {
21         return age;
22     }
23     public void setAge(int age) {
24         this.age = age;
25     }
26     public Axe getAxe() {
27         return axe;
28     }
29     public void setAxe(Axe axe) {
30         this.axe = axe;
31     }
32     public Chinese() {
33         System.out.println("Spring正在执行默认构造函数构造Chinese实例...");
34     }
35     public Chinese(Axe axe) {
36         this.axe = axe;
37     }
38     public void useAxe() {
39         System.out.println("我打算去砍点柴火");
40         System.out.println("修改beanName="+beanName+","+axe.chop());
41     }
42     public void close() {
43         System.out.println("正在执行销毁前的方法 close ...");
44     }
45     public Son getSon() {
46         return son;
47     }
48     public void setSon(Son son) {
49         this.son = son;
50     }
51     public void init() {
52         System.out.println("正在执行初始化方法init...");
53     }
54     @Override
55     public void afterPropertiesSet() throws Exception {
56         // TODO Auto-generated method stub
57         System.out.println("正在执行初始化方法afterPropertiesSet...");
58     }
59 
60 }

Chinese Bean实现了InitializingBean接口，添加了init()(需要XML配置）方法和afterPropertiesSet()方法，那么它在初始化前后会被插入特定行为，行为由这两个方法决定。同时，由于容器中存在实现了BeanPostProcessor的Bean，那么所有Bean包括chinese，都会在初始化前后批量被插入特定行为。

XML配置如下，

1     <bean id="chinese" class="spi.Chinese" 
2     init-method="init" p:axe-ref="steelAxe" p:beanName="依赖注入的值" />
3     <bean class="spi.MyBeanPostProcessor" />

测试代码，

1     public static void test8() {
2         ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
3         Person p = ctx.getBean("chinese", Person.class);
4         p.useAxe();
5     }

执行结果，

 1 Bean后处理器在初始化之前对 messageSource 进行增强处理...
 2 Bean后处理器在初始化之后对 messageSource 进行增强处理...
 3 Bean后处理器在初始化之前对 stoneAxe 进行增强处理...
 4 Bean后处理器在初始化之后对 stoneAxe 进行增强处理...
 5 Bean后处理器在初始化之前对 steelAxe 进行增强处理...
 6 Bean后处理器在初始化之后对 steelAxe 进行增强处理...
 7 Bean后处理器在初始化之前对 spi.EmailNotifier#0 进行增强处理...
 8 Bean后处理器在初始化之后对 spi.EmailNotifier#0 进行增强处理...
 9 Bean后处理器在初始化之前对 getContextViaBean 进行增强处理...
10 Bean后处理器在初始化之后对 getContextViaBean 进行增强处理...
11 Bean后处理器在初始化之前对 getField 进行增强处理...
12 Bean后处理器在初始化之后对 getField 进行增强处理...
13 Spring正在执行默认构造函数构造Chinese实例...
14 依赖注入的值:Spring正在执行setBeanName()方法注入依赖关系...
15 Bean后处理器在初始化之前对 chinese 进行增强处理...
16 正在执行初始化方法afterPropertiesSet...
17 正在执行初始化方法init...
18 Bean后处理器在初始化之后对 chinese 进行增强处理...
19 Bean后处理器将Chinese.beanName修改为'Java编程'.
20 Java编程:Spring正在执行setBeanName()方法注入依赖关系...
21 我打算去砍点柴火
22 修改beanName=Java编程,钢斧砍柴好快

从执行结果可以看到，受BeanPostProcessor影响，所有Bean都被插入了两条特定行为，chinese Bean由于额外实现了InitializingBean接口而多了两条额外行为。

另外可以看到虽然在配置文件中chinese的beanName被注入的是“依赖注入的值”，但是初始化之后它又被修改成了“Java编程”，所以setBeanName也被调用了两次。

从上面的例子可以看出，BeanPostProcessor接口的作用就是对容器bean进行批量处理，实际中Spring的这种后处理很有用，通常用来实现代理器，

例如BeanNameAutoProxyCreator是根据Bean实例的name属性，创建Bean实例的代理。

DefaultAdvisorProxyCreator是根据提供的Advisor对容器所有Bean实例创建代理。

2.容器后处理器

类似的，容器也有后处理器，专门用来扩展容器的功能。容器后处理器需要实现BeanFactoryPostProcesser接口。

Spring为我们实现了几个容器后处理器，常用的有PropertyPlaceholderConfigurer, PropertyOverrideConfigurer等。

PropertyPlaceholderConfigurer可以用property文件来替换Spring配置文件中的占位符变量，典型用法如，

 1     <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
 2         <property name="locations">
 3             <list>
 4                 <value>dbconn.properties</value>
 5                 <value>dbconn.properties2</value>
 6                 <value>dbconn.properties3</value>
 7             </list>
 8         </property>
 9     </bean>
10     
11     <bean id="dataSource" class="conn.machange.v2.c3p0.ComboPooledDataSource" destroy-method="close"
12         p:driverClass="${jdbc.driverClassName}"
13         p:jdbcUrl="${jdbc.url}"
14         p:user="${jdbc.username}"
15         p:password="${jdbc.password}" />

上面定义的dataSource Bean，并没有直接将值注入driverClass, jdbcUrl等属性中，而是使用${jdbc.driverClassName},${jdbc.url}，

因为有了容器后处理器PropertyPlaceholderConfigurer的存在，Spring会查找对应的外部properties文件并用里面设置的变量替换Spring中的变量，外部properties文件内容如下，

dbconn.properties

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.pawword=123456

另外还有PropertyOverrideConfigurer容器后处理器，这个跟前面有点类似都是用来将Spring配置提取到外部properties文件中，但是功能更强大。

PropertyOverrideConfigurer属性文件指定的信息可以直接覆盖Spring配置的元数据，还是上面的例子，

 1     <bean class="org.springframework.beans.factory.config.PropertyOverrideConfigurer">
 2         <property name="locations">
 3             <list>
 4                 <value>dbconn.properties</value>
 5                 <value>dbconn.properties2</value>
 6                 <value>dbconn.properties3</value>
 7             </list>
 8         </property>
 9     </bean>
10     
11     <bean id="dataSource" class="conn.machange.v2.c3p0.ComboPooledDataSource" 
12     destroy-method="close" />

可以看到dataSource这个bean没有最注入任何属依赖属性，但是在下面的外部properties文件中，却配置了dataSource Bean的属性，注意这里的属性名称必须是Bean确实拥有的才行。

dbconn.properties

dataSource.driverClassName=com.mysql.jdbc.Driver
dataSource.url=jdbc:mysql://localhost:3306/test
dataSource.username=root
dataSource.pawword=123456

3.Spring的Annotation

使用Spring的Annotation可以不用再在XML文件中进行bean的配置，只需要在XML中设置好bean的搜索路径，然后在bean上使用相应的Annotation就行了。

XML配置Bean搜索路径如下，使用<context:component-scan的base-package属性进行配置，

还可以使用<context:include-filter和<context:exclude-filter进行Bean路径的配置，这种配置不需要在Bean类名上加注解，容器就能自动识别出bean

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xmlns:context="http://www.springframework.org/schema/context"
 5     xsi:schemaLocation="http://www.springframework.org/schema/beans
 6     http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
 7     http://www.springframework.org/schema/context
 8     http://www.springframework.org/schema/context/spring-context-4.0.xsd">
 9     <!-- 自动扫描指定包及其子包下的所有Bean类 -->
10     <context:component-scan base-package="spi" />
11     <context:include-filter type="regex" expression=".*Chinese" />
12     <context:exclude-filter type="regex" expression="Stone*" />
13 </beans>

3.1@Componnet

接着我们只需要将Bean类名加上Annotation注解就行了，Spring可以使用@Component, @Controller, @Service, @Repository四种注解将一个类标识为容器中的bean，最常用的是@Component.

 1 @Component
 2 public class Chinese implements Person, InitializingBean {
 3 ...
 4 
 5 @Component
 6 public class SteelAxe implements Axe { 
 7 ...
 8 
 9 @Component
10 public class StoneAxe implements Axe { 
11 ...

3.2@Scope

@Scope用来指定Bean的作用域，与XML配置中的scope属性意义一样

1 @Scope("prototype")
2 @Component
3 public class Chinese implements Person, InitializingBean {
4 ...

3.3@Resource

Spring通过@Resource设置依赖关系，用来修饰setter方法，相当于XML配置中的<property>元素，@Resource中有一个name属性，为name属性设置值就相当于设置ref属性。

1     @Resource(name="stoneAxe")
2     public void setAge(int age) {
3         this.age = age;
4     }

@Resource也可以直接修饰实例变量，一样会进行依赖注入，并且括号中的name可以省略，

1     @Resource(name="stoneAxe")
2     private Axe axe;
3 //或者
4     @Resource(”stoneAxe")
5     private Axe axe;

3.4@PostConstruct和@PreDestroy

这两个注解相当于XML中的init-method和destroy-method属性，会在bean初始化期间添加额外行为，只不过这两个注解不需要任何属性值，直接将注解放在对应的方法上即可

1     @PostConstruct
2     public void init() {
3         System.out.println("正在执行初始化方法init...");
4     }
5     @PreDestroy
6     public void afterPropertiesSet() throws Exception {
7         // TODO Auto-generated method stub
8         System.out.println("正在执行初始化方法afterPropertiesSet...");
9     }

3.5@DependsOn和@Lazy

@DependsOn用于强制初始化其他（依赖的）多个bean，以数组形式作为此注解的参数值，

1 @DependsOn({"steelAxe","stoneAxe"})
2 @Scope("prototype")
3 @Component
4 public class Chinese implements Person, InitializingBean {
5 ...

3.6@Autowired

Spring4.0中的@Autowired进行了功能增强，可以用来修饰setter方法，普通方法，实例变量和构造器，甚至是数组变量。默认使用byType（按参数类型）自动装配策略。

 1     // 修饰setter方法
 2     @Autowired
 3     public void setAge(int age) {
 4         this.age = age;
 5     }
 6 ...
 7     //修饰普通方法，支持多个参数
 8     @Autowired
 9     public void test(Axe axe, Person person) {
10         
11     }
12 ...
13     //修饰成员变量
14     @Autowired
15     private Axe axe;
16 ...
17     //修饰构造器
18     @Autowired
19     public Chinese(Axe axe) {
20         this.axe = axe;
21     }
22 ...
23     //修饰数组，Spring会先收集类型相符的bean，构造数组，然后进行依赖注入
24     @Autowired
25     private Axe[] axes;
26 ...

需要注意的是，@Autowired除了修饰数组之外，对于其他情况（setter方法，普通方法，成员变量，构造函数），如果Spring在容器中找到超过一个符合类型的bean，将会报错

@Autowired默认使用byType策略进行依赖注入时bean的查找，如果希望指定依赖注入的bean id，则需要使用@Qualifier

1     @Qualifier("steelAxe")
2     private Axe axe;

当然，这么做就没什么意义了，因为@Resource完全可以实现这个功能，@Qualifier还有个用处就是可以指定方法形参时的依赖注入，

1     public void setAxe(@Qualifier("steelAxe") Axe axe) {
2         this.axe = axe;
3     }

4.Resource接口

Spring提供了一个Resource接口用来访问资源，其底层是封装了各种各种资源的访问方式，例如网络资源，本地资源，二进制数据等等，

通过Resource实现类的对象，可以对资源进行统一方式的操作，还可以通过Rescource实现类的对象获取资源的File实例，以java IO的方式操作资源。

Resource提供如下对资源的统一访问方法：getInputStream(), exists(), isOpen(), getDescription(), getFile(), getUrl()。

Spring为Resource默认已经实现了如下类：UrlResource, ClassPathResource, FileSystemResource, ServletContextResource, InputStreamResource, ByteArrayResource.

下面是几个实现类的用法，

 1     public static void test10() throws IOException {
 2         UrlResource ur = new UrlResource("file:book.xml");
 3         //ClassPathResource ur = new ClassPathResource("book.xml");
 4         //FileSystemResource ur = new FileSystemResource("book.xml");
 5         //ServletContextResource ur = new ServletContextResource(application,"WEB-INF/book.xml");
 6         //String file="Java编程核心思想";
 7         //byte[] fileBytes = file.getBytes();
 8         //ByteArrayResource ur = new ByteArrayResource(fileBytes);
 9         System.out.println(ur.getFilename());
10         System.out.println(ur.getDescription());
11         File file = ur.getFile();
12         System.out.println(file.getName());
13     }

可以看到上面代码中，对于每一种Resource实现类，在Spring使用时仅仅是获取资源的方式不同，但是操作文件和数据一模一样，都是通过Resourcce实现类获取资源对象，以相同方法获取资源信息，都可以转化为File实例进行后续操作，当然对于二进制数据就没有文件的说法，所以getFileName之类的方法是不起作用的。

另外还注意到，不同的Resource实现类在获取资源时，传入的参数类型不尽相同，有的需要http:前缀，有的需要file:前缀，有的不需要前缀，这是由实现类的底层性质针对不同类型的资源决定的。

5.ResourceLoader和ResourceLoaderAware接口

在上面的例子中，我们总是需要显式地写出要使用哪个Resource的实现类来获取资源，这显得比较麻烦，Spring又为我们提供了两个接口，

ResourceLoader 用来获取一个Resource实例

ResourceLoaderAware 获取Resource实例的引用

通过ResourceLoader，我们可以实现面向接口的编程，直接获取一个资源，

由于ApplicationContext类也实现了ResourceLoader接口，所以可以直接把ApplicationContext当作一个ResourceLoader，用ApplicationContext实例去获取一个资源，像这样：

1 Resource res =ctx.getResource("beans2.xml");

这样就直接获取了一个资源实例，简化了编程，不过这样获取的资源，其底层是通过什么方式（即由哪个Resource的实现类）来获取资源的呢，

Spring采用的是典型的策略模式，根据ApplicationContext实例化时候的策略，来决定这里获取Resource的策略。应用程序只需要使用统一的接口，调用相同的实现方法，而不需要关系底层到底是用了哪个实现类。

如果ApplicationContext实例化使用的是ClassPathXmlApplicationContext方式，那么Resource就是采用ClassPathResource实现类；

如果ApplicationContext实例化使用的是FileSystemXmlApplicationContext方式，那么Resource就是采用FileSystemResource实现类，

以此类推。

因此前面获取资源的代码我们就可以简化如下：

1     public static void test11() throws IOException {
2         ApplicationContext ctx = new ClassPathXmlApplicationContext("beans2.xml");
3         //ApplicationContext ctx = new FileSystemXmlApplicationContext("beans2.xml");
4         Resource res =ctx.getResource("beans2.xml");
5         System.out.println(res.getFilename());
6         System.out.println(res.getDescription());
7         File file = res.getFile();
8         System.out.println(file.getName());
9     }

这样就将获取资源的Resource实现类解耦了，我们只需要直接使用Resource接口即可。

当然，如果你非要指定具体的Resource实现类也是可以的，只需要在ctx.getResource(..)时，在传入的参数前加不同的前缀，例如

1         //无前缀表示由ApplicationContext来决定加载策略
2         Resource res =ctx.getResource("beans2.xml");
3         //以ClassPathResource访问类加载路径下的资源
4         Resource res =ctx.getResource("classpath:beans2.xml");
5         //以UrlResource实例访问本地系统
6         Resource res =ctx.getResource("file:beans2.xml");
7         //以UrlResource实例访问基于HTTP的网络资源
8         Resource res =ctx.getResource("http:beans2.xml");

6.将Resource实例作为Bean属性

比ResourceLoader更能解耦的方式是直接将Resource的实例作为Bean的属性，这样就能直接在XML文件中配置需要访问的资源名称，例如这样，

1 public class Chinese implements Person, InitializingBean {
2     private Resource res;
3     public Resource getRes() {
4         return res;
5     }
6     public void setRes(Resource res) {
7         this.res = res;
8     }
9 ...

这样便可以将具体的资源名称写入配置文件，使得能最大显得地将资源名称与具体java代码解耦

<bean id="chinese" class="spi.Chinese" p:res="classpath:book.xml" />