依赖注入的两种方式并附上例子

1.依赖注入：就是指程序在运行过程中，如果需要另外一个对象协助完成时，无需在代码中创建被调用者，而是依赖外部的注入获取。

2.依赖注入的两种方式：

设置注入：设置注入是通过setter方法注入被调用者的实例。

构造注入：利用构造方法来设置依赖注入的方式称为构造注入。

3.接下来附上例子来说明设置注入

(1).首先，附上设置注入的例子，新建一个Java项目，配置好spring后，即可，项目结构图如下图所示：

(2).首先，新建2个接口，一个Animal接口，一个Person接口，其中Animal接口有一个抽象的用途方法，就是动物是用来干嘛的，其中Person接口有一个饲养的方法。

Animal.java文件代码如下：

[java] view plain copy

1. package com.inter;  
2.   
3. public interface Animal {  
4.     void use();//定义抽象的用途方法  
5. }  

Person.java文件代码如下：

[java] view plain copy

1. package com.inter;  
2.   
3. public interface Person {  
4.     void raise();//定义抽象的饲养方法  
5. }  

(3).接着新建3个类，放在com.bean包下，分别为Dog、Cat、Businessman类，其中Dog、Cat类的use方法只输出一句话，Businessman类中有个Animal对象属性，并有其对应的setter方法，有一个raise方法，也是简单的输出和调用方法。

Dog.java文件代码如下：

[java] view plain copy

1. package com.bean;  
2.   
3. import com.inter.Animal;  
4.   
5. public class Dog implements Animal{  
6.   
7.     @Override  
8.     public void use() {  
9.         // TODO Auto-generated method stub  
10.         System.out.println("狗的用途是看家");  
11.     }  
12.   
13. }  

Cat.java文件代码如下：

[java] view plain copy

1. package com.bean;  
2.   
3. import com.inter.Animal;  
4.   
5. public class Cat implements Animal{  
6.   
7.     @Override  
8.     public void use() {  
9.         // TODO Auto-generated method stub  
10.         System.out.println("猫的用途是捉老鼠");  
11.     }  
12.   
13. }  

Businessman.java文件代码如下：

[java] view plain copy

1. package com.bean;  
2.   
3. import com.inter.Animal;  
4. import com.inter.Person;  
5.   
6. public class Businessman implements Person {  
7.   
8.     private Animal animal;  
9.   
10.     public Businessman() {  
11.   
12.     }  
13.   
14.     public void setAnimal(Animal animal) {  
15.         this.animal = animal;  
16.     }  
17.   
18.     @Override  
19.     public void raise() {  
20.         // TODO Auto-generated method stub  
21.         System.out.println("人饲养动物");  
22.         animal.use();  
23.     }  
24.   
25. }  

(4).对上面的类在applicationContext.xml文件中进行配置，代码如下：

[html] view plain copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans  
3.     xmlns="http://www.springframework.org/schema/beans"  
4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
5.     xmlns:p="http://www.springframework.org/schema/p"  
6.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">  
7.   
8.     <bean id="bus" class="com.bean.Businessman">  
9.         <property name="animal">  
10.             <ref bean="dog"/>  
11.         </property>  
12.     </bean>  
13.   
14.     <bean id="dog" class="com.bean.Dog"></bean>  
15.     <bean id="cat" class="com.bean.Cat"></bean>  
16. </beans>  

其中定义一个Businessman类的bean中，有个属性property标签，其中name对应Businessman类的Animal对象属性，并且使用ref标签引用了下面定义的Dog对象的id， 就这样设置注入了dog对象。

(5).最后编写测试类Test，代码如下：

[java] view plain copy

1. package com.test;  
2.   
3. import org.springframework.context.ApplicationContext;  
4. import org.springframework.context.support.ClassPathXmlApplicationContext;  
5.   
6. import com.inter.Person;  
7.   
8. public class Test {  
9.     public static void main(String[] args){  
10.         ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");  
11.         Person p=(Person) ac.getBean("bus");  
12.         p.raise();  
13.     }  
14. }  

通过查找配置文件来找到有id为bus的bean，然后把这个bean强制转换为一个Person对象，再调用这个Person对象的raise方法，此时raise方法即为Businessman的raise方法，因为在Businessman类中使用了Animal对象属性，并通过设置注入到了配置文件中。

(6).运行后效果如下：

为什么输出的是狗的用途呢，因为我们把对象属性通过设置注入的方式注入到配置文件中，而配置文件中的对象属性引用的为Dog这个类。

