Springboot 入门指南:控制反转和依赖注入的含义和实现方式

这篇具有很好参考价值的文章主要介绍了Springboot 入门指南:控制反转和依赖注入的含义和实现方式。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

一、什么是控制反转(IoC)?

二、什么是依赖注入(DI)?

三、如何在 springboot 中使用 IoC 和 DI?

总结


一、什么是控制反转(IoC)?

控制反转(Inversion of Control,简称 IoC)是一种设计原则,它的目的是降低代码之间的耦合度,提高模块化和可测试性。控制反转的含义是,将对象的创建、配置和管理交给一个外部容器来完成,而不是由对象自己或使用对象的类来完成。这样,对象就不需要知道或关心它们的依赖关系是如何被创建和维护的,只需要按照一定的规则和接口与容器进行交互即可。

在 spring 框架中,IoC 容器就是负责实现控制反转的核心组件,它可以通过配置文件或注解的方式来管理应用程序中的各种 bean(即被容器管理的对象)。IoC 容器可以根据 bean 的定义和依赖关系来自动创建、装配和销毁 bean,从而简化了开发者的工作。

二、什么是依赖注入(DI)?

依赖注入(Dependency Injection,简称 DI)是一种实现控制反转的具体方法,它的思想是,当一个对象需要另一个对象(或多个对象)来完成某些功能时,不是由该对象自己去创建或查找依赖对象,而是由外部容器在运行时将依赖对象通过构造器、方法或属性等方式注入到该对象中。这样,对象就可以在不改变自身代码的情况下,动态地获得所需的依赖对象,并且可以方便地替换不同的实现。

在 spring 框架中,DI 是通过 IoC 容器来实现的,开发者只需要在 bean 的定义中声明其依赖关系,或者在 bean 的类中使用注解来标注其依赖属性或方法,就可以让 IoC 容器自动地为其注入相应的 bean。spring 支持基于类型(by type)、基于名称(by name)和基于构造器(by constructor)等多种方式来进行依赖注入。

三、如何在 springboot 中使用 IoC 和 DI?

springboot 是一种基于 spring 的轻量级框架,它可以帮助开发者快速搭建和运行 spring 应用程序,无需过多的配置和代码。springboot 采用了约定优于配置(convention over configuration)的原则,提供了一系列的自动配置类和启动器(starter),使得开发者只需要引入相应的依赖,并按照一定的规范来编写代码,就可以让 springboot 为其自动配置好所需的 bean 和组件。

要在 springboot 中使用 IoC 和 DI,有以下几个步骤:

  1. 在 pom.xml 文件中引入 spring-boot-starter-web 依赖,这会自动引入 spring-webmvc、spring-aop、spring-beans 等与 web 开发相关的组件。
  2. 在主类上使用 @SpringBootApplication 注解,这会启用自动配置、组件扫描和其他特性。
  3. 在需要被 IoC 容器管理的类上使用 @Component、@Service、@Controller、@Repository 等注解,这会让 springboot 自动扫描并注册这些类为 bean。
  4. 在需要依赖注入的类中使用 @Autowired、@Resource、@Inject 等注解,或者使用构造器或 setter 方法,来标注或声明其依赖的 bean,这会让 springboot 自动为其注入相应的 bean 实例。
  5. 在 application.properties 或 application.yml 文件中配置一些自定义的属性或参数,这会覆盖 springboot 的默认配置,并且可以在 bean 中使用 @Value 或 @ConfigurationProperties 注解来获取这些属性的值。

下面是一个简单的示例,演示了如何在 springboot 中使用 IoC 和 DI 来实现一个用户服务的功能:

// User.java
package com.example.demo.entity;

import lombok.Data;

@Data
public class User {
    private Long id;
    private String name;
    private Integer age;
}

// UserDao.java
package com.example.demo.dao;

import com.example.demo.entity.User;
import org.springframework.stereotype.Repository;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

@Repository
public class UserDao {
    // 模拟数据库
    private static final List<User> users = new ArrayList<>();

    static {
        users.add(new User(1L, "Alice", 20));
        users.add(new User(2L, "Bob", 21));
        users.add(new User(3L, "Charlie", 22));
    }

    // 根据 id 查询用户
    public User findById(Long id) {
        Optional<User> user = users.stream().filter(u -> u.getId().equals(id)).findFirst();
        return user.orElse(null);
    }

    // 查询所有用户
    public List<User> findAll() {
        return users;
    }
}

// UserService.java
package com.example.demo.service;

