Spring——Spring是什么?IoC容器是什么?

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


前言

本人是一个普通程序猿!分享一点自己的见解,如果有错误的地方欢迎各位大佬莅临指导,如果你也对编程感兴趣的话,互关一下,以后互相学习,共同进步。这篇文章能够帮助到你的话,劳请大家点赞转发支持一下!


一、Spring是什么

我们通常所说的 Spring 指的是 Spring Framework(Spring 框架) ,它是⼀个开源框架。Spring 支持广泛的应用场景,它可以让 Java 企业级的应用程序开发起来更简单。

用一句话概括 Spring:Spring 是包含了众多工具方法的 IoC 容器


1.IoC 容器 —— 容器

容器是用来容纳某种物品的(基本)装置。

书包是用来容纳书本的容器。
Spring——Spring是什么?IoC容器是什么?,JavaEE,spring,java,后端,java-ee
水杯是用来容纳水的容器。Spring——Spring是什么?IoC容器是什么?,JavaEE,spring,java,后端,java-ee
衣柜是用来容纳衣服的容器。
Spring——Spring是什么?IoC容器是什么?,JavaEE,spring,java,后端,java-ee
所以,容器就是用来容纳 / 存储某些东西的

像数据结构中的, 顺序表,链表,栈,队列,二叉树,哈希表等结构也是容器 ,只不过 这些容器存储的是数据

IoC容器,存储的是 “对象” (Java中的实例化对象)。


2.IoC 容器 —— IoC

IoC = Inversion of Control 翻译成中文是“控制反转”的意思,也就是说 Spring 是⼀个“控制反转”的容器

控制反转,指的是控制权反转。

Java程序中对象的生命周期
不再由程序猿(代码片段)来控制
而是将 控制权反转
Spring(Spring容器/IoC容器)来控制


假设我们让程序来创建一台电脑。

传统程序开发

电脑(Computer)依赖CPU(Cpu),有CPU才能有电脑。
CPU依赖主板(Mainboard),有主板才能有CPU。
主板依赖电源(Power),有电源才能有主板。

Spring——Spring是什么?IoC容器是什么?,JavaEE,spring,java,后端,java-ee

public class Computer {
    public void init() {
        // 电脑依赖CPU
        Cpu cpu = new Cpu();
        cpu.init();
        System.out.println("电脑创建成功");
    }
}

class Cpu {

    public void init() {
        // CPU依赖主板
        Mainboard mainboard = new Mainboard();
        mainboard.init();
        System.out.println("CPU创建成功");
    }
}

class Mainboard {
    // 主板依赖电源
    public void init() {
        Power power = new Power();
        power.init();
        System.out.println("主板创建成功");
    }
}

class Power {
    private int size = 800;
    public void init() {
        System.out.println(size + "W电源创建成功");
    }
}
class Main {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.init();
    }
}

Spring——Spring是什么?IoC容器是什么?,JavaEE,spring,java,后端,java-ee
以上程序中,CPU,主板,电源都是写死的,如果客户想要定制,假设客户想要定制一个特殊规格的电源。


修改后代码

public class Computer {
    public void init(int size) {
        // 电脑依赖CPU
        Cpu cpu = new Cpu();
        cpu.init(size);
        System.out.println("电脑创建成功");
    }
}

class Cpu {

    public void init(int size) {
        // CPU依赖主板
        Mainboard mainboard = new Mainboard();
        mainboard.init(size);
        System.out.println("CPU创建成功");
    }
}

class Mainboard {
    // 主板依赖电源
    public void init(int size) {
        Power power = new Power(size);
        power.init();
        System.out.println("主板创建成功");
    }
}

class Power {
    private int size;

    public Power(int size) {
        this.size = size;
    }

    public void init() {
        System.out.println(size + "W电源创建成功");
    }
}

class Main {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.init(1200);
    }
}

Spring——Spring是什么?IoC容器是什么?,JavaEE,spring,java,后端,java-ee

这样的传统开发代码耦合程度很高,当最底层代码改动之后,整个调用链上的所有代码都需要修改。


控制反转式程序开发

