Java Spring DI之旅

做过.NET的人很多都用过Microsoft Enterprise Library，里面有一个Dependency injection工具Unity，我们可以使用它来实现依赖注入；什么是依赖注入呢？我个人认为依赖注入就是脱藕，当类A一个对象要引用另外一个类B对象才能完成操作时，我们说两个类之间具有依赖关系；如果类A只是通过类B实现的接口来引用类B的对象，我们说这两个类之间是松耦合的；那么我们如何通过一种更灵活的方式把类B的对象赋值给类A对象，使得类A对象根本不需要了解到B这个类的存在，这种方式叫做依赖注入。

在Java中，Spring作为开发利器，其核心就是DI和AOP；我们只需要在xml中配置好类A的对象生成过程，然后调用上下文方法，Spring就会为我们创造出一个类A的对象，至于如何把B类的一个对象创建出来并赋给类A对象的，我们不需要关心，并且类A在编码时都无需知道类B的存在，一切将由Spring自动完成。

那么我们来看看如何构造这个类A对象的创建过程，通常来讲我们把Java中需要用Spring来创建的对象都称之为Bean，而把这个创建的过程叫做装配。

如何申明Bean

申明Bean的方式有两种，一种是通过一个或多个xml文件作为配置文件，还有一种是使用Java注解。

我们现在主要讲前面这种方式：

<bean id="objA" class="com.company.project.A"></bean>
<bean id="objB" class="com.company.project.B"></bean>

我们现在申明了两个Bean，由于类A的对象需要使用到类B的对象，如何讲类B对象告知类A对象？假如类A对象有一个构造函数需要传入类B对象的值：

public A(B obj)
{
   .....   
}

那么我们可以使用构造函数注入：

<bean id="objA" class="com.company.project.A">
   <constructor-arg ref="objB"/>
</bean>
<bean id="objB" class="com.company.project.B"></bean>

如果类B只有一个单列对象，如：

public class B
{
   private B(){}

   private static class BSingletonHodler
   {
      static B instance = new B();
   }

   private static B getSingletonInstance()
   {
      return BSingletonHodler.instance;
   } 
}

那么我们的配置应该是：

<bean id="objB" class="com.company.project.B" factory-method="getSingletonInstance"></bean>

注意，所有通过Spring上下文来创建的bean都是单列的，也就是说每一次通过相同的id来得到一个bean时，都得到的是相同的对象，我们可以通过xml中bean元素的scope属性来改变这种行为；

还有一种情况，我们需要Spring在构造一个bean对象成功之后，或者在销毁一个bean之前执行这个bean的一个方法，应该这样使用：

<bean id="objA" class="com.company.project.A" init-method="构造完成后执行的方法" destory-method="销毁之前执行的方法">
   <constructor-arg ref="objB"/>
</bean>

如果类A只是通过一个属性引用了类B的对象，而并非构造函数：

public class A
{
   public A(){}
   private B b;
   public B getB()
   {
      return b;
   }
   public void setB(B obj)
   {
      b = obj;
   }
}

那么我们需要属性注入：

<bean id="objA" class="com.company.project.A">
   <property name="b" ref="objB"/>
</bean>
<bean id="objB" class="com.company.project.B"></bean>

或者使用一种内嵌的方式：

<bean id="objA" class="com.company.project.A">
   <property name="b">
      <bean class="com.company.project.B"></bean>
   </property>
</bean>

或者：

<bean id="objA" class="com.company.project.A" p:b-ref="objB">
</bean>

采用这种方式时，应该在文件头申明xmlns:p="http://ww.springframework.org/schema/p"这个命名空间，加-ref后缀是用来告知spring应该装配一个bean，而不是一个字面量。

如果类A不是需要的一个类B的对象，而是一个类B对象的集合，如：

public class A
{
   public A(){}
   private Collection<B> bList;
   public void setBList(Collection<B> bList)
   {
      this.bList = bList;
   }
}

我们可以使用：

<bean id="objA" class="com.company.project.A">
   <property name="bList">
      <list>
         <ref bean="objB"/>
         <ref bean="objB"/>
         <null/><!--插入一个空值-->
      </list>
   </property>
</bean>
<bean id="objB" class="com.company.project.B" scope="prototype"></bean>

如果类A接受一个Map集合：

public class A
{
   public A(){}
   private Map<string,B> maps;
   public void setMaps(Map<string,B> maps)
   {
      this.maps = maps;
   }
}
public class B{...}