import com.example.demo.dao.UserDao;
import com.example.demo.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {
    // 注入 UserDao
    @Autowired
    private UserDao userDao;

    // 根据 id 查询用户
    public User getUserById(Long id) {
        return userDao.findById(id);
    }

    // 查询所有用户
    public List<User> getAllUsers() {
        return userDao.findAll();
    }
}

// UserController.java
package com.example.demo.controller;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class UserController {
    // 注入 UserService
    @Autowired
    private UserService userService;

    // 根据 id 查询用户
    @GetMapping("/user/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.getUserById(id);
    }

    // 查询所有用户
    @GetMapping("/users")
    public List<User> getUsers() {
        return userService.getAllUsers();
    }
}

// DemoApplication.java
package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {

	public static void main(String[] args) {
		SpringApplication.run(DemoApplication.class, args);
	}

}

总结

控制反转和依赖注入是 spring 框架的核心特征,它们可以帮助开发者编写出低耦合、高内聚、易测试的代码,提高开发效率和质量。springboot 是一种基于 spring 的轻量级框架,它可以让开发者更方便地使用 spring 的功能,无需过多的配置和代码。要在 springboot 中使用 IoC 和 DI,只需要引入相应的依赖,使用一些简单的注解,就可以实现对象的创建、配置和管理。文章来源地址https://www.toymoban.com/news/detail-673756.html

到了这里,关于Springboot 入门指南:控制反转和依赖注入的含义和实现方式的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

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

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

相关文章

  • Spring第二讲:SpringIoC控制反转、依赖注入

    4、1什么是IoC 在传统的 Java 应用中,一个类想要调用另一个类中的属性或方法,通常会先在其代码中通过 new 的方式将后者的对象创建出来,然后才能实现属性或方法的调用。但在 Spring 应用中,Java 对象创建的控制权是掌握在 IoC 容器手里,开发者通过XML或注解的配置将Java对

    2024年02月13日
    浏览(45)
  • spring--Ioc控制反转/DI依赖注入

    1.概念:在使用对象的时候,由主动的new转换为外部提供对象,将对象创建的控制权交给外部,即控制反转 2.spring提供了一个容器,称为IOC容器,用来从当ioc中的外部 3.被管理或者被创建的对象在ioc中被叫做bean 使用步骤 1.导入依赖 spring-context 依赖,用到xml文件就需导入 2.创建

    2024年02月12日
    浏览(39)
  • 6.3Java EE——控制反转与依赖注入

    一、控制反转的概念 传统面向对象程序设计原则         控制反转(Inversion of Control,缩写为IoC)是面向对象编程中的一个设计原则,用来降低程序代码之间的耦合度。在传统面向对象编程中,获取对象的方式是用new主动创建一个对象,也就是说应用程序掌握着对

    2024年02月16日
    浏览(34)
  • 深入理解WPF中的依赖注入和控制反转

    在WPF开发中, 依赖注入(Dependency Injection)和控制反转(Inversion of Control)是程序解耦的关键,在当今软件工程中占有举足轻重的地位,两者之间有着密不可分的联系 。今天就以一个简单的小例子,简述如何在WPF中实现依赖注入和控制反转,仅供学习分享使用,如有不足之处

    2024年02月06日
    浏览(49)
  • CommunityToolkit.Mvvm8.1 IOC依赖注入控制反转(5)

      本系列文章导航 https://www.cnblogs.com/aierong/p/17300066.html https://github.com/aierong/WpfDemo (自我Demo地址) 希望提到的知识对您有所提示,同时欢迎交流和指正 作者:aierong 出处:https://www.cnblogs.com/aierong     CommunityToolkit.Mvvm包不提供ioc功能,但是官方建议使用:Microsoft.Extensions.DependencyInject

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

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

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

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

    2024年02月05日
    浏览(40)
  • Spring学习笔记(二)Spring的控制反转(设计原则)与依赖注入(设计模式)

    是一种设计原则,降低程序代码之间的耦合度 对象由Ioc容器统一管理,当程序需要使用对象时直接从IoC容器中获取。这样对象的控制权就从应用程序转移到了IoC容器 依赖注入是一种消除类之间依赖关系的设计模式。例如,A类要依赖B类,A类不再直接创建B类,而是把这种依赖

    2024年02月19日
    浏览(37)
  • 延时盲注技术:SQL 注入漏洞检测入门指南

    部分数据来源: ChatGPT  环境准备 引言         在网络安全领域中,SQL 注入漏洞一直是常见的安全隐患之一。它可以利用应用程序对用户输入的不恰当处理,导致攻击者能够执行恶意的 SQL 查询语句,进而获取、修改或删除数据库中的数据。为了帮助初学者更好地理解和

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

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

    2024年02月05日
    浏览(66)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包