我们可以尝试 不在每个类中自己创建下级类 ,如果自己创建下级类就会出现当下级类发⽣改变操作,自己也要跟着修改。此时,我们只需要 将原来由自己创建的下级类,改为传递的⽅式(也就是注⼊的⽅式) ,因为我们不需要在当前类中创建下级类了,所以下级类即使发生变化(创建或减少参数),当前类本身也无需修改任何代码,这样就完成了程序的解耦。

基于以上思路,我们把调用汽车的程序示例改造⼀下,把创建子类的方式,改为注入传递的方式,具体实现代码如下:

public class Computer {
    private Cpu cpu;

    public Computer(Cpu cpu) {
        this.cpu = cpu;
    }

    public void init() {
        // 电脑依赖CPU
        cpu.init();
        System.out.println("电脑创建成功");
    }
}

class Cpu {
    private Mainboard mainboard;

    public Cpu(Mainboard mainboard) {
        this.mainboard = mainboard;
    }

    public void init() {
        // CPU依赖主板
        mainboard.init();
        System.out.println("CPU创建成功");
    }
}

class Mainboard {
    // 主板依赖电源
    private Power power;

    public Mainboard(Power power) {
        this.power = power;
    }

    public void init() {
        power.init();
        System.out.println("主板创建成功");
    }
}

class Power {
    private int size;

    public Power(int size) {
        this.size = size;
    }

    public void init() {
        System.out.println(size + "W电源创建成功");
    }
}

class MyContainer {
    public Power power;
    public Mainboard mainboard;
    public Cpu cpu;
    public Computer computer;

    public MyContainer() {
        this.power = new Power(1200);
        this.mainboard = new Mainboard(power);
        this.cpu = new Cpu(mainboard);
        this.computer = new Computer(cpu);
    }
    public Computer getComputer() {
        return computer;
    }
}

class Main {
    public static void main(String[] args) {
        MyContainer mycontainer = new MyContainer();
        mycontainer.getComputer().init();
    }
}

我们可以看到传统程序开发中 由最高级的类,依次创建了需要的类。

而改进之后的 控制权反转 ,我们把控制权交给了容器Mycontainer后, 不再是上级对象创建并控制下级对象了 而是下级对象把注⼊将当前对象中 下级的控制权不再由上级类控制了,这样即使下级类发⽣任何改变,当前类都是不受影响的 这就是典型的控制反转,也就是 IoC 的实现思想

代码经过以上调整,无论底层类如何变化,整个调用链是不用做任何改变的,这样就完成了代码之间的解耦,从而实现了更加灵活、通用的程序设计了。


3.Spring IoC

文章开头提到过:Spring 是包含了多个⼯具方法的 IoC 容器,这就是对Spring 最核心的总结。

Spring 是⼀个 IoC(控制反转) 容器, IoC 代表的是对象的创建和销毁的权利都交给 Spring 来管理了

Spring 是⼀个 IoC容器, “容器”二字代表的是它具备两个最基础的功能:

  • 将对象存入到容器
  • 从容器中取出对象

这两个功能也是Spring最核心的功能。

将对象存储在容器中的好处
将对象放到容器中呢,就类似于线程池。
线程池会提前帮你创建好线程存在线程池中,你要用的时候拿就行,用完再放回来。
容器也是如此,帮你创建好对象就放在容器里,你用就拿,用完就换回来。
而普通程序开发则是要用的时候才创建对象,用完就销毁。


二、DI是什么

DI 是 Dependency Injection 的缩写,翻译成中⽂是“依赖注入”的意思。

所谓依赖注入,就是 由 IoC 容器在运⾏期间,动态地将某种依赖关系注入到对象之中 。所以,依赖注入(DI)和控制反转(IoC)是从不同的角度的描述的同⼀件事情,就是指通过引入 IoC 容器,利用依赖关系注入的方式,实现对象之间的解耦。

也就是说,比如说我要创造一台电脑,在创建过程中。
我现在需要主板,我就动态的去容器中拿主板,注入到电脑中去。
这个过程就称之为依赖注入。


总结

以上就是今天要讲的内容,本文介绍了Spring是什么,要开启框架Spring的学习了。

