• 初识 - Spring


    1. Spring 是什么

    我们通常所说的 Spring 指的是 Spring Framework(Spring 框架),它是个开源框架,句话概括 Spring:Spring 是包含了众多?具?法的 IoC 容器.

    1.1 什么是容器

    就跟据字面来理解,装水的瓶子可以叫容器,可以装衣服的衣柜可以叫容器,总之,可以用来容纳某种物品(基本)装置我们都可以叫容器

    向我们之前所学过的知识:

    List/Map => 数据存储容器
    Tomcat => Web 容器
    Spring -> IoC 容器

    1.2 什么是 IoC

    IoC => Inversion of Control 翻译成中是 “控制反转” 的意思,也就是说 Spring 是个“控制反转”的容器,是 Spring 的核心,贯穿始终.这个 IOC ,对于 Spring框架来说,就是由 Spring 来负责控制对象的生命周期和对象间的关系.把所有类放在 Spring容器里,所有类的创建和销毁都由Spring来控制,而不再由引用他的对象来控制,这就是控制反转.

    1.2.1 传统程序开发

    接下来,我们具体来看一下实现过程,假如,我们要构建一辆"车"的程序,我们的思想是这样的:
    在这里插入图片描述
    构建一辆车(Car Class),车需要依赖于车身(FrameWork Class),车身需要依赖底盘(Bottom Class),而底盘要依赖轮胎(Tire Class),我们最终实现的程序如下:

    public class NewCar {
        public static void main(String[] args) {
            Car car = new Car();
            car.init();
        }
    
        /**
         * 汽车对象
         */
        static class Car {
            public void init() {
                //依赖车身
                Framework framework = new Framework();
                framework.init();
            }
        }
    
        /**
         * 车身类
         */
        static class Framework {
            public void init() {
                //依赖底盘
                Bottom bottom = new Bottom();
                bottom.init();
            }
        }
    
        /**
         * 地盘类
         */
        static class Bottom {
            public void init() {
                //依赖轮胎
                Tire tire = new Tire();
                tire.init();
            }
        }
    
        /**
         * 轮胎类
         */
        static class Tire {
            private int size = 30;
            public void init() {
                System.out.println("轮胎尺寸: " + size);
            }
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49

    在这里插入图片描述

    以上程序中,轮胎尺寸都是固定的,然而,随着我们对车的需求越来越大,个性化需求也越来越多,这个时候我们就需要修改轮胎的尺寸,再改代码就显得很麻烦:

    /**
     * 造一个车
     */
    public class NewCar {
        public static void main(String[] args) {
            Car car = new Car(20);
            car.init();
        }
    
        /**
         * 汽车对象
         */
        static class Car {
            private Framework framework;
            public Car(int size){
                framework = new Framework(size);
            }
            public void init() {
                framework.init();
            }
        }
    
        /**
         * 车身类
         */
        static class Framework {
            private Bottom bottom;
            public Framework(int size){
                bottom = new Bottom(size);
            }
            public void init() {
                bottom.init();
            }
        }
    
        /**
         * 地盘类
         */
        static class Bottom {
            private Tire tire;
            public Bottom(int size){
                tire = new Tire(size);
            }
            public void init() {
                tire.init();
            }
        }
    
        /**
         * 轮胎类
         */
        static class Tire {
            private int size;
            public Tire(int size){
                this.size = size;
            }
            public void init() {
                System.out.println("轮胎尺寸: " + size);
            }
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61

    不难看出,当我们底层代码改动之后,整个调用链上的所有代码都需要修改,这是很麻烦的,因为代码耦合度很高

    1.2.2 解决办法

    这时我们就需要解耦,我们把轮胎交给别人做,我们只管提需求别人做好了拿来用就行了,这就是控制反转式程序开发

    /**
     * 造一辆车
     */
    public class NewCar {
        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();
        }
    
        /**
         * 车类
         */
        static class Car{
            private Framework framework;
            public Car(Framework framework){
                this.framework = framework;
            }
            public void init() {
                framework.init();
            }
        }
    
        /**
         * 车身类
         */
        static class Framework{
            private Bottom bottom;
            public Framework(Bottom bottom){
                this.bottom = bottom;
            }
            public void init() {
                bottom.init();
            }
        }
    
        /**
         * 地盘类
         */
        static class Bottom {
            private Tire tire;
            public Bottom(Tire tire) {
                this.tire = tire;
            }
            public void init() {
                tire.init();
            }
        }
    
        /**
         * 轮胎类
         */
        static class Tire{
            private int size ;
            private String color;
            public Tire(int size,String color){
                this.size = size;
                //我还可以加颜色
                this.color = color;
            }
            public void init() {
                System.out.println("轮胎尺寸: " + size+",颜色: "+color);
            }
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67

    在这里插入图片描述

    这样改制后,我们在想去改车的一些属性,就不用调用整个类了,这样就很好的完成了代码之间的解耦,从而实现更加灵活,通用的程序设计了
    在这里插入图片描述
    在这里插入图片描述

    1.2.3 对比总结

    在传统的代码中对象创建顺序是:Car -> Framework -> Bottom -> Tire
    改进之后解耦的代码的对象创建顺序是:Tire -> Bottom -> Framework -> Car

    在这里插入图片描述
    在我们改进之后的控制权发?的反转,不再是上级对象创建并控制下级对象了,是下级对象把注将当前对象中,下级的控制权不再由上级类控制了,这样即使下级类发任何改变,当前类都是不受影响的,这就是典型的控制反转,也就是 IoC 的实现思想

    1.3 什么是 DI

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

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

    IoC 是“标”也是种思想,标和思想只是种指导原则,最终还是要有可的落地案, DI 就属于具体的实现。

    2. 总结

    2.1 Spring 是什么如何理解 Spring

    Spring 是包含了多个具法的 IoC 容器,说的是对象的创建和销毁的权利都交给 Spring 来管理了,它本身具备了存储对象和获取对象的能。也就是 Spring 最核心的功能就是:就是学如何将对象(Bean)存?到 Spring (容器)中,再从 Spring(容器) 中获取对象(Bean)的过程

    将对象存放到容器中的好处:将对象存储在 IoC 容器相当于将以后可能的所有具制作好都放到仓库中,需要的时候直接取就了,完再把它放回到仓库。 new 对象的式相当于,每次需要具了,才现做,完就扔掉了也不会保存,下次再的时候还得重新做,这就是 IoC 容器和普通程序开发的区别

    2.2 IoC 和 DI 是啥有什么区别

    IoC, Inversion of Control, 译为 控制反转. 使用控制反转的思路 ,可以实现依赖类之间的解耦,让我们不必在去关心依赖类的具体实现, 以及生命周期, 我们只需要在使用他的时候, 把他注入进来就行.
    DI, Denpendency Injection, 译为 依赖注入. 是一种 Ioc 具体实现手段, 指的是在 IoC 容器运行的期间, 动态将某种依赖关系注入到对象中.
    区别: IoC 是一种思想, DI 是一种实现(乐观锁(思想) CAS(实现手段))就像是说:我今天要去吃一段好的犒劳自己一下(思想) 跟 我今天要去吃一顿海底捞犒劳一下自己(实现手段)

    2.3 Spring 最核心的功能是啥

    1: 将 Bean(对象) 储到 Spring(容器)中
    2: 将 Bean(对象) 从 Spring(容器)中出来

    先自我介绍一下,小编13年上师交大毕业,曾经在小公司待过,去过华为OPPO等大厂,18年进入阿里,直到现在。深知大多数初中级java工程师,想要升技能,往往是需要自己摸索成长或是报班学习,但对于培训机构动则近万元的学费,着实压力不小。自己不成体系的自学效率很低又漫长,而且容易碰到天花板技术停止不前。因此我收集了一份《java开发全套学习资料》送给大家,初衷也很简单,就是希望帮助到想自学又不知道该从何学起的朋友,同时减轻大家的负担。添加下方名片,即可获取全套学习资料哦

  • 相关阅读:
    突破编程_C++_设计模式(解释器模式)
    MQTT- emqx 安装指南
    确定 k8s 的 Annotation 与 Labels 你用对了?
    国外的跨境物流有什么学习的地方
    项目7-音乐播放器5+注册账号
    【JS】数据结构之栈
    ThingsBoard IoT Gateway MQTT 连接器配置 第二部分
    1. 【力扣】银行账户概要 II
    【高效开发工具系列】Windows 系统下将 Windows 键盘的 ctrl 和 alt 互换
    STL 红黑树源码分析
  • 原文地址:https://blog.csdn.net/m0_54866636/article/details/126080978