3、Spring的DI依赖注入

2023-11-15 11:02:10

一、DI介绍

1、DI介绍

  • 依赖注入，应用程序运行依赖的资源由Spring为其提供，资源进入应用程序的方式称为注入。
  • Spring容器管理容器中Bean之间的依赖关系，Spring使用一种被称为“依赖注入”的方式来管理Bean之间的依赖关系。
  • 使用依赖注入，不仅可以为Bean注入普通的属性值，还可以注入其他Bean的引用。依赖注入是一种优秀的解耦方式，其可以让Bean以配置文件组织在一起，而不是以硬编码的方式耦合在一起。

2、依赖注入

依赖注入： Dependency Injection。它是 spring 框架核心 ioc 的具体实现。

3、为什要依赖注入

直接用对象，不需要去new对象。所谓的注入就是创建对象的过程而已。

  • 传统的代码，每个对象负责管理与自己需要依赖的对象，导致如果需要切换依赖对象的实现类时，需要修改多处地方。同时，过度耦合也使得对象难以进行单元测试。

  • 依赖注入把对象的创造交给外部去管理,很好的解决了代码紧耦合（tight couple）的问题，是一种让代码实现松耦合（loose couple）的机制。

  • 例如：我们控制层调用业务层需要在控制层创建业务层的对象，之前我们需要Person p = new Person;现在不需要我们自己去new person，直接交给spring去创建，我可以直接拿过来用。

Spring 支持的注入方式共有四种: set 注入、构造器注入、静态工厂注入、实例化工厂注入。

4、IOC与DI之间的关系

IoC(Inversion of Control 控制反转)：是一种面向对象编程中的一种设计原则，用来减低计算机代码之间的耦合度。其基本思想是：借助于“第三方”实现具有依赖关系的对象之间的解耦。

DI(Dependence Injection 依赖注入)：将实例变量传入到一个对象中去(Dependency injection means giving an object its instance variables)。

  • 控制反转是一种思想
  • 依赖注入是一种设计模式
  • IoC框架使用依赖注入作为实现控制反转的方式

说人话：就是DI与IOC相辅相成，相互包含。不能说成DI就是IOC，这两个本质区别是：IOC是思想，DI设计模式。

二、Spring的依赖注入方式

1、Set注入

1、set注入介绍

思考：调用某个类的方法，你是怎么操作的？

答：我通过该类的构造器创建对象，通过对象去调用方法。

3、Spring的DI依赖注入

看图说话：

方式一与方式二对比：

  • 方式二没有主动的去实例对象，而是通过带参数的方法传递过来UserDao对象，从而实现UserService对UserDao的依赖.

　　实际上创建对象是交给Spring容器来创建的

  • 属性字段需要提供set方法。并且还需要通过修改spring的配置文件，进行相关的注入信息配置。

2、Set注入标签介绍

名称：property

类型：标签

归属：bean标签

作用：使用set方法的形式为bean提供资源

格式：
    <bean>
     <property />
    </bean>
基本属性：

 <property name="propertyName" value="propertyValue" ref="beanId"/>
    name：对应bean中的属性名，要求该属性必须提供可访问的set方法（严格规范为此名称是set方法对应名称）

    value：设定非引用类型属性对应的值，不能与ref同时使用

    ref：设定引用类型属性对应bean的id ，不能与value同时使用

    注意：一个bean可以有多个property标签，属性字段需要提供set方法

3、测试Set注入方式创建对象

  1. 在UserServiceImpl创建UserDao的变量，并在UserServiceImpl变量提供Set方法。
public class UserServiceImpl implements UserService {

    private UserDao userDao;

    public void setUserDao(UserDao userDao){

        this.userDao = userDao;

    }

    @Override
    public void saveUser() {
        System.out.println("service层通过注入的方式调用dao层，成功啦！");
        userDao.saveUser();
    }
  1. 接口类UserService
public interface UserService {
    void saveUser();
}
  1. dao层方法
public class UserDao {

