Spring的IOC容器—依赖注入

前面一篇博客大致讲了一下Spring的IOC容器的原理，IOC即控制反转主要是依靠依赖注入的方式来实现的。依赖注入是指所依赖的对象不是由自己new出来的，而是用别的方式像打针似的注入进来。 其实说白了不管是控制反转还是依赖注入都说明了Spring采用动态、灵活的方式来管理各种对象。

Spring的依赖注入对调用者和被调用者几乎没有任何要求，完全支持对POJO之间依赖关系的管理。有以下几种注入方式： 

1. Setter 注入


因为对于javaBean来说，我们可以通过setter和getter方法分别改变对象和获取对象的属性。所以当前对象只要为其依赖对象所对应的属性添加setter方法，就可以通过setter方法将相应的依赖对象设置到被注入对象中。例如下面的代码：

 . Person接口

 

package com.tgb.depency;
/**
* 定义Person接口
* @author MINGXUANYUN
*
*/
public interface Person {

//定义一个吃东西的方法
public void eatSomething();

//定义一个个人信息方法
public String personInfo();
}

.Eat接口

package com.tgb.depency;
public interface Eat {
//定义一个吃苹果的方法
public String eatApple();

}

.Person的实现类

/**
* Person的实现类
* @author MINGXUANYUN
*/
public class Huohuo implements Person{

private Eat eat;
//默认的构造器
public Huohuo(){}

public Eat getEat() {
return eat;
}
public void setEat(Eat eat) {
this.eat = eat;
}

//实现Person吃东西的方法
@Override
public void eatSomething() {
System.out.println(eat.eatApple());
}

@Override
public String personInfo() {
return null;
}
}

.Eat的实现类

/**
* 大口大口吃
* @author MINGXUANYUN
*/
public class WideMouthEat implements Eat {

@Override
public String eatApple() {
return"张大嘴巴吃苹果很粗鲁的！！！";
}
}

.配置文件，将Person实例和Eat实例组织在一起

<!--Setter注入测试实例 -->
<bean id="Huohuo" class= "com.tgb.depencyimpl.Huohuo">
<property name="eat" ref="WideMouthEat"></property>
</bean>
<bean id="WideMouthEat" class="com.tgb.depencyimpl.WideMouthEat">
</bean>

从以上例子可以看出：Spring将bean与bean之间的依赖关系放到配置文件里管理，而不是写在代码里。通过配置文件，Spring精确的为每个bean注入每个属性。<bean>中的name属性是class属性的一个别名，class属性指真正的实现类（类的全名）。Spring自动接管每个bean里的 property元素定义。Spring再执行无参数的构造器，创建默认的bean后，调用对应的setter方法为程序注入属性值。

.主程序

public class SetterTest {

public static void main(String[] args) {
//实例化Spring的上下文
ApplicationContext ctx = new FileSystemXmlApplicationContext("bean.xml");
//强制转换接口类型
Person person = (Person) ctx.getBean("Huohuo");
//执行Person的eatSomething方法
person.eatSomething();
}

}

.运行结果输出 ：

                    
张大嘴巴吃苹果很粗鲁的！！！

说明： 主程序调用person.eatSomething方法，该方法方法体里需要有Eat的实例，但主程序里并没有任何地方为Person实例传入Eat实例，Eat实例是由Spring在运行期间动态注入的。Person实例不需要了解Eat实例的具体实现和创建过程。程序运行到Eat实例的时候，Spring自动创建Eat实例，然后注入给它的调用者，Person实例运行到需要Eat实例的时候，自动产生Eat实例。

这样有什么好处呢？如果我们需要另一个Eat实现类来为Person类使用。Person和其实现类都无需改变。只需要增加一个Eat的实现类，并在配置文件中配置就可以。

例如，增加Eat实现类ChewslowlyEat

import com.tgb.depency.Eat;

public class ChewslowlyEat implements Eat {
@Override
public String eatApple() {
return "细嚼慢咽淑女的典范！！";
}
}

修改配置文件：

<bean id="Huohuo" class= "com.tgb.depencyimpl.Huohuo">
　　　<property name="eat" ref="ChewslowlyEat"></property>
</bean>
<bean id="ChewslowlyEat" class="com.tgb.depencyimpl.ChewslowlyEat"></bean>

