Spring中的DI（依赖注入）使用详解

Spring中的DI（依赖注入）

什么时候需要依赖注入：

当一个被Spring管理的对象，存在另一个对象（依赖于另一个对象）时，就需要使用依赖注入，来完成对象之间的依赖关系

我们的程序在编写时，通过控制反转把对象创建的任务交给了Spring， 对象之间一定会有相互调用的情况，既然不使用new对象的方式，我们就只能让Spring来帮我们来完成这个操作。

依赖注入其实就是属性注入的一种特殊类型，不同点就是：

• 属性注入的是String、int、List、Set、Array···这种参数，使用value
• 而依赖注入注入的是一个Bean，是一个同样在Spring管理中的Bean，需要使用ref

我们需要为Spring容器提供所有bean的定义以及bean之间的依赖关系，那么进行依赖注入可以使用两种方式实现，XML文件配置或者注解。

使用XML配置文件方式

实现依赖注入一定要有一个入口，才能让Spring帮我们把对象注入进去

使用构造方法注入

简单的属性注入

/**
 * 准备一个普通的pojo类，里面的属性都没有初始化
 * 提供一个有参的构造方法，供Spring进行注入
 */
public class Student {
    private Integer id;
    private String name;
    private Double score;

    public Student(Integer id, String name, Double score) {
        this.id = id;
        this.name = name;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
}

    






    






    
    <bean id="student" class="com.zxy.pojo.Student">
        <constructor-arg name="id" value="1001"/>
        <constructor-arg name="name" value="张三"/>
        <constructor-arg name="score" value="99.7"/>
    bean>

依赖注入（Bean）

/**
 * 准备一个业务类，他需要调用dao层来完成数据的持久化操作
 * 准备一个构造方法，让Spring把dao对象注入进来
 */
public class UserServiceImpl implements IUserService {

    private IUserDao userDao;

    public UserServiceImpl(IUserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void add() {
        System.out.println("处理业务，准备存储数据");
        //调用dao层完成持久化的操作
        userDao.save();
    }
}

	
    <bean name="userDao" class="com.zxy.dao.impl.UserDaoImpl"/>
	
    <bean name="userService" class="com.zxy.service.impl.UserServiceImpl">
        <constructor-arg name="userDao" ref="userDao"/>
    bean>

使用set方法注入

简单的属性注入

/**
 * 为每个属性提供set方法，在xml文件中使用property标签进行赋值
 */
public class Student {
    private Integer id;
    private String name;
    private Double score;