我们应该使用：

<bean id="objA" class="com.company.project.A">
   <property name="maps">
      <map>
         <entry key="b1" value-ref="objB"/>
         <entry key="b2" value-ref="objB"/>
      </map>
   </property>
</bean>
<bean id="objB" class="com.company.project.B" scope="prototype"></bean>

如果类A需要装配一个properties:

public class A
{
   private Properties properties;
   public void setProperties(Properties properties)
   {
      this.properties = properties;
   }
   public A(){ ... }
}

我们可以在Spring配置文件中做如下配置：

<bean id="objA" class="com.company.project.A">
   <property name="properties">
      <props>
         <prop key="JOEL">STRUM</prop>
         <prop key="Cymbal">SRASH</prop>
         <prop key="Harmonica">HUM</prop>
      </props>
   </property>
</bean>

使用表达式来提供装配值
自Spring3提供了Spring表达式语言（即SpEL）以来，我们便可以在配置文件中使用运行时执行的表达式将值装配到Bean的属性或构造器参数中。所有的SpEL都应该放置到以#{}为界定符的标记里面，如提供一个Integer常量表达式：
```
<property name="message" value="The value is #{5}"></property>
```
字符串常量表达式应该使用单引号或者双引号作为界定符：
```
<property name="message" value="#{'This is a message'}"></property>
```
Boolean类型的常量表达式：
```
<property name="enabled" value="#{true}"></property>
```
我们可以在SpEL中通过ID引用其他的bean：
```
<property name="b" value="#{objB}"></property>
```
或者引用其他Bean的一个属性：
```
<property name="message" value="#{objB.message}"/>
```
或者其他Bean的一个方法：
```
<property name="message" value="#{objB.getMessage()}"/>
```
如果上例中message属性只能接收大写字母，但是我们不能确定objB.getMessage()返回null，如果返回null，我们则不需要调用toUpperCase()方法，我们可以利用?.符号：
```
<property message="message" value="#{objB.getMessage()?.toUpperCase()}"/>
```
利用一个静态属性或方法的返回值对某个属性进行装配：
```
<property name="pi" value="#{T(java.lang.Math).PI}"/>
```
在表达式中也可以使用算数运算符：
```
<property name="amount" value="#{counter.total + 5}"/>
```
在表达式中使用比较操作符时，应该使用相应的文本类型，如：==(eq)，<(lt)，<=(le)，>(gt)，>=(ge)，如：
```
<property name="hasCapacity" value="#{counter.total le 100000}"/>
```
也可以使用逻辑操作符：and or not

有时候我们希望在某个条件为true时，SpEL表达式的求值结果为是某个值；当条件为false时，求值结果是另一个值：
```
<property name="message" value="#{objB.message != null ? objB.message : 'this is a message'}"/>
```
上面也可以简写为：
```
<property name="message" value="#{objB.message ?: 'this is a message'}"/>
```
在SpEL中使用正则表达式:
```
<property name="isValid" value="#{admin.email matches '[a-zA-Z0-9._%+_]'}"/>
```
SpEL作用于集合，假设我们有这样一个类：
```
package com.thoughtworks.demo.core;

public class Student {
    private String name;
    public void setName(String name)
    {
        this.name = name;
    }
}
```
我们可以在Spring里面利用util:list来构建一个Student对象的List：
```
<util:list id="students">
   <bean class="com.thoughtworks.demo.core.Student" p:name="Josen"></bean>
   <bean class="com.thoughtworks.demo.core.Student" p:name="Cindy"></bean>
   <bean class="com.thoughtworks.demo.core.Student" p:name="Baby"></bean>
</util:list>
```
前提是我们必须在文件头加入xmlns:util="http://www.springframework.org/schema/util"命名空间，并在xsi:schemaLocation加入了http://www.springframework.org/schema/util和http://www.springframework.org/schema/util/spring-util-2.0.xsd

如果我们要在集合中提取一个成员，我们应该使用：
```
<property name="chosenStudent" values="#{students[1]}"/>
```
我们也可以使用util:properties来构造一个properties文件的bean，如：
```
<util:properties id="settings" location="classpath:settings.properties">
</util:properties>
<bean id="man" class="com.thoughtworks.demo.core.Student">
   <property name="name" value="#{settings['project.name']}"></property>
</bean>
```

自动装配