    public void saveUser(){
        System.out.println("我是dao层");
    }
}

4.配置文件配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

        <bean id="userService" class="com.why.service.impl.UserServiceImpl">
                <!--
                    <property/> 中的name对应set方法的set后面的名字且首字母小写
                     ref 代表注入的是引用类型，所以需要填入药注入bean的id
                    说明：service引用到层，相当于在service里面创建userDao的对象，直接被service引用，与new对象调用方法类似
                -->
                <property name="userDao" ref="userDao"/>
        </bean>

        <!--将注入的资源声明为bean，交由spring管理-->
        <bean id="userDao" class="com.why.dao.UserDao"/>
</beans>
  1. 测试类
public class UserController {
    public static void main(String[] args) {

        //获取Spring上下文环境 (加载配置文件)
        ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");

        /*
              通过getBean方法得到Spring容器中实例化好的Bean对象 (实例化Bean对象)
              userService代表的是配置文件中bean标签的id属性值(id标识唯一的bean)
         */
        UserService userService = (UserService) context.getBean("userService");
        userService.saveUser();
    }
}

6.测试结果

程序没有报错，并正确输出我们要打印的东西

3、Spring的DI依赖注入

2、构造方法注入

1、构造器注入标签介绍

名称：constructor-arg

类型：标签

归属：bean标签

作用：使用构造方法的形式为bean提供资源，兼容早期遗留系统的升级工作

格式：
    <bean>
     <constructor-arg />
    </bean>
    
基本属性：
  <constructor-arg name="argsName" value="argsValue />
        
        name：对应bean中的构造方法所携带的参数名
        value：设定非引用类型构造方法参数对应的值，不能与ref同时使用

其他属性：

 <constructor-arg index="arg-index" type="arg-type" ref="beanId"/>
 
 ref：设定引用类型构造方法参数对应bean的id ，不能与value同时使用

 type ：设定构造方法参数的类型，用于按类型匹配参数或进行类型校验

 index ：设定构造方法参数的位置，用于按位置匹配参数，参数index值从0开始计数

 注意：一个bean可以有多个constructor-arg标签

2、构造注入测试案例

  1. 在UserServiceImpl创建UserDao的变量，并在UserServiceImpl变量提供构造方法。
public class UserServiceImpl implements UserService {

    private UserDao userDao;
    private String name;
    private int age;
    
    //根据构造器进行注入
    public UserServiceImpl(UserDao userDao, String name, int age) {
        this.userDao = userDao;
        this.name = name;
        this.age = age;
    }
    
    
    @Override
    public void saveUser() {
        System.out.println("name="+name);
        System.out.println("age="+age);
        userDao.saveUser();
    }

    public void destroy(){
        System.out.println("bean销毁");
    }
}
  1. 修改配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

   <!--
        构造器注入
    -->
    <bean id="userService" class="com.why.service.impl.UserServiceImpl">
        <!--
           对构造器进行赋值
       -->
        <constructor-arg name="userDao" ref="userDao"></constructor-arg>
        <constructor-arg name="age" value="22"></constructor-arg>
        <constructor-arg name="name" value="laity"/>

    </bean>

    <bean id="userDao" class="com.why.dao.UserDao"></bean>
</beans>

3. 其它代码与set注入代码相同

  1. 测试结果

3、Spring的DI依赖注入

