Spring入门-IOC和DI

接下来学习Spring相关知识IOC和DI，即控制反转和依赖注入。

什么是IOC和DI

IOC(Inversion of Control 控制反转)，即对象之间的依赖关系由Spring容器来建立。

DI(Dependency Injection 依赖注入)，Spring容器可以通过调用set方法或者构造器来建立对象之间的依赖关系。

简单来说，对象之间关系由最初人来建立，变成交给Spring容器来建立，这样造成控制角色的转变，人只需要等着就可以了，容器给什么对象我就使用什么对象。为了实现IOC，DI是必不可少的，其可以实现对象动态注入，根据接口实现类的不同可以调用不同的对象，这样可以大大提高代码可维护性。

DI依赖注入对象

依赖注入有两种方式，即set方法注入和构造器注入，一般使用set方法注入。

set方法注入

（1）需要注入对象的类中，添加对应对象set方法，属性一般使用接口类型，这样可以实现动态注入

接口

package com.boe;
/**
 * 员工接口
 */
public interface Employee {
    
    //接口方法，就是工作
    public void work();

}

实现类

package com.boe;

public class Engineer implements Employee{
    
    public Engineer() {
        System.out.println("创建了一个新的Engineer");
    }

    public void work() {
        System.out.println("call厂商，写报告，被怼");
    }

}

package com.boe;

public class Leader implements Employee{
    
    public Leader() {
        System.out.println("新创建了一个Leader");
    }

    public void work() {
        System.out.println("开会，坐办公室，专职怼下属");
    }

}

测试类中添加要注入的属性emp，类型为接口Employee。

package com.boe;

public class Company {
    //属性为员工
    private Employee emp;
    
    //添加set，get方法
    public Employee getEmp() {
        return emp;
    }

    public void setEmp(Employee emp) {
        this.emp = emp;
    }
    
    //构造方法
    public Company() {
        System.out.println("创建了一个新的公司");
    }
    
    //调用员工工作的方法
    public void runCompany() {
        //根据注入的对象不同，执行得到不同的结果
        emp.work();
    }
}

（2）在配置文件中，使用<property name="" ref="">来配置属性，name即类中注入对象对应的属性名，ref为注入对象的bean id

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context" xmlns:util="http://www.springframework.org/schema/util"  
    xmlns:jee="http://www.springframework.org /schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
        http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd">    
        
       <!--Set方式注入 -->
       <bean id="engineer" class="com.boe.Engineer"></bean>
       <bean id="leader" class="com.boe.Leader"></bean>       
       <!-- 开始注入 -->
       <bean id="company" class="com.boe.Company">
        <property name="emp" ref="leader"></property>
       </bean>
       
</beans>

使用junit测试

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.boe.Company;

public class TestDI {
    
    //测试set方法注入
    @Test
    public void testSet() {
        String path="myIOC.xml";
        ApplicationContext ac=new ClassPathXmlApplicationContext(path);
        Company company=ac.getBean("company",Company.class);
        company.runCompany();
    }

}

测试结果如下，当property中ref指向的bean id发生变化时，对应就有不同的执行效果，实现了对象的依赖注入，配置什么ref就有什么对象注入进来。

构造器注入

（1）需要注入对象的类中添加带有参数的构造器，参考下面代码。

注入类，宅男类

package com.boe;
/**
 * 宅男类
 * @author yangchaolin
 */
public class Otaku {
    //构造方法
    public Otaku() {
        System.out.println("创建一个新的宅男");
    }
}

被注入类，女神类

package com.boe;
/**
 * 女神类
 * @author yangchaolin
 */
public class Gakki {    
    //属性
    private Otaku otaku;
    //带参数的构造方法
    public Gakki(Otaku otaku) {
        System.out.println("创建一个女神，有宅男");
        this.otaku = otaku;
    }
    //默认构造方法
    public Gakki() {
        System.out.println("创建一个女神，无宅男");
    }    
    //toString方法
    @Override
    public String toString() {
        return "Gakki [otaku=" + otaku + "]";
    }
}

（2）在配置文件中，使用<constructor-arg index="" ref="" />元素来配置，其中index代表构造方法中参数的位置，位置从0开始，ref为bean id。

       <!-- 构造器方式注入 -->
       <bean id="otaku" class="com.boe.Otaku"></bean>
       <bean id="gakki" class="com.boe.Gakki">
           <constructor-arg index="0" ref="otaku"></constructor-arg>
       </bean>

junit测试类

    //测试构造器方法注入
    @Test
    public void testConstructor() {
        String path="myIOC.xml";
        ApplicationContext ac=new ClassPathXmlApplicationContext(path);
        Gakki gakki=ac.getBean("gakki",Gakki.class);
        System.out.println(gakki);
    }

测试结果

自动装配

默认情况下容器不会自动装配对象，只有依据某些规则自动帮我们建立对象之间的依赖关系，需设置autowire属性，有三种类型。

