Spring依赖注入（DI）

DI是什么？

  di（dependencyinjection）依赖注入：实际上DI和IOC是同一个概念，因为在ApplicationContext.xml配置文件中bean和bean之间通过ref来维护的时候是相互依赖的，所以又叫做依赖注入。也就是控制反转。

因为ApplicationContext是非常消耗内存的，所以必须保证一个项目里只有一个ApplicationContext实例：

那么如何保证这有一个实例呢，就需要把ApplicationContext对象做成单例形式，如何提取单例：？？？

packagecom.util;

 

importorg.springframework.context.ApplicationContext;
importorg.springframework.context.support.ClassPathXmlApplicationContext;

 

final publicclass ApplicationContextUtil {
private staticApplicationContext ac = null;

//提供一个构造方法
privateApplicationContextUtil(){

}

static{
ac= newClassPathXmlApplicationContext("applicationContext.xml");
}
//提供一个方法供外面使用
public staticApplicationContext getApplicationContext(){
returnac;
}
}

<!--这里就是注入的概念 通过注入设置name and id相当于set方法在使用的时候用get方法-->
<beanid="userBean"class="com.bean.UserBean">
<propertyname="id"value="1"></property>
<propertyname="name"value="leilei"></property>
<propertyname="age"value="25"></property>
</bean>

<!--这里可以配置多个Bean类,main方法里使用的时候直接用ac.getBean（）-->
<beanid="adminBean"class="com.bean.AdminBean">
<propertyname="id"value="2"></property>
<propertyname="name"value="lele"></property>
<propertyname="password"value="aihenmei"></property>
<!--这里是在一个Bean中引用另外一个Bean需要配置属性注意ref是你在配置文件里配置的那个对应的Bean的id 
name是你bean类里的getset的字段名-->
<propertyname="userBean"ref="userBean"></property>
</bean>

public staticvoid main(String[] args) {
//这里调用要实例化applicationContext

ApplicationContextac =ApplicationContextUtil.getApplicationContext();

AdminBean ad =(AdminBean)ac.getBean("adminBean");//这里填写的是"applicationContext.xml"里bean的id
ad.adminInfo();
}

spring依赖注入（DI）的三种方式，分别为：

1．  接口注入

2．  Setter方法注入

3．  构造方法注入

 

下面介绍一下这三种依赖注入在Spring中是怎么样实现的。

 

首先我们需要以下几个类：

接口 Logic.Java

接口实现类 LogicImpl.java

一个处理类 LoginAction.java

还有一个测试类 TestMain.java

 

Logic.java如下：

package com.spring.test.di;

 

public interface Logic {

    public String getName();

}

 

LogicImpl.java如下：

package com.spring.test.di;

 

public class LogicImpl implements Logic{

   

    public String getName(){

       return "fengyun";

    }

}

TestMain.java

 

package com.spring.test.di;

 

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.FileSystemXmlApplicationContext;

 

public class TestMain {

 

    /**

     * @param args

     */

    public static void main(String[] args) {

 

       // 得到ApplicationContext对象

       ApplicationContext ctx = new FileSystemXmlApplicationContext(

              "applicationContext.xml");

       // 得到Bean

       LoginAction loginAction = (LoginAction) ctx.getBean("loginAction");

      

       loginAction.execute();

    }

 

}

LoginAction.java 会根据使用不同的注入方法而稍有不同

 

下面按照注入的方法来看LoginAction.java类

 

Setter方法注入：

 

package com.spring.test.di;

 

public class LoginAction {

 

    private Logic logic;

 

    public void execute() {

       String name = logic.getName();

       System.out.print("My Name Is " + name);  

    }

 

    /**

     * @return the logic

     */

    public Logic getLogic() {

       return logic;

    }

 

    /**

     * @param logic

     *            the logic to set

     */

    public void setLogic(Logic logic) {

       this.logic = logic;

    }

 

}

定义了一个Logic 类型的变量 logic, 在LoginAction并没有对logic 进行实例化，而只有他对应的setter/getter方法，因为我们这里使用的是Spring的依赖注入的方式

 

applicationContext.xml配置文件如下:

<bean id="logic" class="com.spring.test.di.LogicImpl"/>

<bean id="loginAction" class="com.spring.test.di.LoginAction">

 <property name="logic" ref="logic"></property>

</bean>

现在可以运行testMain.java了，我们可以看到控制台打出了 My Name Is fengyun

 

OK了，这就是spring的setter方法注入，非常简单

 

下面我们来看看构造方法注入

顾名思义，构造方法注入，就是我们依靠LoginAction的构造方法来达到DI的目的，如下所示：

LoginAction.java

package com.spring.test.di;

 

public class LoginAction {

 

    private Logic logic;

 

    public LoginAction(Logic logic) {

       this.logic = logic;

    }

 

    public void execute() {

       String name = logic.getName();

       System.out.print("My Name Is " + name);

    }

}

 

这里我们添加了一个LoginAction的构造方法

applicationContext.xml配置文件如下:

<bean id="logic" class="com.spring.test.di.LogicImpl"/>

<bean id="loginAction" class="com.spring.test.di.LoginAction">

 <constructor-arg index="0" ref="logic"></constructor-arg>

</bean>

我们使用constructor-arg来进行配置, index属性是用来表示构造方法中参数的顺序的，如果有多个参数，则按照顺序，从 0,1...来配置

 

我们现在可以运行testMain.java了,结果跟使用Setter方法注入完全一样.

 

 

其中需要注意一点有：构造函数有多个参数的话，如：参数1，参数2，而参数2依赖于参数1，这中情况则要注意构造函数的顺序，必须将参数1放在参数2之前。

 

下面继续说说我们不常用到的接口注入，还是以LogicAction为例，我们对他进行了修改，如下所示：

LogicAction.java

package com.spring.test.di;

 

public class LoginAction {

 

    private Logic logic;

 

    public void execute() {

       try {

           Object obj = Class.forName("com.spring.test.di.LogicImpl")

                  .newInstance();

           logic = (Logic) obj;

           String name = logic.getName();

           System.out.print("My Name Is " + name);

       } catch (Exception e) {

           e.printStackTrace();

       }

    }

}

配置文件：

<bean id="logic" class="com.spring.test.di.LogicImpl"/>

<bean id="loginAction" class="com.spring.test.di.LoginAction">

</bean>

对于接口注入这种方式，以上也只是我个人理解，不知道是否有什么问题。呵呵

 

我们最常用就是Setter和构造函数这两种注入方法，至于他们各自的对比，我想在只要baidu一下就可以有清楚的答案了。

 

对于Spring的依赖注入，最重要的就是理解他的，一旦理解了，将会觉得非常的简单。无非就是让容器来给我们实例化那些类，我们要做的就是给容器提供这个接口，这个接口就我们的set方法或者构造函数了。