输出结果：

　　　　细嚼慢咽淑女的典范！！

2. 构造器注入

　 指被注入对象通过在其构造函数中声明依赖对象的参数列表。

.定义一个Person实现类，用于构造器注入

/**
* 构造器注入测试
* @author MINGXUANYUN
*/
public class Yunyun implements Person{
    private String userName;
    private String kind;
    private Eat eat;
    //默认构造方法
    public Yunyun(){};
    //构造注入所需的带参数构造器
    public Yunyun(Eat eat,String userName,String kind){
        this.eat = eat;
        this.userName = userName;
        this.kind = kind;
    }
    @Override
    public String personInfo() {
        return userName + "永远" + kind +"岁" + "----" + eat.eatApple();
    }
    @Override
    public void eatSomething() {
        // TODO Auto-generated method stub    
    }
}

在构造Yunyun实例时，创建三个成员变量userName、kind和对象类型的eat。但是并没有设置setter方法。在构造Person实例时，Spring为Person实例注入所依赖的Eat实例并且为两个成员变量赋值。构造注入的配置文件如下：

.xml配置文件

<!--构造器注入配置实例 -->
        <bean id="Yunyun" class= "com.tgb.depencyimpl.Yunyun">
        <constructor-arg index="0" ref="ChewslowlyEat"></constructor-arg>
        <constructor-arg index="1">  
            <value>朱火云 </value>  
          </constructor-arg>  
          <constructor-arg index="2">  
            <value>18</value>  
          </constructor-arg>
        </bean>  
        <bean id="ChewslowlyEat" class="com.tgb.depencyimpl.ChewslowlyEat"/>

在配置文件中，不用<property>的形式，而是使用<constructor-arg>标签。ref属性指向其它<bean>标签的name属性。由于我们可能传入多个类型一致的构造参数。所以可以用type和index确定我们使用的哪一个构造函数。

.主程序

public class ConstructorTest {

public static void main(String[] args) {
String fileName = "bean.xml";
ApplicationContext ac = new FileSystemXmlApplicationContext(fileName);
// 取得一个实例
Yunyun yunyun =  (Yunyun) ac.getBean("Yunyun");
System.out.println(yunyun.personInfo());
}
}

输出结果：

             
朱火云 永远18岁细嚼慢咽淑女的典范！！

3.静态工厂方法注入


    指通过调用静态工厂的方法来获取自己需要的对象。

.定义一个UserDao类

public class UserDao {
public static UserDao getInstance(){
return new UserDao("static factory method");
}

private String name="";
public UserDao(String name){
this.name = name;
}

public void create(){
System.out.println("create user from-" + name);
}
}

.定义一个UserManager类

import com.tgb.depency.UserDao;

public class UserManager {
//注入UserDao对象
private UserDao userDao;
public void createUser(){
userDao.create();
}
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public UserDao getUserDao() {
return userDao;
}
}

.xml配置文件

<!-- 静态工厂方法注入 -->
<bean name="userManager" class="com.tgb.depencyimpl.UserManager">
<property name="userDao" ref="userDao"></property>
</bean>
<bean name="userDao" class="com.tgb.depency.UserDao" factory-method="getInstance">
</bean>

factory-menthod定义了userDao 。Bean使用UserDao类的getInstance方法来创建自己的实例。

.主程序

public class StaticFactoryTest {

public static void main(String[] args) {
String fileName = "bean.xml";
ApplicationContext ac = new FileSystemXmlApplicationContext(fileName);
UserManager userManager = (UserManager) ac.getBean("userManager");
userManager.createUser();
}
}

输出结果：

                create user from-static factory method

总结：我们原来学三层的时候，UI层调用BLL、BLL调用DAO层。各层与各层之间虽然抽象出了接口层，调用接口。但是在new的时候指向的还是具体的实现。而现在Spring有效的管理各层之间对象的调用。 不管是Action调用Services对象，还是Services调用Dao对象，Spring以松耦合的方式将它们组织在一起。各层之间不需要关心对象间的具体实现，以及如何创建，完全面向接口编程。