路漫漫不止修身,也养性。文章来源地址https://www.toymoban.com/news/detail-612060.html

到了这里,关于Spring——Spring是什么?IoC容器是什么?的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

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

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

相关文章

  • spring ioc容器

    ioc是 inversion of Control的简写,意为控制反转。通过其对所有的Java对象的实例化和初始化,控制对象与对象之间的依赖关系。 (1)控制反转是一种思想。 (2)控制反转是为了 降低程序耦合度,提高程序扩展力。 (3)控制反转,反转的是什么? 答:将对象的创建权利交出去

    2024年01月17日
    浏览(38)
  • Java面试题:你知道Spring的IOC吗?那么,它为什么这么重要呢?

    Spring的IOC(控制反转)是一种设计模式,它允许开发者将对象的创建和管理交给Spring框架来完成。在Spring中,IOC允许开发者将对象依赖关系从代码中分离出来,从而使代码更加灵活、可重用和易于管理。 IoC 全称Inverse of Control( 反向控制或控制反转 )。 在类和类之间存在控

    2024年04月28日
    浏览(99)
  • Spring 6.X IoC 容器

    下面主要介绍 Spring 框架对控制反转 (IoC) 原理的实现 首先要说明的是:IoC 也称为依赖注入,这是一个过程。 其次依赖项的定义:对象仅通过构造函数参数、工厂方法的参数,或在构造对象实例、工厂方法返回后在对象实例上设置的属性来定义其依赖项(即它们使用的其他对

    2024年02月09日
    浏览(41)
  • 3、Spring 之IOC 容器 详解

    IoC 是 Inversion of Control 的简写,译为“控制反转”,它不是一门技术,而是一种 设计思想 ,是一个重要的面向对象编程法则,能够指导我们如何设计出松耦合、更优良的程序。 Spring 通过 IoC 容器 来管理 所有 Java 对象的实例化和初始化 , 控制对象与对象之间的依赖关系 。我

    2024年02月09日
    浏览(41)
  • Spring核心容器IOC案例讲解,带你理解IOC

    Universe Infinity inc. 什么是IOC容器,先把IOC给忽略到,其实就是个容器。 什么?容器又是个啥玩意?容器是用来放东西的东西啊。 各个领域都喜欢起一些专业术语,显得很高级。给你讲IOC是不是很高级,给你讲Map是不是就明白了。 bean对象最终存储在spring容器中,在spring源码底

    2024年01月24日
    浏览(37)
  • Spring 核心之 IOC 容器学习二

    Annotation 的前世今生 定位 Bean 扫描路径 读取 Annotation 元数据 扫描指定包并解析为 BeanDefinition

    2024年01月19日
    浏览(51)
  • Spring 核心之 IOC 容器学习一

    1、BeanFactory 其中 BeanFactory 作为最顶层的一个接口类,它定义了 IOC 容器的基本功能规范,BeanFactory 有三个重要的子类:ListableBeanFactory、HierarchicalBeanFactory 和 AutowireCapableBeanFactory。但是从类图中我们可以发现最终的默认实现类是 DefaultListableBeanFactory,它实现了所有的接口。 那

    2024年01月19日
    浏览(44)
  • spring6-IOC容器

    IOC 是 Inversion of Control 的简写,译为“控制反转”,它不是一门技术,而是一种设计思想,是一个重要的面向对象编程法则,能够指导我们如何设计出松耦合、更优良的程序。 Spring 通过 IoC 容器来管理所有 Java 对象的实例化和初始化,控制对象与对象之间的依赖关系。我们将

    2024年02月08日
    浏览(42)
  • Spring的简介ioc容器及注入方式

    Spring是一个开源框架,它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。    Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。    然而,Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言,任何Java应用都可以从Sprin

    2024年02月11日
    浏览(34)
  • spring6-实现简易版IOC容器

    我们都知道,Spring框架的IOC是基于Java反射机制实现的,下面我们先回顾一下java反射。 1、回顾Java反射 Java 反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意方法和属性;这种动态获取信息以及动态调

    2024年02月08日
    浏览(44)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包