Spring第四篇_依赖注入(Dependency Injection)

最新推荐文章于 2022-07-05 14:39:00 发布

weixin_44086832

最新推荐文章于 2022-07-05 14:39:00 发布

阅读量237

点赞数

分类专栏： Java Spring 文章标签： spring java

本文链接：https://blog.csdn.net/weixin_44086832/article/details/105601918

版权

Java 同时被 2 个专栏收录

22 篇文章 0 订阅

订阅专栏

Spring

15 篇文章 0 订阅

订阅专栏

4. 依赖注入

文章目录

- 4. 依赖注入

Spring中的依赖注入:

依赖注入:
Dependency Injection
IOC的作用:
降低程序间的依赖耦合(依赖关系)
依赖关系的管理:
以后都交给Spring来维护
在当前类需要用到其它类的对象的时候, 由Spring为我们提供, 我们只需要在配置文件中说明
依赖关系的维护, 就称之为依赖注入
- 依赖注入:
  能注入的数据有三类:
  基本类型和String
  其他bean类型(在配置文件中或者注解配置过的bean)
  复杂类型/集合类型
  注入的方式有三种:
  第一种: 使用构造函数提供
  第二种: 使用set方法提供
  第三种: 使用注解提供(明天的内容)

准备工作:

1. 创建项目 day01_eesy_05DI

进行 pom.xml的相关配置, 导入Spring框架所需要的jar包
将项目 day01_eesy_04bean 中 src/main 目录下的文件复制到 day01_eesy_05DI 的 src/main目录下
将 factory相关文件及 AccountServiceImpl.java 的 init 和 destroy 方法删除
目录结构

在这里插入图片描述

4.1 构造函数注入

4.1.1 构造函数注入介绍

构造函数注入
使用的标签: constructor-arg
标签出现的位置: bean标签的内部
标签的属性:
type: 用于指定要注入的数据的数据类型, 该数据类型也是构造函数中某个或某些参数的类型
index: 用于指定要注入的数据给构造函数中指定索引位置的参数赋值,索引的位置是从0开始
name: 用于指定给构造函数中指定名称的参数赋值常用
==以上三个用于指定给构造函数中哪个参数赋值=
value: 用于提供基本类型和String类型的数据
ref: 用于指定其他的bean类型数据; 他只得就是在Spring的IOC核心容器中出现过的bean对象
优势:

在获取bean对象是,注入数据是必须的操作,否则对象无法创建成功

弊端:
改变了bean对象的实例化方式,使我们在创建对象时,如果用不到这些数据,也必须提供

4.1.2 案例

修改业务层 AccountServiceImpl.java 的构造函数, 以及saveAccount 方法,添加成员变量

//账户的业务层实现类
public class AccountServiceImpl implements IAccountService {

    //说明: 如果是经常变化的数据, 并不适用于注入的方式

    private String name;

    private Integer age;

    private Date birthday;

    public AccountServiceImpl(String name, Integer age, Date birthday){
        this.name = name;
        this.age = age;
        this.birthday = birthday;

    }

    public void saveAccount() {
        System.out.println("saveAccount方法执行了"+ name +age +birthday);
    }

}

在bean.xml中完成相关配置,进行构造函数注入

<?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">

    <!--
        Spring中的依赖注入:
            依赖注入:
                Dependency Injection
            IOC的作用:
                降低程序间的依赖耦合(依赖关系)
            依赖关系的管理:
                以后都交给Spring来维护
            在当前类需要用到其它类的对象的时候, 由Spring为我们提供, 我们只需要在配置文件中说明
            依赖关系的维护, 就称之为依赖注入
            依赖注入:
                能注入的数据 有三类:
                    基本类型和String
                    其他bean类型(在配置文件中或者注解配置过的bean)
                    复杂类型/集合类型
                注入的方式   有三种:
                    第一种: 使用构造函数提供
                    第二种: 使用set方法提供
                    第三种: 使用注解提供(明天的内容)
    -->

    <!--
        构造函数注入
        使用的标签: constructor-arg
        标签出现的位置: bean标签的内部
        标签的属性:
            type: 用于指定要注入的数据的数据类型, 该数据类型也是构造函数中某个或某些参数的类型
            index: 用于指定要注入的数据 给构造函数中指定索引位置的参数赋值,索引的位置是从0开始
            name: 用于指定给构造函数中指定名称的参数赋值           常用
            ================以上三个用于指定给构造函数中哪个参数赋值===========================
            value: 用于提供基本类型和String类型的数据
            ref:   用于指定其他的bean类型数据; 他只得就是在Spring的IOC核心容器中出现过的bean对象

            优势:
                在获取bean对象是,注入数据是必须的操作,否则对象无法创建成功
            弊端:
                改变了bean对象的实例化方式,使我们在创建对象时,如果用不到这些数据,也必须提供


      -->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
        <constructor-arg name="name" value="text"></constructor-arg>
        <constructor-arg name="age"  value="18"></constructor-arg>
        <constructor-arg name="birthday" ref="now"></constructor-arg>
    </bean>

    <bean id="now" class="java.util.Date"></bean>


</beans>

