Spring之DI(依赖注入)

这篇具有很好参考价值的文章主要介绍了Spring之DI(依赖注入)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

依赖注入(DI)是一个过程,在这个过程中,对象仅通过构造函数参数、工厂方法的参数或在对象被实例化后通过属性设置来定义它们的依赖项(即与该对象一起工作的其他对象)。然后,容器在创建 bean 时注入这些依赖项。这个过程基本上是与对象直接通过构造类或等机制来控制其依赖项的实例化或位置是相反的,因此得名控制反转。// 对象不直接创建自己,而是通过 Spring 容器创建,那么 Spring 容器是如何创建对象的?

使用 DI 原则,代码会更简洁,当对象具有依赖关系时,也能更有效的解耦。对象不检索它的依赖项,也不知道依赖项的具体类或者位置。因此,你的类将变得更容易测试,特别是当依赖关系建立在接口或者抽象基类上时,他们的子类或者模拟实现将允许在单元测试中被使用。// 依赖注入最大的好处,就是代码可以解耦合变得更加简洁

DI 主要有两种变体:基于构造函数的依赖注入和基于 Setter 方法的依赖注入

基础环境

1.创建Module

Spring之DI(依赖注入)

2.引入依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>spring</artifactId>
        <groupId>com.biem</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>DI</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.3</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
        </dependency>
    </dependencies>
</project>

3. 创建实体类com.biem.spring.pojo.User.java

package com.biem.spring.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * ClassName: User
 * Package: com.biem.spring.pojo
 * Description:
 *
 * @Create 2023/5/25 18:07
 * @Version 1.0
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private int id;
    private String name;
    private String password;
}

4. 创建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 http://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>

4. 测试com.biem.spring.test.UserTest.java文件

package com.biem.spring.test;

import com.biem.spring.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * ClassName: UserTest
 * Package: com.biem.spring.test
 * Description:
 *
 * @Create 2023/5/25 18:13
 * @Version 1.0
 */
public class UserTest {

}

基于构造函数的依赖注入

<constructor-arg>元素用于构造方法的注入,且定义时不分顺序,只需要通过name属性指定值即可。<constructor-arg>还提供了type属性用于指定参数类型,以避免字符串和基本类型的混淆。

实例

1.applicationContext.xml添加

    <bean id="user1" class="com.biem.spring.pojo.User">
        <constructor-arg name="id" value="1"></constructor-arg>
        <constructor-arg name="name" value="张三"></constructor-arg>
        <constructor-arg name="password" value="123456"></constructor-arg>
    </bean>

2. com.biem.spring.test.UserTest.java添加

    @Test
    public void testConstructorDI(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        User user = context.getBean("user1", User.class);
        System.out.println("user = " + user);
    }

3.输出结果

Spring之DI(依赖注入)

基于 Setter 方法的依赖注入

setter方法注入是通过<property>元素,<property>元素过name属性指定值。

实例

1.applicationContext.xml添加

    <bean id="user2" class="com.biem.spring.pojo.User">
        <property name="id" value="2"></property>
        <property name="name" value="李四"></property>
    </bean>

2. com.biem.spring.test.UserTest.java添加

    @Test
    public void testSetterDI(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        User user = context.getBean("user2", User.class);
        System.out.println("user = " + user);
    }

3.输出结果

Spring之DI(依赖注入)

Null值处理

<property name="name">
	<null />
</property>

name的值是null

<property name="name" value="null"></property>

name的值是字符串null

应用:简单登录系统

1.com.biem.spring.dao.UserDao.java

package com.biem.spring.dao;

/**
 * ClassName: UserDao
 * Package: com.biem.spring.dao
 * Description:
 *
 * @Create 2023/5/25 19:45
 * @Version 1.0
 */
public interface UserDao {
    public boolean login(String name, String password);
}

2.com.biem.spring.dao.impl.UserDaoImpl.java

package com.biem.spring.dao.impl;

import com.biem.spring.dao.UserDao;

/**
 * ClassName: UserDaoImpl
 * Package: com.biem.spring.dao.imp
 * Description:
 *
 * @Create 2023/5/25 19:46
 * @Version 1.0
 */
public class UserDaoImpl implements UserDao {
    @Override
    public boolean login(String name, String password) {
        if(name.equals("张三") && password.equals("123")){
            return true;
        }
        return false;
    }
}

3.com.biem.spring.service.UserService.java

package com.biem.spring.service;

/**
 * ClassName: UserService
 * Package: com.biem.spring.service
 * Description:
 *
 * @Create 2023/5/25 21:29
 * @Version 1.0
 */
public interface UserService {
    public boolean login(String username, String password);
}

4.com.biem.spring.service.impl.UserServiceImpl.java

package com.biem.spring.service.impl;

import com.biem.spring.dao.UserDao;
import com.biem.spring.service.UserService;

/**
 * ClassName: UserServiceImpl
 * Package: com.biem.spring.service.impl
 * Description:
 *
 * @Create 2023/5/25 21:31
 * @Version 1.0
 */
public class UserServiceImpl implements UserService {

    UserDao userDao;

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

    @Override
    public boolean login(String username, String password) {
        return userDao.login(username, password);
    }
}

5.编写applicationContext.xml配置文件

    <bean id="userDao" class="com.biem.spring.dao.impl.UserDaoImpl"></bean>
    <bean id="userService" class="com.biem.spring.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"/>
    </bean>