自动装配的意思是我们无需指定由哪一个bean来装配，spring会按照我们指定的规则去寻找相应的bean，自动装配有4种类型：

byName：如果某个bean的ID与property的名字一样，则这个bean就会自动装配；
byType：如果某个bean的类型与property的类型一致，则这个bean会被自动装配；
constructor：假设通过构造器注入来装配bean，我们让spring在应用上下文中自动选择与入参类型相同的Bean注入到构造器参数中
autodetect：Spring首先尝试constructor自动装配，如果没有发现与构造器相匹配的Bean，Spring会尝试使用byType自动装配。

注意，前两者是针对要装配的bean的所有property而言的，当然我们也可以为某个property提供独特的装配方案，而constructor则不行，我们不能为某个构造器入参提供独特的装配方案，假设我们有一个类Teacher引用了Student类：

public class Teacher {
    private Student student;
    public void setStudent(Student student)
    {
        this.student = student;
    }
    public Student getStudent()
    {
        return this.student;
    }
    
    private String name;
    public void setName(String name)
    {
        this.name = name;
    }
}

我们按照byName的方式来完成student这个property的自动装配：

<bean id="student" class="com.thoughtworks.demo.core.Student">
    <property name="name" value="Josen"></property>
</bean>
<bean id="teacher" class="com.thoughtworks.demo.core.Teacher" autowire="byName">
    <property name="name" value="Alex"/>
</bean>

或者按照byType来自动装配：

<bean id="student" class="com.thoughtworks.demo.core.Student">
   <property name="name" value="Josen"></property>
</bean>
<bean id="teacher" class="com.thoughtworks.demo.core.Teacher" autowire="byType">
   <property name="name" value="Alex"/><!-- 注意，这里为name property提供了独特的装配方案 -->
</bean>

当Teacher类有一个构造函数的时候：

public class Teacher {
    private Student student;
    public void setStudent(Student student)
    {
        this.student = student;
    }
    public Student getStudent()
    {
        return this.student;
    }
    
    private String name;
    public void setName(String name)
    {
        this.name = name;
    }
    
    public Teacher(Student stu)
    {
        this.student = stu;
    }
}

我们使用constructor自动装配：

<bean id="student" class="com.thoughtworks.demo.core.Student">
   <property name="name" value="Josen"></property>
</bean>
<bean id="teacher" class="com.thoughtworks.demo.core.Teacher" autowire="constructor">
   <property name="name" value="Alex"/><!-- 注意，这里为name property提供了独特的装配方案 -->
</bean>

注解装配
注解装配属于自动装配的范畴，如果我们为某个属性或者属性的setter方法添加了@Autowired，那么这个属性将由Spring按照byType的方式进行自动装配：
```
public class Teacher {
    private Student student;
    @Autowired //按照 byType方式自动装配
    public void setStudent(Student student)
    {
        this.student = student;
    }
    public Student getStudent()
    {
        return this.student;
    }
    
    @Value("Cindy") //提供常量值的注解装配
    private String name;
    public void setName(String name)
    {
        this.name = name;
    }
}
```
注意，Spring默认禁用注解装配，所以在使用注解装配之前，应在配置文件中配置它，首先加入xmlns:context="http://www.springframework.org/schema/context"命名空间，然后在xsi:schemaLocation里面加入http://www.springframework.org/schema/context和http://www.springframework.org/schema/context/spring-context-3.0.xsd，最后在beans下加入
```
<context:annotation-config/>
```
配置节点。

我们也可以使用@Autowired来注解构造器，那么Spring将按照constructor的自动注解方式完成bean的装配，假如我们注解了多个构造器，Spring将会从满足条件的构造器中选择参数最多的那个构造器

这里有一个问题，在视同@Autowired来注解属性的时候，假如Spring找不到类型相同的bean，那么spring会抛出异常；这时我们可以使用@Autowired(required=false)方式来注解属性，假如Spring找不到类型相同的bean，则会装配一个null值

我们也可以使用@Qualifier注解来把@Autowired的byType自动装配转化为byName自动装配，但是@Qualifier必须和@Autowired一起使用：
```
public class Teacher {
    private Student student;
    @Autowired
    @Qualifier("student")
    public void setStudent(Student student)
    {
        this.student = student;
    }
    public Student getStudent()
    {
        return this.student;
    }
    
    @Value("Cindy")
    private String name;
    public void setName(String name)
    {
        this.name = name;
    }
}
```