在模拟表现层中进行运行

//模拟一个表现层,用于调用业务层
public class Client {
    
    public static void main(String[] args) {
        //1.获取核心容器对象
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
        //2.根据id获取bean对象
        IAccountService accountService = (IAccountService) applicationContext.getBean("accountService");
        accountService.saveAccount();
     
    }

}

运行结果

在这里插入图片描述

4.2 set方法注入

4.2.1 set方法注入介绍

set方法注入:
涉及的标签: property
出现的位置: bean标签的内部
标签的属性:
name: 用于指定注入时所调用的set方法名称
value: 用于提供基本类型和String类型的数据
ref: 用于指定其他的bean类型数据; 他指的就是在Spring的IOC核心容器中出现过的bean对象

4.2.2 案例

创建业务层 AccountServiceImpl2.java

//账户的业务层实现类
public class AccountServiceImpl2 implements IAccountService {

    //说明: 如果是经常变化的数据, 并不适用于注入的方式

    private String name;

    private Integer age;

    private Date birthday;

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

    public void setAge(Integer age) {
        this.age = age;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public void saveAccount() {
        System.out.println("saveAccount方法执行了 "+ name+" " +age+" " +birthday);
    }

}

在配置文件 bean.xml中完成配置

<?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">

    <!--
        Spring中的依赖注入:
            依赖注入:
                Dependency Injection
            IOC的作用:
                降低程序间的依赖耦合(依赖关系)
            依赖关系的管理:
                以后都交给Spring来维护
            在当前类需要用到其它类的对象的时候, 由Spring为我们提供, 我们只需要在配置文件中说明
            依赖关系的维护, 就称之为依赖注入
            依赖注入:
                能注入的数据 有三类:
                    基本类型和String
                    其他bean类型(在配置文件中或者注解配置过的bean)
                    复杂类型/集合类型
                注入的方式   有三种:
                    第一种: 使用构造函数提供
                    第二种: 使用set方法提供
                    第三种: 使用注解提供(明天的内容)
    -->

    <!--
        构造函数注入
        使用的标签: constructor-arg
        标签出现的位置: bean标签的内部
        标签的属性:
            type: 用于指定要注入的数据的数据类型, 该数据类型也是构造函数中某个或某些参数的类型
            index: 用于指定要注入的数据 给构造函数中指定索引位置的参数赋值,索引的位置是从0开始
            name: 用于指定给构造函数中指定名称的参数赋值           常用
            ================以上三个用于指定给构造函数中哪个参数赋值===========================
            value: 用于提供基本类型和String类型的数据
            ref:   用于指定其他的bean类型数据; 他只得就是在Spring的IOC核心容器中出现过的bean对象

            优势:
                在获取bean对象是,注入数据是必须的操作,否则对象无法创建成功
            弊端:
                改变了bean对象的实例化方式,使我们在创建对象时,如果用不到这些数据,也必须提供


      -->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
        <constructor-arg name="name" value="text"></constructor-arg>
        <constructor-arg name="age"  value="18"></constructor-arg>
        <constructor-arg name="birthday" ref="now"></constructor-arg>
    </bean>
    <!--配置一个日期对象-->
    <bean id="now" class="java.util.Date"></bean>


    <!--
        set方法注入:
            涉及的标签: property
            出现的位置: bean标签的内部
            标签的属性:
                name: 用于指定注入时所调用的set方法名称
                value: 用于提供基本类型和String类型的数据
                ref: 用于指定其他的bean类型数据; 他指的就是在Spring的IOC核心容器中出现过的bean对象
       -->
    <bean id="accountService2" class="com.itheima.service.impl.AccountServiceImpl2">
        <property name="name" value="Test"></property>
        <property name="age" value="18"></property>
        <property name="birthday" ref="now"></property>
    </bean>

在模拟表现Client.java中运行

//模拟一个表现层,用于调用业务层
public class Client {

    public static void main(String[] args) {
        //1.获取核心容器对象
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
        //2.根据id获取bean对象
//        IAccountService accountService = (IAccountService) applicationContext.getBean("accountService");
//        accountService.saveAccount();

        IAccountService accountService = (IAccountService) applicationContext.getBean("accountService2");
        accountService.saveAccount();

    }

}

运行结果

在这里插入图片描述
5. 目录结构

在这里插入图片描述

4.3 注入集合数据

4.3.1 集合数据注入介绍

复杂类型的注入/集合类型的注入

用于给List结构集合注入的标签有:
list array set
用于给Map结构集合注入的标签有:
map props
结构相同, 标签可以互换

4.3.2 案例

创建业务实现类AccountServiceImpl3.java

//账户的业务层实现类
public class AccountServiceImpl3 implements IAccountService {


    private String[] myStrs;

    private List<String> myList;

    private Set<String> mySet;

    private Map<String,String> myMap;

    private Properties myProps;

    public void setMyStrs(String[] myStrs) {
        this.myStrs = myStrs;
    }

    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 setMyProps(Properties myProps) {
        this.myProps = myProps;
    }

