Spring依赖注入（DI，Dependency Injection）

最新推荐文章于 2024-05-21 10:23:42 发布
最新推荐文章于 2024-05-21 10:23:42 发布
阅读量140 收藏
点赞数
分类专栏： Spring 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Riove/article/details/118313798
版权

摘要：Spring笔记_04-2021-06-28

1.什么是依赖注入？

**官方说明：**https://docs.spring.io/spring-framework/docs/5.2.0.RELEASE/spring-framework-reference/core.html#beans-dependencies

依赖注入：

  • 依赖注入（DI）是一个过程，对象仅通过构造函数参数、工厂方法的参数或在对象实例构造或从工厂方法返回后在对象实例上设置的属性来定义它们的依赖（即与它们一起工作的其他对象）

  • Spring容器在创建bean时注入这些依赖项。这个过程基本上是bean本身的逆过程（因此称为控制反转），通过使用类的直接构造或服务定位器模式来控制其依赖项的实例化或位置

  • 使用DI原则，代码更干净，当对象具有依赖关系时，解耦更有效。对象不查找其依赖项，也不知道依赖项的位置或类。因此，类变得更容易测试，特别是当依赖关系在接口或抽象基类上时，这些接口或抽象基类允许在单元测试中使用存根或模拟实现

DI有两个主要的方式：

  • 基于构造函数的依赖注入
  • 基于Setter的依赖注入
  • 其它方式

2.基于构造函数的依赖注入

2.1 搭建环境

1.新建一个maven项目，导入依赖

2.导入容器applicationContext.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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>

3.编写接口UserDao和实现类UserDaoImpl、UserDaoImpl2、UserDaoImpl3

package com.riove.dao;

public interface UserDao {
    void getUser();
}

package com.riove.dao;

public class UserDaoImpl implements UserDao{

    public void getUser() {
        System.out.println("SqlServer数据库！");
    }
}

package com.riove.dao;

public class UserDaoImpl2 implements UserDao{

    public void getUser() {
        System.out.println("MySql数据库！");
    }
}

package com.riove.dao;

public class UserDaoImpl3 implements UserDao{

    public void getUser() {
        System.out.println("Oracle数据库！");
    }
}

4.编写接口UserService和实现类UserServiceImpl

package com.riove.service;

import com.riove.dao.UserDao;

public interface UserService {

    void getUser();
    void setUserDao(UserDao userDao);
}

package com.riove.service;

import com.riove.dao.UserDao;

public class UserServiceImpl implements UserService{


    private UserDao userDao;

    public UserServiceImpl() {
    }

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

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

    public void getUser() {
        userDao.getUser();
    }
}

5.实体类（备用）

package com.riove.pojo;

/**
 * @Author Riove
 * @Create 2021/6/28 20:05
 */
public class User {

    private int id;
    private String username;
    private String password;

    public User() {
    }

