Spring DI(依赖注入) 笔记

最新推荐文章于 2024-07-22 08:55:10 发布
最新推荐文章于 2024-07-22 08:55:10 发布
阅读量60 收藏
点赞数
文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52253125/article/details/125912530
版权

文章目录

DI依赖注入

​ 依赖注入可以理解成IoC的一种应用场景，反转的是对象间依赖关系维护权。讲的通俗点，就是在运行期，由Spring根据配置文件，将其他对象的引用通过组件的提供的setter方法进行设定。

1. set方法注入

在要注入属性的bean标签中进行配置。前提是该类有提供属性对应的set方法。

实体类代码

public class Student {
    private Integer id;
    private String name;
    private Integer age;
    private Teacher teacher;

    public Student(){}

    public Student(Integer id, String name, Integer age, Teacher teacher) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.teacher = teacher;
    }

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

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


public class Teacher {
    private Integer id;
    private String name;
    private Integer age;

    public Teacher() {
    }

    public Teacher(Integer id, String name, Integer age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

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

配置文件内容

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

  <!--set方法注入teacher类的值-->
    <bean class="com.zijie.domain.Teacher" id="teacher">
        <property name="id" value="2" />
        <property name="name" value="李四" />
    </bean>

    <!--set方法注入student类的值-->
        <!--
            name属性用来指定要设置哪个属性
            value属性用来设置要设置的值
            ref属性用来给引用类型的属性设置值，可以写上Spring容器中bean的id
        -->
    <bean class="com.zijie.domain.Student" id="student">
        <property name="id" value="1" />
        <property name="name" value="张三" />
        <property name="age" value="23"/>
        <property name="teacher" ref="teacher"/>
    </bean>
      
</beans>

测试类

public class APP {
    public static void main(String[] args) {
        //1.获取StudentDaoImpl对象
        //创建Spring容器，指定要读取的配置文件路径
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        //从容器中获取对象
        Student student = (Student) app.getBean("student");
        //调用对象的方法进行测试
        System.out.println(student);
    }
}

2.有参构造注入

在要注入属性的bean标签中进行配置。前提是该类有提供对应的有参构造。
使用上面的Student类进行有参构造的设置

配置文件内容

<?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 class="com.zijie.domain.Teacher" id="teacher">
        <property name="id" value="2" />
        <property name="name" value="李四" />
    </bean>
    <!--使用有参构造进行注入 constructor-arg 构造器注入-->
    <bean class="com.zijie.domain.Student" id="student">
        <constructor-arg name="id" value="1" />
        <constructor-arg name="name" value="张三" />
        <constructor-arg name="age" value="23" />
        <constructor-arg name="teacher" ref="teacher" />
    </bean>
</beans>

测试类

public class APP {
    public static void main(String[] args) {

        //1.获取StudentDaoImpl对象
        //创建Spring容器，指定要读取的配置文件路径
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        //从容器中获取对象
        Student student = (Student) app.getBean("student");
        //调用对象的方法进行测试
        System.out.println(student);
    }
}

3.复杂类型属性注入

定义两个实体类：Test和Massages

public class Massages {
    private String name;
    private String password;
    private String path;
    private double phone;

    public Massages() {
    }

    public Massages(String name, String password, String path, double phone) {
        this.name = name;
        this.password = password;
        this.path = path;
        this.phone = phone;
    }

    public String getName() {
        return name;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getPath() {
        return path;
    }

    public void setPath(String path) {
        this.path = path;
    }

    public double getPhone() {
        return phone;
    }

    public void setPhone(double phone) {
        this.phone = phone;
    }

    @Override
    public String toString() {
        return "Massages{" +
                "name='" + name + '\'' +
                ", password='" + password + '\'' +
                ", path='" + path + '\'' +
                ", phone=" + phone +
                '}';
    }
}


import java.util.*;
public class Test {
    private int age;
    private String name;
    private Massages massages;
    private List<String> list;
    private List<Massages> phones;
    private Set<String> set;
    private Map<String, Massages> map;
    private int[] arr;
    private Properties properties;

    public Test() {
    }

    public Test(int age, String name, Massages massages, List<String> list, List<Massages> phones, Set<String> set, Map<String, Massages> map, int[] arr, Properties properties) {
        this.age = age;
        this.name = name;
        this.massages = massages;
        this.list = list;
        this.phones = phones;
        this.set = set;
        this.map = map;
        this.arr = arr;
        this.properties = properties;
    }

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    public Massages getMassages() {
        return massages;
    }

    public void setMassages(Massages massages) {
        this.massages = massages;
    }

    public List<String> getList() {
        return list;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public List<Massages> getPhones() {
        return phones;
    }

    public void setPhones(List<Massages> phones) {
        this.phones = phones;
    }

    public Set<String> getSet() {
        return set;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }

    public Map<String, Massages> getMap() {
        return map;
    }

    public void setMap(Map<String, Massages> map) {
        this.map = map;
    }

    public int[] getArr() {
        return arr;
    }

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

    public Properties getProperties() {
        return properties;
    }

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

    @Override
    public String toString() {
        return "Test{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", massages=" + massages +
                ", list=" + list +
                ", phones=" + phones +
                ", set=" + set +
                ", map=" + map +
                ", arr=" + Arrays.toString(arr) +
                ", properties=" + properties +
                '}';
    }
}

在配置文件中设置相应的属性值

<?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 class="com.zijie.domain.Massages" id="massages">
        <property name="name" value="王五"/>
        <property name="password" value="123456"/>
        <property name="path" value="beijing"/>
        <property name="phone" value="12234345678"/>
    </bean>
    <bean class="com.zijie.domain.Test" id="test">
        <!-- 普通类型 -->
        <property name="age" value="22"/>
        <property name="name" value="张三"/>

        <!-- Massages massages -->
        <property name="massages" ref="massages"/>

        <!-- list<String> list -->
        <property name="list">
            <list>
                <value>刘备</value>
                <value>关羽</value>
                <value>张飞</value>
            </list>
        </property>

        <!-- List<Massages> phones-->
        <property name="phones">
            <list>
                <ref bean="massages"></ref>
            </list>
        </property>

        <!-- Set<String> set-->
        <property name="set">
            <set>
                <value>111</value>
                <value>222</value>
            </set>
        </property>

        <!-- Map<String, Massages> map-->
        <property name="map">
            <map>
                <entry key="1" value-ref="massages"></entry>
            </map>
        </property>

        <!-- int[] arr-->
        <property name="arr">
            <array>
                <value>1</value>
                <value>2</value>
            </array>
        </property>

        <!-- Properties properties-->
        <property name="properties">
            <props>
                <prop key="one">第一</prop>
                <prop key="two">第二</prop>
            </props>
        </property>
    </bean>
</beans>

配置测试类

public class APP {
    public static void main(String[] args) {
        //1.获取StudentDaoImpl对象
        //创建Spring容器，指定要读取的配置文件路径
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        //从容器中获取对象

        Test test = (Test) app.getBean("test");
        //调用对象的方法进行测试
        System.out.println(test);
    }
}
菜鸟阿点
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【Spring笔记02】Spring中的IOC容器和DI依赖注入介绍
✅ Java 开发工程师，从事 Web 应用程序的研发，擅长 Spring、SpringBoot 等技术。 ✅ 热爱编程，业余时间学习新知识，通过 CSDN 记录学习心得和笔记内容。
05-14 173
【Spring笔记02】Spring中的IOC容器和DI介绍
Spring 学习笔记《依赖注入》源文件
01-20
在Java开发领域，Spring框架是不可或缺的重要组成部分，它以其强大的依赖注入（Dependency Injection，简称DI）特性而闻名。依赖注入是面向对象设计的一种模式，它允许我们解耦组件之间的依赖关系，使代码更加灵活，...
3.spring DI依赖注入
孤柒的博客
04-11 699
本文内容为Java中的SSM框架的搭建过程和知识点介绍，源文件已经上传到我的资源中,有需要的可以去看看, 我主页中的思维导图中内容大多从我的笔记中整理而来,相应技巧可在笔记中查找原题, 有兴趣的可以去 我的主页了解更多计算机学科的精品思维导图整理 本文可以转载，但请注明来处，觉得整理的不错的小伙伴可以点赞关注支持一下哦！ 1.DI简介 2.目标类 3.配置文件 4.测试 ...
SpringIOC笔记DI依赖注入
zjp567的博客
03-19 133
DI依赖注入 DI依赖注入set方法 ​ <bean class="com.sangeng.domain.Student" id="student"> <!-- name属性用来指定要设置哪个属性 value属性用来设置要设置的值 ref属性用来给引用类型的属性设置值，可以写上Spring容器中bean的id --> <property name.
java spring 依赖注入_java之spring之依赖注入
weixin_39724362的博客
02-16 131
一.DI: Dependency injection; 依赖注入依赖注入和控制反转是同一个概念的不同说法。对象的创建依赖于容器。对象属性的设置是由容器来设置。对象属性的赋值过程称为注入。二.Spring中如何注入属性：1.普通属性(String 和 基本数据类型)，直接通过 property 设置即可2.数组的设置足球蓝球乒乓球3.List 的设置和数组一样北京昌平山西平遥xxxx或者北京昌平山西...
spring学习笔记2-Spring Bean依赖注入
weixin_43942512的博客
11-14 167
Spring Bean依赖注入 Spring框架的核心功能之一就是通过依赖注入的方式来管理Bean之间的依赖关系。 依赖注入 每个基于应用程序的 java 都有几个对象，这些对象一起工作来呈现出终端用户所看到的工作的应用程序。当编写一个复杂的 Java 应用程序时，应用程序类应该尽可能独立于其他 Java 类来增加这些类重用的可能性，并且在做单元测试时，测试独立于其他类的独立性。依赖注入（或有时称...
spring源码笔记，依赖注入(DI)
Nicholas.S的博客
08-04 1315
前面我们主要分析了FileSystemXmlApplicationContext这个具体的IoC容器的初始化源码实现，在IoC容器中建立了BeanDefinition的数据映射，将其和beanName一起绑定在一个ConcurrentHashMap中。现在我们来看一下spring是如何将IoC容器中的Bean根据配置关联在一起的。 Spring中触发IoC容器“依赖注入”的方式有两种，一个是通过g...
Spring IOC笔记——DI(依赖注入)的使用详解
stormzhuo的博客
02-12 6677
前言 内容主要参考自《Spring实战》一书和尚硅谷-Spring5框架最新版教程，算是读书笔记或是原书的补充。 本文主要涉及IOC的部分，依照书中内容以及个人理解对Spring IOC容器进行了总结 IOC(概念及原理) 什么是IOC? Spring IOC，我们又通常将其称为 IOC 容器，IOC 的2个实现方式分别为 依赖注入（DI）和 依赖查找（DL）。由于依赖查找（DL）使用的很少，因此 IOC 也被叫做依赖注入。 IOC 底层原理 xml 解析、工厂模式、反射 DI(依赖注入)是如何实现的？
Spring的依赖注入【DI】，笔记
qq_29762001的博客
11-21 129
6、DI依赖注入 dependency injection 6.1、构造器注入 <bean class="cn.fh.pojo.User" id="user3"> <constructor-arg name="age" value="20"></constructor-arg> <constructor-arg na...
【Spring学习笔记 三】深入理解Beans和依赖注入DI
MaoLin Tian's Blog
08-19 632
上一篇Blog我们粗浅的搭建了第一个Spring框架，学习了基本的依赖注入实现方式，感觉能面对的场景太少了，本篇Blog我们详细的了解下Spring-Bean到底是如何工作的、作用域是什么，生命周期是什么，以及面对各种类型，依赖注入DI是通过什么方式实现注入的。 ...
Spring-依赖注入DI
weixin_42888638的博客
06-26 116
依赖注入DI学习笔记
动力节点老杜Spring6，配套笔记PDF文件
02-08
2. **依赖注入（Dependency Injection, DI）**： 为了遵循OCP，可以使用Spring的依赖注入机制。通过将数据库操作的具体实现（如`UserDao`的实现）作为依赖注入到`UserService`，使得`UserService`不直接创建`...
SSH笔记-泛型依赖注入
06-13
本笔记将深入探讨SSH中的Spring框架如何实现泛型依赖注入。 首先，我们来理解泛型的基本概念。泛型是Java SE 5引入的一种强大的类型系统机制，允许在类、接口和方法中使用类型参数，从而增强了代码的类型安全性和...
韩顺平Spring笔记
04-30
Spring是Java企业级应用开发中的主流框架，它以其依赖注入（Dependency Injection，DI）和面向切面编程（Aspect-Oriented Programming，AOP）为核心，极大地简化了复杂的应用程序设计。在笔记中，韩顺平老师可能详细...
Spring学习笔记.zip
03-18
Spring框架以其轻量级、依赖注入（DI）和面向切面编程（AOP）等特性而闻名，是Java EE开发中的主流选择。 **依赖注入（Dependency Injection，DI）** 依赖注入是Spring框架的核心特性之一，它允许开发者在运行时将...
SpringBoot集成EasyExcel实现模板写入多个sheet导出
LynneZoe的博客
07-18 447
SpringBoot集成EasyExcel实现模板写入多个sheet导出。
Spring纯注解开发
Admans的专栏
07-18 843
Spring3.0引入了纯注解开发的模式，框架的诞生是为了简化开发，那注解开发就是简化再简化。Spring的特性在整合MyBatis方面体现的淋漓尽致哦注解开发前，配置Bean时是在xml里将class分别写在Bean标签里，然后起id，就像这样注解开发后，配置Bean时首先将xml里的标签删掉，然后在类上添加@Component注解即可在xml文件中来写一个扫描包的注解标签，对象就装进IOC容器里了component-scan:component意为组件，scan意为扫描。
Vue 3 和 SpringBoot 实现文件分片上传示例
最新发布
exlink2012的专栏
07-22 238
实现分片上传，并使用Spring Boot在后端保存文件。前端将文件分片并逐个上传到后端，后端接收到所有分片后再进行合并，最终保存为一个完整文件。
SpringBoot new方式创建出来的类对象 @Value()注入的问题
阿潘是个程序猿的博客
07-18 329
ew方式创建出来的类对象获取springboot配置文件属性
深入解析：Spring DI运行时序图与依赖注入详解
本篇课堂笔记详细阐述了Spring+DI（依赖注入）的运行时序图及其核心原理。课程的目标在于帮助读者通过深入分析Spring源码来理解和掌握Spring框架的核心概念，特别是依赖注入的机制。对于那些Spring使用不熟练的学习...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值