（1）byName：表示依据属性名查找对应的bean，即通过属性名，查找xml配置文件中是否有bean id等于这个属性名的，有就将bean注入，没有就不注入，参考将人注入到国家。

人对应的类

package com.boe;

public class People {
    //默认构造方法
    public People() {
        System.out.println("创建一个人");
    }
}

国家对应的类

package com.boe;

public class Country {
    //属性
    private People people;
    //get set方法
    public People getPeople() {
        return people;
    }

    public void setPeople(People people) {
        this.people = people;
    }
    //构造方法
    public Country() {
        System.out.println("创建一个新的国家");
    }
    //重写toString方法
    @Override
    public String toString() {
        return "Country [people=" + people + "]";
    }
}

xml中配置信息

       <!-- byName -->
       <bean id="people" class="com.boe.People"></bean><!-- 属性名为people，bean id也为people -->
       <bean id="country" class="com.boe.Country" autowire="byName"></bean>

junit测试

    //测试使用自动装配-byName&byType
    @Test
    public void testAutowireByName() {
        String path="myIOC.xml";
        ApplicationContext ac=new ClassPathXmlApplicationContext(path);
        Country country=ac.getBean("country",Country.class);
        System.out.println(country);
    }

当bean id等于属性名people时，autowire="byName"是可以将People类实例对象注入的，否则不会注入。

修改bean id为其他名字，不会注入。

（2）byType：依据属性的类型来查找对应的bean，即查看bean的class属性是否匹配，如果一致就注入。

在上述修改基础上，将autowire属性值设置为byType

       <!-- byType -->
       <bean id="people1" class="com.boe.People"></bean>
       <bean id="country" class="com.boe.Country" autowire="byType"></bean>

即使bean id不匹配，class属性是匹配的，因此也可以注入。

但是byType属性只能有一个bean与之对应，如果有多个class类型一样的bean，这种自动装配会有致命错误发生。

       <!-- byType -->
       <bean id="people1" class="com.boe.People"></bean>
       <bean id="people2" class="com.boe.People"></bean>
       <bean id="country" class="com.boe.Country" autowire="byType"></bean>

（3）constructor：与byType类似，只不过使用构造器来注入，将Country换成Province测试。

省对应的类

package com.boe;

public class Province {
    //属性
    private People people;
    //带参数构造方法
    public Province(People people) {
        System.out.println("新建一个省，有人民");
        this.people = people;
    }
    //默认构造方法
    public Province() {
        System.out.println("新建一个省，没有人民");
    }
    //重写toString
    @Override
    public String toString() {
        return "Province [people=" + people + "]";
    }    
}

xml中配置信息

      <!-- constructor -->
       <bean id="p" class="com.boe.People"></bean>
       <!-- <bean id="p1" class="com.boe.People"></bean> -->
       <bean id="province" class="com.boe.Province" autowire="constructor"></bean>

junit代码

    //测试使用自动装配-constructor
    @Test
    public void testAutowireConstructor() {
        String path="myIOC.xml";
        ApplicationContext ac=new ClassPathXmlApplicationContext(path);
        Province province=ac.getBean("province",Province.class);
        System.out.println(province);
    }

测试结果，可以看出跟byType类似，如果有多个同样类型的bean匹配，则不会注入且不报错，这点跟byType有点不同。

DI依赖注入值

Spring容器可以帮我们注入基本数据类型的值，可以注入的类型有：char、int、double等，此外还可以注入String。

测试类valueBean

package value;

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class valueBean {
    //注入基本数据类型示例
    private String name;
    private int age;
    //注入集合类型示例
    private List<String> interests;//List集合中的值可以重复
    private Set<String> city;//Set集合中的值不可以重复
    private Map<String,Double> score;//Map集合的注入
    private Properties db;
    
    
    public Properties getDb() {
        return db;
    }
    public void setDb(Properties db) {
        this.db = db;
    }
    public Map<String, Double> getScore() {
        return score;
    }
    public void setScore(Map<String, Double> score) {
        this.score = score;
    }
    public Set<String> getCity() {
        return city;
    }
    public void setCity(Set<String> city) {
        this.city = city;
    }
    public List<String> getInterests() {
        return interests;
    }
    public void setInterests(List<String> interests) {
        this.interests = interests;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    //无参数构造器
    public valueBean() {
        System.out.println("valueBean()");
    }
    @Override
    public String toString() {
        return "valueBean [name=" + name + ", age=" + age +"
"+"interests=" + interests + "
"+"city=" + city + "
"+"score="
                + score + "
"+"db=" + db + "]";
    }    
}

注入基本数值xml配置

        <!--  注入基本类型数据-->
        <bean id="vb1" class="value.valueBean">
           <!--  注入基本数据类型-->
           <!-- 调用setName方法和setAge方法，将关关和22传入到对象中 -->
           <property name="name" value="关关"></property>
           <property name="age" value="22"></property>
　　　　　</bean>