  1. 构造标签的属性
//根据构造器进行注入
    public UserServiceImpl(UserDao userDao, String name, int age) {
        this.userDao = userDao;
        this.name = name;
        this.age = age;
    }

带name属性

<bean id="userService" class="com.why.service.impl.UserServiceImpl">
        <!--
           对构造器进行赋值
       -->
        <constructor-arg name="userDao" ref="userDao"></constructor-arg>
        <constructor-arg name="age" value="22"></constructor-arg>
        <constructor-arg name="name" value="laity"/>

</bean>

不带name属性，顺序要按照构造方法的参数类型进行设置

<bean id="userService" class="com.why.service.impl.UserServiceImpl">
        <!--
           对构造器进行赋值
       -->
        <constructor-arg  ref="userDao"></constructor-arg>
        <constructor-arg  value="22"></constructor-arg>
        <constructor-arg  value="laity"/>

</bean>

index0表示第一个参数，index1表示第二个参数，以此类推

<bean id="userService" class="com.why.service.impl.UserServiceImpl">
        <!--
           对构造器进行赋值
       -->
        <constructor-arg index ="0" ref="userDao"></constructor-arg>
        <constructor-arg index ="1" value="22"></constructor-arg>
        <constructor-arg  index ="2" value="laity"/>
</bean>

3、集合注入

1、集合类型标签介绍

名称：array，list，set，map，props

类型：标签

归属：property标签 或 constructor-arg标签

作用：注入集合数据类型属性

格式：
    <property>
     <list></list>
    </property>

1、集合类型数据注入——list（重点）

<property name="xxx">
   <list>
       <value>why</value>
       <value>66666</value>
   </list>
</property>

(2)集合类型数据注入——props（重点）

<property name="xxx">
   <props>
       <prop key="name">javaxxf</prop>
       <prop key="value">666666</prop>
   </props>
</property>

(3)集合类型数据注入——array （了解）

<property name="xxx">
   <array>
       <value>123456</value>
       <value>66666</value>
   </array>
</property>

(4)集合类型数据注入——set（了解）

<property name="xxx">
    <set>
        <value>javaxxf</value>
        <value>66666</value>
    </set>
</property>

(5)集合类型数据注入——map（了解）

<property name="xxx">
   <map>
       <entry key="name" value="javaxf66666"/>
       <entry key="value" value="66666"/>
   </map>
</property><property name="xxx">
   <map>
       <entry key="name" value="javaxf66666"/>
       <entry key="value" value="66666"/>
   </map>
</property>

2、测试集合注入

  1. 创建集合并提供set方法
package com.why.service.impl;

import com.why.service.UserService;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Properties;

public class UserServiceImpl implements UserService {

    private ArrayList arrayList;
    private Properties properties;
    private int[] arr;
    private HashSet hset;
    private HashMap hmap;

    public void setArrayList(ArrayList arrayList) {
        this.arrayList = arrayList;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    public void setArr(int[] arr) {
        this.arr = arr;
    }

    public void setHset(HashSet hset) {
        this.hset = hset;
    }

    public void setHmap(HashMap hmap) {
        this.hmap = hmap;
    }

    @Override
    public void saveUser() {
        System.out.println("ArrayList"+arrayList);
        System.out.println("Properties"+properties);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("HashSet"+hset);
        System.out.println("HashMap"+hmap);
    }
}
  1. 配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">


    <bean id="userService" class="com.why.service.impl.UserServiceImpl">
        <!--list集合配置-->
        <property name="arrayList">
            <list>
                <value>list1</value>
                <value>list2</value>
                <value>list3</value>
            </list>
        </property>
        <!--properties配置-->
        <property name="properties">
            <props>
                <prop key="properties1">java</prop>
                <prop key="properties2">java</prop>
                <prop key="properties3">java</prop>
            </props>
        </property>
        <!--数组配置-->
        <property name="arr">
            <array>
                <value>11</value>
                <value>12</value>
                <value>13</value>
            </array>
        </property>
        <!--hashmap集合配置-->
        <property name="hmap">
            <map>
                <entry key="map1" value="Laity1"></entry>
                <entry key="map2" value="Laity2"></entry>
            </map>
        </property>
        <!--hashset集合配置-->
        <property name="hset">
            <set>
                <value>hset1</value>
                <value>hset2</value>
                <value>hset3</value>
            </set>
        </property>
    </bean>

</beans>
  1. 运行结果
    3、Spring的DI依赖注入

三、参考资料

理解Spring中的IoC和DI

控制反转（IoC）与依赖注入（DI）

上一篇：【Spring】DI：给属性赋值


下一篇：实验2 多个逻辑段的汇编源程序编写与调试