    public void setId(Integer id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setScore(Double score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
}

    <bean name="student" class="com.zxy.pojo.Student">
        <property name="id" value="1001"/>
        <property name="name" value="张三"/>
        <property name="score" value="99.5"/>
    </bean>

依赖注入（Bean）

/**
 * 提供set方法
 */
public class UserServiceImpl implements IUserService {

    private IUserDao userDao;
    
    public void setUserDao(IUserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void add() {
        System.out.println("处理业务，准备存储数据");
        //调用dao层完成持久化的操作
        userDao.save();
    }
}

    
	<bean name="userService" class="com.zxy.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"/>
    bean>

注入集合属性

/**
 * 准备一个类，其中它的属性分别有数组、list、set、map、properties
 * 我们将为这些集合注入值
 */
public class DataList {

    private String[] myArray;
    private List<String> myList;
    private Set<String> mySet;
    private Map<String,String> myMap;
    private Properties myProperties;

    public void setMyArray(String[] myArray) {
        this.myArray = myArray;
    }

    public void setMyList(List<String> myList) {
        this.myList = myList;
    }

    public void setMySet(Set<String> mySet) {
        this.mySet = mySet;
    }

    public void setMyMap(Map<String, String> myMap) {
        this.myMap = myMap;
    }

    public void setMyProperties(Properties myProperties) {
        this.myProperties = myProperties;
    }

    @Override
    public String toString() {
        return "DataList{" +
                "myArray=" + Arrays.toString(myArray) +
                ", myList=" + myList +
                ", mySet=" + mySet +
                ", myMap=" + myMap +
                ", myProperties=" + myProperties +
                '}';
    }
}

    <bean name="dataList" class="com.zxy.pojo.DataList">
        <property name="myArray" >
            <array>
                <value>张三value>
                <value>李四value>
                <value>王五value>
            array>
        property>
        <property name="myList">
            <list>
                <value>张三value>
                <value>李四value>
                <value>王五value>
            list>
        property>
        <property name="mySet">
            <set>
                <value>张三value>
                <value>李四value>
                <value>王五value>
            set>
        property>
        <property name="myMap">
            <map>
                <entry key="姓名" value="张三"/>
                <entry key="性别" value="男"/>
                <entry key="年龄" value="20"/>
            map>
        property>
        <property name="myProperties">
            <props>
                <prop key="姓名">张三prop>
                <prop key="性别">男prop>
                <prop key="年龄">20prop>
            props>
        property>
    bean>

注意：

• array、list、set这三个标签之间可以通用
• 使用value可以直接赋值，也可以使用ref引入一个配置好的bean给集合
• map标签下的子标签是entry标签，可以使用key和value属性直接赋值，也可以使用value-ref进行赋值

使用注解方式

我们将配置都使用注解写在这个类上，当Spring通过反射得到这个类时，就可以获得它上面的注解信息，根据注解信息判断这个类是否需要spring容器管理，如何实现实例化对象等，从而不需要读取XML文件进行解析了。

注解中有三种依赖注入的方式：构造方法、setter方法都和上面配置文件方式相似，还有一种直接给对应的对象进行依赖注入，没有使用构造方法和setter方法，那就是接口注入

注解说明：

@Autowired

• 自动装配，将在Spring容器中管理的对应对象注入给该对象（自动装配时，先byType，然后byName）

@Qualifier(“id”)

• 根据指定的id（对应bean标签的id属性）进行注入（byName），一个接口中有多个实现类，而且和byName不一致时使用

@Resource

• JDK提供的注解，不能使用在构造方法上，此时类中也不要提供有参的构造方法，
• 属性name：配置bean的id，属性type：配置类的class实例

注解中寻找Bean 的过程（自动装配），首先通过byType类型寻找相应的实现类，如果实现类有一个相匹配直接使用，如果该接口有两个实现类它会根据byName进行匹配实现类的类名，如果匹配则使用该实现类。如果两个实现类的类名都和byName不匹配就会报错没有找到实现类！

示例：

模拟dao：

@Component//表示这个类交给Spring管理
public class UserDaoImpl implements IUserDao {
    
    @Override
    public void save() {
        System.out.println("向数据库中添加一条用户信息");
    }
}

service（需要用到dao）:

@Service("userService")//指定id
public class UserServiceImpl implements IUserService {

    @Autowired//自动装配完成依赖注入
    private IUserDao userDao;

    @Override
    public void add() {
        System.out.println("处理业务，准备存储数据");
        //调用dao层完成持久化的操作
        userDao.save();
    }
}

beans.xml（入口还是使用xml文件，也可以使用配置类来完成）：

<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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    
    <context:component-scan base-package="com.zxy"/>
beans>

测试：

    @Test
    public void test3(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        IUserService service = context.getBean("userService",IUserService.class);
        service.add();
    }

上面使用的是我们最常用的接口注入的方式，下面还有构造器注入和setter方法注入两种方式：

构造器注入：

@Service("userService")
public class UserServiceImpl implements IUserService {

    private IUserDao userDao;

    @Autowired//用在构造方法上
    public UserServiceImpl(IUserDao userDao){
        this.userDao=userDao;
    }

    @Override
    public void add() {
        System.out.println("处理业务，准备存储数据");
        //调用dao层完成持久化的操作
        userDao.save();
    }
}

set方法

@Service("userService")
public class UserServiceImpl implements IUserService {

    private IUserDao userDao;

    @Autowired//使用在set方法上
    @Resource(name = "userDaoImpl")//多加一个注解，指定去寻找Bean的name
    public void setUserDao(IUserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void add() {
        System.out.println("处理业务，准备存储数据");
        //调用dao层完成持久化的操作
        userDao.save();
    }
}