Spring概念:容器、Ioc、DI

文章介绍了Spring框架的核心特性——IoC(控制反转)和DI(依赖注入)。IoC意味着不再由程序自身控制对象的创建和管理,而是由Spring框架来处理。DI是IoC的一种实现方式,通过Spring将依赖的对象注入到需要它们的地方,从而实现代码解耦。文章通过传统程序开发和SpringIoC的对比,展示了IoC和DI如何简化程序设计和提高可维护性。
摘要由CSDN通过智能技术生成

目录

什么是容器?

什么是 IoC?

传统程序的开发

理解 Spring IoC

DI

总结


我们通常所说的 Spring 指的是 Spring Framework(Spring 框架),它是⼀个开源框架,有着活跃⽽庞⼤的社区,这就是它之所以能⻓久不衰的原因。Spring ⽀持⼴泛的应⽤场景,它可以让 Java 企业级的应⽤程序开发起来更简单。
⽤⼀句话概括 Spring:Spring 是包含了众多⼯具⽅法的 IoC 容器。


我们的重点先放在 IoC 容器上,理解它是一个什么东西。

那问题来了,什么是容器?什么是 IoC 容器?接下来我们⼀起来看 

什么是容器?

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

我们想想,之前课程我们接触的容器有哪些?
        List/Map -> 数据存储容器
        Tomcat -> Web 容器
        List / Map 是一个数据存储容器,这个很好理解。
但是 Tomcat 为什么是一个 Web 容器呢?
思考一下:
Tomcat 是用来运行 外部的项目,因此它是一个 Web 容器。
你有一个项目,想要运行。
肯定是要将项目部署到 Tomcat 的 webapps 目录底下,才可以运行。
此时,webapps 不就是一个项目的容器嘛!
而 webapps 目录,不就是 Tomcat 下面的一个子目录嘛。
那么,我们将 Tomcat 称为是一个容器,没有任何问题! 

什么是 IoC?

Spring 是⼀个 IoC 容器。

什么是 IoC?

IoC = Inversion of Control 翻译成中⽂是 “控制反转” 的意思。
也就是说 Spring 是⼀个 “控制反转” 的容器。
首先,明确一点:控制反转,是两个词 >> 控制 和 反转。
所谓的控制反转,指的是:之前程序的控制权是在自己手上,现在,我们把这个控制权交出去了。

一般情况下,我们在 A 类 中,想去调用 B 类中的方法,是怎么做的?
是不是 先要去new B 类对象,通过 对象 去调用 B类中的方法。
这时 B 的控制权,是我们手上的。
而 控制反转,就是将我们手上的权限,交由 “其他人” 来操作这个类。
这个“其他人”,就是 Spring 框架。
此时,我们想要 A 类中调用 B 的时候, 告诉 框架,我要在 A 中 调用 B 了。
至于 B 的生命周期,和我们没有任何关系。
这是控制反转。

前面说过: Spring 是一个 控制反转 的 容器。
也就是 像之前在传统开发的时候,所有需要我们自己去new东西,都不需要我们再去new 了。
因为我们把控制权 “反转给了” Spring 框架。
Spring 会帮我们管理所有的对象(Bean)

在 Spring 中,我们管 对象,叫做 Bean。

当我们想要在一个类中,调用另外一个类,就只需声明一下就可以拿到它了。
这就是一个 IoC 容器的定义.

下面,我们通过举一个例子,来加深 对 IoC 的理解。 

传统程序的开发

假如,我们现在构建⼀辆“车”的程序,我们的实现思路是这样的

public class Test {
    public static void main(String[] args) {
        Car car = new Car();
        car.init();
    }

}

public class Tire {
    private int size = 10;
    public void init(){
        System.out.println("tire="+size);
    }
}

public class Bottom {
    public void init(){
        Tire tire = new Tire();
        tire.init();
    }
}

public class Framework {
    public void init(){
         Bottom bottom = new Bottom();
        bottom.init();
    }
}

public class Car {
    public void init(){
        Framework framework = new Framework();
        framework.init();
    }
}

 

        大家可以发现:一个业务程序,它整个的调用链是非常长的,在实际开发中,这种场景是非常非常 常见的! !可以说:到了 EE 这一块,遇到的每一个业务,都会有这么长的调用链这是因为: 在 EE 中,是需要进行分层的!