4.接下来附上构造注入的例子，来说明构造注入

(1).首先，新建一个Java项目，配置好Spring环境，先附上这个项目的文件结构图：

(2).首先，定义两个接口，分别为Axe和Person接口，放在com.inter包下，其中Axe(斧头)接口定义了一个抽象的chop(砍)方法，其中Person(人)接口定义了一个使用斧头的方法。

Axe.java文件的代码如下：

[java] view plain copy

1. package com.inter;  
2.   
3. public interface Axe {  
4.      String chop();  
5. }  

Person.java文件代码如下：

[java] view plain copy

1. package com.inter;  
2.   
3. public interface Person {  
4.     void useAxe();  
5. }  

(3).接着新建3个类，分别为Chinese、SteelAxe、StoneAxe类，放在com.bean包下，其中Chinese类实现Person接口，SteelAxe和StoneAxe类实现Axe接口，其中Chinese类有一个对象属性，一个普通属性，并通过构造方法传入两个属性作为参数，其中SteelAxe、StoneAxe类里有一个返回值为字符串的方法。

Chinese.java文件代码如下：

[java] view plain copy

1. package com.bean;  
2.   
3. import com.inter.Axe;  
4. import com.inter.Person;  
5.   
6. public class Chinese implements Person {  
7.     private Axe axe;  
8.     private String name;  
9.   
10.     public Chinese() {  
11.   
12.     }  
13.   
14.     public Chinese(Axe axe,String name){  
15.         this.axe=axe;  
16.         this.name=name;  
17.     }  
18.       
19.       
20.   
21.     public String getName() {  
22.         return name;  
23.     }  
24.   
25.     @Override  
26.     public void useAxe() {  
27.         // TODO Auto-generated method stub  
28.         System.out.println(axe.chop());  
29.     }  
30.   
31. }  

SteelAxe.java文件代码如下：

[java] view plain copy

1. package com.bean;  
2.   
3. import com.inter.Axe;  
4.   
5. public class SteelAxe implements Axe{  
6.   
7.     @Override  
8.     public String chop() {  
9.         // TODO Auto-generated method stub  
10.         return "钢斧砍柴好快";  
11.     }  
12.   
13. }  

StoneAxe.java文件代码如下：

[java] view plain copy

1. package com.bean;  
2.   
3. import com.inter.Axe;  
4.   
5. public  class StoneAxe implements Axe{  
6.   
7.     @Override  
8.     public String chop() {  
9.         // TODO Auto-generated method stub  
10.         return "石斧砍柴好慢";  
11.     }  
12.   
13. }  

(4).其中在applicationContext.xml配置文件配置bean，代码如下：

[html] view plain copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans  
3.     xmlns="http://www.springframework.org/schema/beans"  
4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
5.     xmlns:p="http://www.springframework.org/schema/p"  
6.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">  
7.   
8.     <bean id="chinese" class="com.bean.Chinese">  
9.         <constructor-arg>  
10.             <ref bean="stoneAxe"/>  
11.         </constructor-arg>  
12.         <constructor-arg name="name" value="A-Lin">  
13.         </constructor-arg>  
14.     </bean>  
15.     <bean id="steelAxe" class="com.bean.SteelAxe"></bean>  
16.     <bean id="stoneAxe" class="com.bean.StoneAxe"></bean>  
17. </beans>  

其中Chinese对象中使用constructor-arg标签，直接引用stoneAxe这个id的StoneAxe类，就可以给对象属性axe这个注入值 ，这种方式就为构造注入，其中为普通属性注入值，就像配置文件的constructor-arg标签的name属性一样，并赋给value属性一个值，其中name属性对应的为Chinese类的name属性！

(5).最后，编写测试类Test，代码如下：

[java] view plain copy

1. package com.test;  
2.   
3. import org.springframework.context.ApplicationContext;  
4. import org.springframework.context.support.ClassPathXmlApplicationContext;  
5.   
6. import com.bean.Chinese;  
7. import com.inter.Person;  
8.   
9. public class Test {  
10.     public static void main(String[] args){  
11.         ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");  
12.         Chinese c=(Chinese) ac.getBean("chinese");  
13.         System.out.println(c.getName());  
14.         c.useAxe();  
15.     }  
16. }  

其中使用类路径的方式查找到applicationContext.xml文件，生成一个ApplicationContext应用上下文环境对象，利用这个对象在配置文件中获得Chinese这个类的对象，调用其方法。

(6).运行后，效果如下图所示：

原文地址：http://blog.csdn.net/u012561176/article/details/46012783