junit测试

   @Test
   /**
    * 测试注入-直接注入
    */
   public void test6() {
         //写配置路径
         String config="value.xml";
         //启动Spring容器
         ApplicationContext ac=new ClassPathXmlApplicationContext(config);          
         valueBean valueBean=ac.getBean("vb1", valueBean.class);
         System.out.println(valueBean);
   }

测试结果

容器可以注入集合类型的值（List，Set，Map，Properties），有如下两种方式

（1）直接注入，在xml中写好

       <bean id="vb1" class="value.valueBean">
          <!-- 注入集合类型数据 -->
          <!-- 调用setInterests方法，将集合传入到对象中，list代表集合，其中的值就是集合中的元素 -->
          <property name="interests">
            <list>
              <value>玩电脑</value>
              <value>玩诛仙</value>
              <value>玩街头篮球</value>
            </list>
          </property>
          <property name="city">
            <set>
               <value>长沙</value>
               <value>佛山</value>
               <value>北京</value>
               <value>北京</value><!-- 写两个北京，set只会显示一个，不允许重复的值 -->
            </set>
          </property>
          
          <!-- Map集合的注入 -->
          <property name="score">
              <map>
                 <entry key="物理" value="59"></entry>
                 <entry key="工程力学" value="49"></entry>
                 <entry key="材料科学与工程" value="58"></entry>
              </map>
          </property>
          
          <!-- Properties集合的注入 -->
          <property name="db">
               <props>
                  <prop key="username">yangchaolin</prop>
                  <prop key="password">1234</prop>
               </props>
          </property>
       </bean>        

注入结果

（2）采用引用的方式注入

 step1 将集合类型的值先配置成一个bean

 step2 再将这个bean注入到对应的bean里面

测试类ExampleBean

package value;

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
/**
 * 采用另外一种注入方式注入集合，即引用的方式，将集合先配置成bean，然后注入到ExampleBean里面来
 * @author yangchaolin
 */
public class ExampleBean {
    
    private List<String> interests;
    private Set<String> city;
    private Map<String,Double> score;
    private Properties db;
    //无参数构造器
    public ExampleBean() {
        System.out.println("ExampleBean()");
    }
    public List<String> getInterests() {
        return interests;
    }
    public void setInterests(List<String> interests) {
        this.interests = interests;
    }
    public Set<String> getCity() {
        return city;
    }
    public void setCity(Set<String> city) {
        this.city = city;
    }
    public Map<String, Double> getScore() {
        return score;
    }
    public void setScore(Map<String, Double> score) {
        this.score = score;
    }
    public Properties getDb() {
        return db;
    }
    public void setDb(Properties db) {
        this.db = db;
    }
    @Override
    public String toString() {
        return "ExampleBean [interests=" + interests + "
"+"city=" + city + "
"+"score=" + score + "
"+"db=" + db + "]";
    }   
}

xml配置

<!-- 将集合类型的值配置成一个bean，util:list其实就是一个bean,因此可以作为ref来注入-->
       <!-- util:list中的util是命名空间（namespace）,是为了区分同名的元素而设定的前缀，如list是上面spring框架下的list，不是java.util下的list -->
       <util:list id="interestBean">
         <value>喝酒</value>
         <value>玩游戏</value>
         <value>逃课</value>
         <value>挂科</value>
       </util:list>
       <util:set id="cityBean">
          <value>长沙</value>
          <value>佛山</value>  
          <value>中山</value>  
          <value>北京</value>        
       </util:set>
       <util:map id="scoreBean">
         <entry key="大学数学" value="79"></entry>
         <entry key="C语言" value="76"></entry>
         <entry key="大学计算机基础" value="75"></entry>
       </util:map>
       <util:properties id="dbBean">
         <prop key="物理化学">59</prop>
         <prop key="弹性力学">55</prop>
         <prop key="大学英语">80</prop>
       </util:properties>
       <!-- 采用引用的方式，注入集合类型的值 -->
       <bean id="eb1" class="value.ExampleBean">
         <property name="interests" ref="interestBean"></property>
         <property name="city" ref="cityBean"></property>
         <property name="score" ref="scoreBean"></property>
          <property name="db" ref="dbBean"></property>
       </bean>

junit测试

   @Test
   /**
    * 测试注入-使用引用注入
    */
   public void test7() {
         //写配置路径
         String config="value.xml";
         //启动Spring容器
         ApplicationContext ac=new ClassPathXmlApplicationContext(config);          
         ExampleBean exampleBean=ac.getBean("eb1", ExampleBean.class);
         System.out.println(exampleBean);
   }

测试结果

结论

（1）IOC是目标，DI是手段

（2）DI注入有set方法注入和构造器方法注入，一般使用前者

（3）自动装配有三种类型，byName、byType和constructor

（4）DI注入除了可以注入对象外，还可以注入数据，如基本数据类型和集合，其中集合注入可以直接注入，也可以将集合配置成一个bean后注入