1、控制层   2、服务层  3、数据持久层  。。底下是一个数据库。
        所有的接口在执行的时候,所有接口接收到请求,都优先送往控制层,控制层做完数据的正确性校验之后,才会轮到后面 层次进行处理,如果校验没通过,直接向前端返回相应的错误信息。然后呢,控制层校验数据通过之后,就会直接调用 服务层 (service) 进行服务的组装和调用,service 里面会决定 究竟需要调用几个接口来,去操作数据库。简单来说: service 是不操作数据库的! ! !然后,调用到的接口,就会去操作 接口底下 :对应的 数据持久层数据持久层,就是正儿八经的开始操作数据库了
        我们现在所看到的这个案例,就是非常常见的类型几乎所有的接口里面,都会这样去调用! ! ! !如果这样去调用的话,我们右边的这个代码又有什么问题呢?问题就在于,此时的代码是存在耦合性的,右边的代码是一环套一环的只要改动其中一个环节的代码,其他环节的代码都会受到影响! !

        此时,来看右边的代码,这种一旦改动,全部都要改的代码,维护起来,太麻烦!升级一个部分的功能,其它的 也要跟着改。比如: 随着时代推进,人们开始不满一成不变的产品。此时,产品经理,整辆车的构造应该根据用户的需求定制。例如:是要轿车,还是越野,车身想要什么颜色,要种款型的;底盘要多高,轮胎的尺寸要多大,统统都由用户去选择,我们要做的就是:根据用户的输入进行拼装,把最终结果呈现给用户就行了。

现在,我们以 改变轮胎的尺寸为例。

既然是根据用户的需求,来设置轮胎的大小那么,肯定是需要传输一个参数的。

import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int size = scanner.nextInt();
        Car car = new Car();
        car.init(size);
    }
}

public class Car {
    public void init(int size){
        Framework framework = new Framework();
        framework.init(size);
    }
}

public class Framework {
    public void init(int size){
         Bottom bottom = new Bottom();
        bottom.init(size);
    }
}
public class Bottom {
    public void init(int size){
        Tire tire = new Tire();
        tire.init(size);
    }
}
public class Tire {
    public void init(int size){
        System.out.println("tire="+size);
    }
}

此时,大家可以想象,只是添加一个功能,全部程序都要修改。如果 产品经理,不是一次性的说,而是分几次说呢? 结果显然易知,整个代码都在不停的进行整改。

这就是 耦合性强的代码 所带来的 缺陷:动一点代码,整体的代码都需要改

上述代码还只是最简单的一种。那么,如何让代码之间进行解耦合,让 代码之间的影响降为零?
答案: 控制反转
        将 关于的对象创建 的权限 交给 “别人 (Spring)我们不再去关注 什么时候去 new 对象,也不需要关注 调用方法 能不能接收多个参数直接告诉 loC 容器,我们需要使用这个类,然后,容器把这类给你,我们直接使用就可以了。调用方法,传参即可。
        此时,我们只需要将原来由自己创建的下级类,改为传递的方式,也就是注入的方式,因为我们不需要在当前类中创建下级类了,所以下级类即使发生变化(创建或减少参数)当前类本身也无需修改任何代码,这样就完成了程序的解耦。PS: 解耦指的是解决了代码的耦合性,耦合性也可以换一种叫法叫程序相关性。好的程序代码的耦合性是很低的,也就是代码之间要实现解耦

 

public class Test {
    public static void main(String[] args) {
        Tire tire = new Tire(20);
        Bottom bottom = new Bottom(tire);
        Framework framework = new Framework(bottom);
        Car car = new Car(framework);
        car.init();
    }
}

public class Car {
    private Framework framework; 
    public void Car(Framework framework){
       this.framework = framework;
    }
    public void init(){
        framework.init();
    } 
}

public class Framework {
    private Bottom bottom;
    public Framework( Bottom bottom){
        this.bottom = bottom;
    }
    public void init(){
        bottom.init();
    }
}
public class Bottom {
    private  Tire tire;
    public Bottom( Tire tire ){
        this.tire=tire;
    }
    public void init(){
        tire.init();
    }
}
public class Tire {
    int size;
    public  Tire( int size){
        this.size=size;
    }
    public void init(){
        System.out.println("tire="+size);
    }
}

上诉的这种 解耦操作,就是运用 IoC 思想。
将 创建类的对象,以及传参的权限,交由“其它人”,自己不再插手其中。
只是在使用的时候,告诉 容器 需要使用某某对象,然后容器就把对应的对象给我们。
最后,我们拿着对象直接使用即可。
至于 对象什么时候创建,几个参数?都不需要我们去操心。
修改起来,也非常简单!
你改了哪个类,你就只针对那个类进行修改就行了。
其它程序,不会受到任何影响!!! 

总结

由此,不难得出结论。
IoC 的优点:
1、实现代码的解耦合,使用代码之间互不影响。
2、对象(Bean)的生命周期,交给 IoC 框架来维护,作为程序员无需再关注了。