    public void saveAccount() {
        System.out.println(Arrays.toString(myStrs));
        System.out.println(myList);
        System.out.println(mySet);
        System.out.println(myMap);
        System.out.println(myProps);
    }
}

在配置文件bean.xml中完成配置

<?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">

    <!--
        Spring中的依赖注入:
            依赖注入:
                Dependency Injection
            IOC的作用:
                降低程序间的依赖耦合(依赖关系)
            依赖关系的管理:
                以后都交给Spring来维护
            在当前类需要用到其它类的对象的时候, 由Spring为我们提供, 我们只需要在配置文件中说明
            依赖关系的维护, 就称之为依赖注入
            依赖注入:
                能注入的数据 有三类:
                    基本类型和String
                    其他bean类型(在配置文件中或者注解配置过的bean)
                    复杂类型/集合类型
                注入的方式   有三种:
                    第一种: 使用构造函数提供
                    第二种: 使用set方法提供
                    第三种: 使用注解提供(明天的内容)
    -->

    <!--
        构造函数注入
        使用的标签: constructor-arg
        标签出现的位置: bean标签的内部
        标签的属性:
            type: 用于指定要注入的数据的数据类型, 该数据类型也是构造函数中某个或某些参数的类型
            index: 用于指定要注入的数据 给构造函数中指定索引位置的参数赋值,索引的位置是从0开始
            name: 用于指定给构造函数中指定名称的参数赋值           常用
            ================以上三个用于指定给构造函数中哪个参数赋值===========================
            value: 用于提供基本类型和String类型的数据
            ref:   用于指定其他的bean类型数据; 他只得就是在Spring的IOC核心容器中出现过的bean对象

            优势:
                在获取bean对象是,注入数据是必须的操作,否则对象无法创建成功
            弊端:
                改变了bean对象的实例化方式,使我们在创建对象时,如果用不到这些数据,也必须提供


      -->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
        <constructor-arg name="name" value="text"></constructor-arg>
        <constructor-arg name="age"  value="18"></constructor-arg>
        <constructor-arg name="birthday" ref="now"></constructor-arg>
    </bean>
    <!--配置一个日期对象-->
    <bean id="now" class="java.util.Date"></bean>


    <!--
        set方法注入:                更常用的方式
            涉及的标签: property
            出现的位置: bean标签的内部
            标签的属性:
                name: 用于指定注入时所调用的set方法名称
                value: 用于提供基本类型和String类型的数据
                ref: 用于指定其他的bean类型数据; 他指的就是在Spring的IOC核心容器中出现过的bean对象

            优势:
                创建对象时没有明确的限制,可以直接使用默认构造函数
            弊端:
                如果有某个成员必须有值, 则获取对象时有可能set方法没有执行
       -->
    <bean id="accountService2" class="com.itheima.service.impl.AccountServiceImpl2">
        <property name="name" value="Test"></property>
        <property name="age" value="18"></property>
        <property name="birthday" ref="now"></property>
    </bean>


    <!--
        复杂类型的注入/集合类型的注入
        用于给List结构集合注入的标签有:
            list array set
        用于给Map结构集合注入的标签有:
            map props
        结构相同, 标签可以互换
      -->
    <bean id="accountService3" class="com.itheima.service.impl.AccountServiceImpl3">
        <property name="myStrs">
            <array>
                <value>aaa</value>
                <value>bbb</value>
                <value>ccc</value>
            </array>
        </property>

        <property name="myList">
            <list>
                <value>aaa</value>
                <value>bbb</value>
                <value>ccc</value>
            </list>
        </property>

        <property name="mySet">
            <set>
                <value>aaa</value>
                <value>bbb</value>
                <value>ccc</value>
            </set>
        </property>

        <property name="myMap">
            <map>
                <entry key="testA" value="aaa"></entry>
                <entry key="testB">
                    <value>bbb</value>
                </entry>
            </map>
        </property>

        <property name="myProps">
            <props>
                <prop key="teatA">aaa</prop>
                <prop key="testB">bbb</prop>
            </props>
        </property>
    </bean>

</beans>

在模拟表现层Client.java中运行

//模拟一个表现层,用于调用业务层
public class Client {

    public static void main(String[] args) {
        //1.获取核心容器对象
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
        //2.根据id获取bean对象
//        IAccountService accountService = (IAccountService) applicationContext.getBean("accountService");
//        accountService.saveAccount();

//        IAccountService accountService = (IAccountService) applicationContext.getBean("accountService2");
//        accountService.saveAccount();

        IAccountService accountService = (IAccountService) applicationContext.getBean("accountService3");
        accountService.saveAccount();


    }

}

运行结果

在这里插入图片描述
5. 目录结构

在这里插入图片描述

weixin_44086832

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Spring第四篇_依赖注入(Dependency Injection)

4. 依赖注入Spring中的依赖注入:依赖注入:Dependency InjectionIOC的作用:降低程序间的依赖耦合(依赖关系)依赖关系的管理:以后都交给Spring来维护在当前类需要用到其它类的对象的时候, 由Spring为我们提供, 我们只需要在配置文件中说明依赖关系的维护, 就称之为依赖注入依赖注入:能注入的数据有三类:基本类型和String其他bea...
复制链接

扫一扫