    public User(int id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

2.2 构造函数参数解析

	<!--2.1 构造函数参数解析-->
    <!--参数解析：
         前提：当我们已经知道传入的参数结构，比如该例：需要传的是这三个对象UserDaoImpl、UserDaoImpl2、UserDaoImpl3其中之一
        重点：这三个对象已经在Spring容器中创建，即由bean对象创建，方能引用
        rel：当传入参数为已知对象的id
       关键：需要传入参数的类中必须含有构造方法，比如该例：UserServiceImpl中必须存在构造方法
    -->
    <bean id="userServiceImpl" class="com.riove.service.UserServiceImpl">
        <constructor-arg ref="userDaoImpl"/>
    </bean>
	<!--在容器中创建对象-->
    <bean id="userDaoImpl" class="com.riove.dao.UserDaoImpl"/>
    <bean id="userDaoImpl2" class="com.riove.dao.UserDaoImpl2"/>
    <bean id="userDaoImpl3" class="com.riove.dao.UserDaoImpl3"/>

public class DITest {
    @Test
    public void test1() {
        //1.获取上下文
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        /**
         *2.通过容器，我们可以做我们想做的任何业务，比如：获取bean对象
         * 
         *Tip：getBean();这个方法可以传入多个属性值
         *      当我们知道该对象返回值类型，只需要在传入的参数对应对象类型，这样就不用强转了
         */
        UserServiceImpl userServiceImpl = context.getBean("userServiceImpl", UserServiceImpl.class);
        userServiceImpl.getUser();
    }
}

2.3 构造函数参数类型匹配

	<!--2.2 构造函数参数类型匹配-->
    <!--参数类型匹配：
         前提：当我们已经知道传入的参数的类型，比如：public User(int id, String username, String password)
        重点：注意参数的个数，有多少个参数就必须注入多少个值，如构造函数User中有3个参数，那么必须对应有3个<constructor-arg type="" value=""/>
        type：参数类型
		value：赋值
    -->
    <bean id="user" class="com.riove.pojo.User">
        <constructor-arg type="int" value="123456"/>
        <constructor-arg type="java.lang.String" value="admin"/>
        <constructor-arg type="java.lang.String" value="admin"/>
    </bean>

	@Test
    public void test2() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        /**
         *2.通过容器，我们可以做我们想做的任何业务，比如：获取bean对象
         *
         *Tip：getBean();这个方法可以传入多个属性值
         *      当我们知道该对象返回值类型，只需要在传入的参数对应对象类型，这样就不用强转了
         */
        User user = context.getBean("user", User.class);
        System.out.println(user);
    }

2.4 构造函数参数索引

`<!--2.3 构造函数参数索引-->
    <!--参数索引：
         前提：当我们已经知道传入的参数的个数，我觉得还得知道它们的属性，和需要传入的值，不过通过索引：个数：是重点
        重点：参数的个数，有多少个参数就必须注入多少个值，如User中有3个参数，那么必须对应有3个<constructor-arg index="" value=""/>
        index：索引，类似我们所学的数组：index[0]、index[1]、index[3]
        value：赋值
    -->
    <bean id="user" class="com.riove.pojo.User">
        <constructor-arg index="0" value="123456"/>
        <constructor-arg index="1" value="admin"/>
        <constructor-arg index="2" value="admin"/>
    </bean>

    @Test
    public void test2() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        /**
         *2.通过容器，我们可以做我们想做的任何业务，比如：获取bean对象
         *
         *Tip：getBean();这个方法可以传入多个属性值
         *      当我们知道该对象返回值类型，只需要在传入的参数对应对象类型，这样就不用强转了
         */
        User user = context.getBean("user", User.class);
        System.out.println(user);
    }

2.5 构造函数参数名称

	<!--2.3 构造函数参数名称-->
    <!--参数索引：
         前提：当我们已经知道传入的参数的参数名（标识符）
        重点：参数名、变量名，有多少个参数就必须注入多少个值，如User中有3个参数，那么必须对应有3个<constructor-arg name="" value=""/>
        name：参数名，自定义属性名又称变量名、标识符
        value：赋值
    -->
    <bean id="user" class="com.riove.pojo.User">
        <constructor-arg name="id" value="123456"/>
        <constructor-arg name="username" value="admin"/>
        <constructor-arg name="password" value="admin"/>
    </bean>

@Test
public void test2() {
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    /**
     *2.通过容器，我们可以做我们想做的任何业务，比如：获取bean对象
     *
     *Tip：getBean();这个方法可以传入多个属性值
     *      当我们知道该对象返回值类型，只需要在传入的参数对应对象类型，这样就不用强转了
     */
    User user = context.getBean("user", User.class);
    System.out.println(user);
}

3.基于Setter的依赖注入

3.1 实体类（Student.java）

package com.riove.pojo;

import com.riove.dao.UserDaoImpl;

import java.util.*;

/**
 * @Author Riove
 * @Create 2021/6/28 20:05
 */
public class Student {

    //基本类型：int/string/double...
    private String name;
    //数组类型
    private String[] books;
    //对象类型
    private UserDaoImpl userDao;
    //集合类型
    private List<String> list;
    //map类型
    private Map<String,String> map;
    //set类型
    private Set<String> set;
    //properties类型
    private Properties properties;

    public Student() {
    }

    public Student(String name, String[] books, UserDaoImpl userDao, List<String> list, Map<String, String> map, Set<String> set, Properties properties) {
        this.name = name;
        this.books = books;
        this.userDao = userDao;
        this.list = list;
        this.map = map;
        this.set = set;
        this.properties = properties;
    }

    public String getName() {
        return name;
    }

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

    public String[] getBooks() {
        return books;
    }

    public void setBooks(String[] books) {
        this.books = books;
    }

    public UserDaoImpl getUserDao() {
        return userDao;
    }

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

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

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

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

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

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

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

    public Properties getProperties() {
        return properties;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", books=" + Arrays.toString(books) +
                ", userDao=" + userDao +
                ", list=" + list +
                ", map=" + map +
                ", set=" + set +
                ", properties=" + properties +
                '}';
    }
}

3.2 Setter的依赖注入

	<!--基于Setter的依赖注入-->
    <bean id="student" class="com.riove.pojo.Student">
        <!--
            1.基本类型：int/string/double...
            name：属性名
            value：赋值
        -->
        <property name="name" value="张三"/>
        <!--
            2.数组类型
            name：属性名
            array：数组类型
            value-type：数据类型
            value：赋值
        -->
        <property name="books">
            <array value-type="java.lang.String">
                <value>西游记</value>
                <value>红楼梦</value>
                <value>水浒传</value>
                <value>三国演义</value>
            </array>
        </property>
        <!--
            3.对象类型
            name：属性名
            ref：对象类型
        -->
        <property name="userDao" ref="userDaoImpl"/>
        <!--
            4.集合类型
            name：属性名
            list：集合类型
            value-type：泛型信息
            value：赋值
        -->
        <property name="list">
            <list value-type="java.lang.String">
                <value>张三</value>
                <value>李四</value>
                <value>王五</value>
            </list>
        </property>
        <!--
            5.map类型
            name：属性名
            map：集合类型
            key-type：键的类型
            value-type：值得类型
            entry：(key,value)
        -->
        <property name="map">
            <map key-type="java.lang.String" value-type="java.lang.String">
                <entry key="user1" value="张三"/>
                <entry key="user2" value="李四"/>
                <entry key="user3" value="王五"/>
            </map>
        </property>
        <!--
            6.set类型
            name：属性名
            set：set类型
            value-type：类型
            value：赋值
        -->
        <property name="set">
            <set value-type="java.lang.String">
                <value>张三</value>
                <value>李四</value>
            </set>
        </property>
        <!--
            7.properties类型
            name：属性名
            props：properties类型
            prop：
            key：
        -->
        <property name="properties">
            <props>
                <prop key="driver">com.mysql.Driver</prop>
                <prop key="url">jdbc:mysql:3306//localhost/database</prop>
                <prop key="username">root</prop>
                <prop key="password">root</prop>
            </props>
        </property>
    </bean>

	@Test
    public void test3() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        /**
         *2.通过容器，我们可以做我们想做的任何业务，比如：获取bean对象
         *
         *Tip：getBean();这个方法可以传入多个属性值
         *      当我们知道该对象返回值类型，只需要在传入的参数对应对象类型，这样就不用强转了
         */
        Student student = context.getBean("student", Student.class);
        System.out.println(student);
    }
Riove
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
依赖注入：Dependency injection-英文书签文字版
12-06
依赖注入：Dependency injection-英文书签文字版 全面讲解Spring中的依赖注入，是英文的文字版，带书签
spring 的ioc的依赖注入（DI）-------------对象注入
健康平安的活着的专栏
01-03 279
一.依赖注入 依赖注入DI：它是spring框架核心ioc的具体实现。在编写程序时候，通过控制反转，把对象的创建交给spring容器中。ioc的解耦知识降低他们之间的依赖关系，但不会消除，如业务层调用持久层。 二.依赖的方式 2.1 通过set方法 1.set方法的注入： 首先，需要引入p命名空间： xmlns:p="http://www.springframework.org/schema/p" 其次，需要注入方式： <bean id="userService" class="" p:
Spring框架依赖注入（Dependency Injection）详解
qq_52943130的博客
06-11 446
Spring框架通过IOC创建对象，而创建对象完成之后需要对某些属性进行赋值，这个时候便需要用到依赖注入（Dependency Injection）简称DI，而实现DI也有两种主要方法，一种是基于XML配置文件的DI实现，另外一种是基于注解的DI实现。下面将会围绕这两种方法展开详细解析DI。
依赖注入（Dependency Injection,DI）
Daylight629博客
02-05 585
依赖注入（Dependency Injection,DI） 依赖注入（Dependency Injection,DI）。 依赖 : 指Bean对象的创建依赖于容器 . Bean对象的依赖资源 . 注入 : 指Bean对象所依赖的资源 , 由容器来设置和装配 . Set 注入 要求被注入的属性 , 必须有set方法 , set方法的方法名由set + 属性首字母大写 , 如果属性是boolean类型 , 没有set方法 , 是 is . ...
spring依赖注入(Dependency Injection, DI)的基本原则
学亮编程手记
11-22 398
配置对象的工作应该由IoC容器负责，“查找资源”的逻辑应该从应用组件的代码中抽取出来，交给IoC容器负责。容器全权负责组件的装配，它会把符合依赖关系的对象通过属性（JavaBean中的setter）或者是构造器传递给需要的对象。通过依赖注入，可以通过更换具体的依赖对象来扩展应用程序的功能，而无需修改依赖注入的类。单一职责原则(Single Responsibility Principle, SRP)：每个类应该只关注自己的核心职责，而将依赖的创建和管理交给外部容器来处理。
java 注入依赖_依赖注入（Dependency Injection）
weixin_42115074的博客
02-22 2248
一、依赖注入的概念了解介绍依赖注入(di)，首先要先了解一个概念——即控制反转(ioc)。控制反转是面向对象编程的一种设计原则，可以用来减低计算机代码之间的耦合度。在传统的应用程序中，都是程序员手动在类的内部创建需要依赖的对象，而这种方式经常会导致类与类之间的高度耦合，难以测试。而当有了ioc容器之后，类把创建和查找依赖对象的权限都交给了容器，由容器进行注入组合对象，所以对象与对象之间是松散耦合，...
spring-optional-dependency-injection
05-10
可选的DI-Spring框架
《Dependency Injection》电子书
09-11
本书由GOOGLE软件工程师编写，不仅介绍了依赖注入相关的技术知识，而且讲解了与之相关的Spring和Guice框架。 适合开始接触和使用DI的技术者以及掌握该技术并拥有相关开发经历的技术人员做进一步提高用。 MANNING...
Java 9 Dependency Injection_Write loosely coupled code with Spring 5 and Guice
05-26
Java 9 Dependency Injection_Write loosely coupled code with Spring 5 and Guice-Packt Publishing(2018) Dependency Injection is a design pattern that allows us to remove the hardcoded dependencies and ...
codekrypt-di:自定义依赖注入框架（类似于Spring）
03-07
Codekrypt依赖注入器特征支持使用@Autowire和@Qualifier现场注入支持@PostConstruct用法HornAirImp.java @Componentpublic class HornAirImpl implements Horn { @Override public void honk () { System ....
通联支付API集成(适用于SpringBoot)
m0_55337678的博客
05-17 381
通联支付实现代码
Spring-Cloud 微服务
weixin_65127444的博客
05-15 903
先来思考一个问题*通过上一章的操作，我们已经可以实现微服务之间的调用。但是我们把服务提供者的网络地址（ip，端口）等硬编码到了代码中，这种做法存在许多问题：1.一旦服务提供者地址变化，就需要手工修改代码2. 一旦是多个服务提供者，无法实现负载均衡功能3.一旦服务变得越来越多，人工维护调用关系困难那么应该怎么解决呢，这时候就需要通过注册中心动态的实现。
(三)Spring教程——依赖注入与控制反转
05-14 561
Spring有两个重要的接口：BeanFactory和ApplicationContext，所谓的容器就是实现了BeanFactory接口或者是ApplicationContext接口的类的实例，BeanFactory是最顶层、最基本的接口，它描述了容器需要实现的最基本的功能，比如对象的注册、获取等。在编写传统的Java应用代码时，我们一般是直接在对象内部通过new来创建对象，让程序主动去创建依赖对象，这就是一个“谁使用，谁创建”的过程，创建依赖对象的主动权和创建时机都是由自己来把控。
SpringBoot Validation自定义注解之校验指定最小整数
最新发布
thinkers
05-21 34
1，引入核心关键依赖。
spring 循环依赖
weixin_45849726的博客
05-14 446
先创建ABean1.0. 记录正在创建ABean singletonCurrentlyInCreation<1.1.实例化ABean–>得到一个对象–>存入singletonFactories1.2. 填充BBean属性–>去单例池找BBean–>没有就创建1.3. 进行其他依赖注入1.4. 初始化前，初始化1.5. 初始化后1.6. 放入单例池创建BBean2.1. 实例化BBean–>得到一个对象。
【SpringBoot】93、SpringBoot中使用Jasypt实现配置文件中敏感数据加密
Asurplus
05-17 20
Jasypt(Java Simplified Encryption)是一个 Java 库，它允许开发人员以最小的努力为项目添加基本的加密功能，而无需深入了解密码学的工作原理
Spring: Spring自带的Http客户端RestTemplate
玉汝于成
05-17 265
RestTemplate 是 Spring 框架中用于发送 HTTP 请求的客户端工具类。它简化了与 REST 服务的交互，并提供了许多方法来发送 HTTP 请求，如 GET、POST、PUT、DELETE 等。
基于SpringBoot的在线视频教育平台源码数据库
s123456sj的博客
05-17 831
随着科学技术的飞速发展，各行各业都在努力与现代先进技术接轨，通过科技手段提高自身的优势；对于在线视频教育平台当然也不能排除在外，随着网络技术的不断成熟，带动了在线视频教育平台，它彻底改变了过去传统的管理方式，不仅使服务管理难度变低了，还提升了管理的灵活性。这种个性化的平台特别注重交互协调与管理的相互配合，激发了管理人员的创造性与主动性，对在线视频教育平台而言非常有利。
SpringBoot项目的项目部署全过程
泉涸的博客
05-14 800
cd /opt/nginx/sbin 此时进入nginx的sbin (里面是nginx的启动命令)./configure--prefix=/opt/nginx (尽量安装到/opt/nginx目录下)(部署之前记得将全部ip(localhost/127.0.0.1)改为你的云服务器ip)(ps -ef |grep nginx 如果有端口即为启动成功)1.将提前准备好的nginx的安装包上传到Linux中(我用的是Xftp)将dist目录下的所有文件都上传到 /opt/nginx/html 中。
Spring依赖注入
09-10
Spring依赖注入（Dependency Injection，简称DI）是Spring框架的核心特性之一。它通过控制反转（Inversion of Control，简称IOC）实现对象之间的解耦和依赖关系的管理。 简单来说，依赖注入是指将一个对象的依赖...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值