举个例子:下馆子 VS 在家自己DIY
        如果我们自己在家做一道菜,我们需要买菜,洗菜,jian菜;另外,我们还需要准备柴米油盐;最后,还要进行一些列的操作,才能做出一道菜。

        但如果是下馆子,你只需要跟老板说 想吃什么。然后,我们就什么都不用管了!等着老板端上来就行了! 菜上来了,直接吃就行了。

这不就是 IoC 思维,将 做饭的权限 交给 其他人 来负责。
我们不需要再去关注过程,直接享用结果即可!

理解 Spring IoC

回到我们的主题:
Spring 是包含了多个⼯具⽅法的 IoC 容器,这就是对 Spring 最核⼼的总结。
集成多个⼯具⽅法”这事咱们以后慢慢再讲.
既然理解了 容器 与 IoC 的意义。
那如何理解“Spring 是⼀个 IoC容器”这句话呢?

我们可以直接认为 Spring 就是一个 IoC 容器。
既然它是一个容器,那么,容器主要的两个核心功能,肯定是具有的!
1、装东西:那些被 控制反转 的对象(Bean),都可以存储在 Spring 中。

2、取东西:将 对象(Bean),从 Spring 中 取出来。

这也是 Spring IoC 容器 最核心的两个功能【存 和 取 】。

对于我们程序员来说,操作 Spring,最最核心的两件事,就是 存 和 取。
初级目标
存:将 Bean(反转的对象),存入 Spring 中。
取:从 Spring 中,取出 Bean(对象)
高级目标
将 Bean(对象)的存取过程,简化,
让其易用性更强!
学习 Spring,就是学习 如何更简单的 进行 存取 操作。

DI

在 讲完了 IoC 的定义之后,我们不得不提一下 Spring 的 另一个定义:DI。
这么说吧:谈到IoC,Spring 是绝对不能少的!而谈到 Spring,DI 是必不可少的!

DI: dependency Injection(依赖注入)

dependency,这个词,相信大家并不陌生!
就是我们 在 pom.xml 中 引入依赖的时候,需要用到的标签。

 dependency Injection(依赖注入)

依赖:
在执行 B 的时候,需要用到 A 类,不然 B 类 无法往下继续执行。

此时,就可以认为 B 类 是 依赖于 A 类的。

注入 :
就是将一个东西 拿过来用,就是注入。
合起来,DI 的意思,就是 引入的依赖,直接拿过来用。

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

 IoC 和 DI,在广义角度上,都是一回事!

这个时候,就会有一个问题,并且,还是一个非常经典的面试题!

IoC 是一种思想,而 DI 是一种实现。

假设,我们有一天心情非常好!决定下班之后,吃顿好的。这就是一种思想.
但是!我们有说要吃什么吗?很明显是没有的!IoC,就是这样的。
我把权限交由 Spring,当我需要使用某个对象的时候,直接向它要。
这对象怎么给我的,我不管!我只关注:是否能拿到这个对象。

而 DI 就是一个具体实现:我准备下班去吃海底捞。
此时,吃什么,是不是就明确落实了!吃海底捞,就是具体的实现。
DI 关注于 怎么将 依赖 注入 对应的对象里面。

IoC 和 DI 之间的关系,就好比多线程进阶中的 乐观锁 和 CAS 之间的关系。
乐观锁:认为进行加锁操作之后,没有那么容易就会发生锁冲突。【思想】
CAS:compare and swap(比较 与 交换)【具体实现】

总结

1、Spring 是什么?如何理解 Spring?

Spring 是一个包含 众多工具方法 的 IoC 容器。
既然 Spring 是一个 IoC 容器(反转控制容器)。
Spring是 存储 IoC【反转控制(后的对象)】 的一个容器。

2、IoC 和 DI 是什么?有什么区别?

IoC - Inversion Of Control(控制反转)
主要是将 对象的权限(创建与销毁)交由 Spring 来管理。
程序员 不必再去 new 对象了!
在使用到某个对象的时候,直接向 Spring 索取,直接使用即可。

DI - dependency injection(依赖注入)
将 引入的依赖 (执行所依赖的对象),拿过来使用。

区别:
IoC 是一种 思想。
DI 是具体的实现。

3、Spring最核心的功能是什么?

既然 Spring 是一个容器,那么,肯定是具有容器的两个核心功能(存 和 取)。
1、将 Bean(反转的对象)存储到 Spring 容器中。
2、将 Bean(反转的对象)从 Spring 容器中取出来。
这也就是 Spring 的 两个核心功能。

评论 5
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值