6.编写测试方法

    @Test
    public void login(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService user = context.getBean("userService", UserService.class);
        boolean flag = user.login("张三","123");
        if(flag){
            System.out.println("登录成功");
        } else {
            System.out.println("登录失败");
        }
    }

Spring之DI(依赖注入)

    @Test
    public void login(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService user = context.getBean("userService", UserService.class);
        boolean flag = user.login("张三","1234");
        if(flag){
            System.out.println("登录成功");
        } else {
            System.out.println("登录失败");
        }
    }

Spring之DI(依赖注入)文章来源地址https://www.toymoban.com/news/detail-469134.html

到了这里,关于Spring之DI(依赖注入)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Spring框架IOC容器和DI依赖注入

    IOC(Invertion Of Control):控制反转,使用对象时,由使用new创建对象转变为由外部提供对象,此过程中对象的创建控制权由程序转移到外部的思想称之为控制反转. DI(Dependency Injection):依赖注入,在容器中建立bean与bean之间的关系的过程,称之为依赖注入 pom.xml依赖引入 BookDao BookDaoImpl Book

    2023年04月09日
    浏览(89)
  • Spring的依赖注入(DI)是什么,有哪些实现方式?

    在Spring中,依赖注入的实现方式主要有以下几种: 类型式依赖注入(Type Based Dependency Injection):这种注入方式是通过Java接口或抽象类来实现的。具体来说,就是将需要注入的依赖关系定义为接口或抽象类,然后通过注解或XML配置文件等方式来指定具体的实现类。在运行时,

    2024年02月09日
    浏览(36)
  • Spring-2-深入理解Spring 注解依赖注入(DI):简化Java应用程序开发

      掌握纯注解开发依赖注入(DI)模式 学习使用纯注解进行第三方Bean注入 问题导入 思考:如何使用注解方式将Bean对象注入到类中 1.1 使用@Autowired注解开启自动装配模式(按类型) 说明:不管是使用配置文件还是配置类,都必须进行对应的Spring注解包扫描才可以使用。@Autowired默

    2024年02月14日
    浏览(58)
  • 深入理解 Spring IoC 和 DI:掌握控制反转和依赖注入的精髓

    在本文中,我们将介绍 IoC (控制反转)和 DI (依赖注入)的概念,以及如何在 Spring 框架中实现它们。 控制反转是软件工程中的一个原则,它将对象或程序的某些部分的控制权转移给容器或框架。我们最常在面向对象编程的上下文中使用它。 与传统编程相比,传统编程中我

    2024年02月04日
    浏览(58)
  • Spring5学习随笔-IOC(反转控制)、DI(依赖注入)和创建复杂对象

    学习视频:【孙哥说Spring5:从设计模式到基本应用到应用级底层分析,一次深入浅出的Spring全探索。学不会Spring?只因你未遇见孙哥】 控制:对于成员变量赋值的控制权 反转控制:把对于成员变量赋值的控制权,从代码中反转(转移)到Spring工厂和配置文件中。 好处:解耦合

    2024年02月05日
    浏览(42)
  • Spring-1-深入理解Spring XML中的依赖注入(DI):简化Java应用程序开发

    前两篇文章我们介绍了什么是Spring,以及Spring的一些核心概念,并且快速快发一个Spring项目,以及详细讲解IOC,今天详细介绍一些DI(依赖注入) 能够配置setter方式注入属性值 能够配置构造方式注入属性值 能够理解什么是自动装配 思考:向一个类中传递数据的方式有几种?(给类

    2024年02月13日
    浏览(50)
  • 【Spring进阶系列丨第二篇】Spring中的两大核心技术IoC(控制反转)与DI(依赖注入)

    我们都知道Spring 框架主要的优势是在 简化开发 和 框架整合 上,至于如何实现就是我们要学习Spring 框架的主要内容,今天我们就来一起学习Spring中的两大核心技术IoC(控制反转)与DI(依赖注入)。 以经典的三层架构MVC作为案例,以前我们都是这么干的,看如下代码: 按照

    2024年02月05日
    浏览(70)
  • Java Spring IoC&DI :探索Java Spring中控制反转和依赖注入的威力,增强灵活性和可维护性

    💓 博客主页:从零开始的-CodeNinja之路 ⏩ 收录文章:Java Spring IoCDI :探索Java Spring中控制反转和依赖注入的威力,增强灵活性和可维护性 🎉欢迎大家点赞👍评论📝收藏⭐文章 我们一下要学习的内容都是为了实现⾼内聚低耦合来进行的 软件设计原则:⾼内聚低耦合. ⾼内聚指

    2024年04月15日
    浏览(48)
  • 【Spring教程十】Spring框架实战:全面深入详解IOC/DI之--纯注解开发模式下的依赖注入&&注解读取properties配置文件

    欢迎大家回到《 Java教程之Spring30天快速入门》,本教程所有示例均基于Maven实现,如果您对Maven还很陌生,请移步本人的博文《 如何在windows11下安装Maven并配置以及 IDEA配置Maven环境》,本文的上一篇为《 全面深入详解IOC/DI注解开发》 Spring为了使用注解简化开发,并没有提供

    2024年02月04日
    浏览(57)
  • Spring6-IoC(Inversion of Control)控制反转和DI(Dependency Injection)依赖注入,手动实现IOC

    Java 反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意方法和属性;这种动态获取信息以及动态调用对象方法的功能称为 Java 语言的 反射机制 。简单来说, 反射机制指的是程序在运行时能够获取自身

    2024年02月09日
    浏览(62)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包