为什么学习SpringSpring框架核心与设计思想(IOC与DI)?

  • 博主简介:想进大厂的打工人
  • 博主主页:@xyk:
  • 所属专栏: JavaEE进阶 


目录

文章目录

一、Spring是什么?

二、为什么要学习框架?

三、Spring核心概念

3.1 什么是容器?

3.2 什么是IOC?

四、再谈Spring中的 IOC

五、理解Spring中的 DI


一、Spring是什么?

Spring 框架是一个用于构建企业级 Java 应用程序的开源框架—指的是Spring Framework(Spring 框架)。它提供了一种综合性的编程和配置模型,用于开发灵活、可扩展、可维护的应用程序。Spring 框架提供了许多功能和特性,帮助开发人员快速构建企业应用程序。

具体来说,Spring可以看作一个包含众多工具方法的IOC容器,Spring的出现就是让开发更简单。

那么,什么是IOC?什么又是容器?下面我们来逐渐讲解~

二、为什么要学习框架?

因为学习框架相当于从“小作坊”到“工厂”的升级,小作坊什么都要自己做,工厂是组件式装配,特点就是高效。

框架更加易⽤、简单且高效。

之前我们使用的Servlet有以下缺点:

  1. 添加外部 jar 不⽅便,容易出错,比如添加了⼀个不匹配的外部 jar 版本。
  2. 运行和调试的时候需要配置 Tomcat 不⽅便。
  3. 发布不方便,Servlet 项目必须依靠外置的 Tomcat(外置的 Web 容器)运行。
  4. 路由配置不方便,⼀个访问地址对应⼀个 Servlet 类。

而Spring Boot 对比 Servlet 的优点:

  1. 快速添加外部 jar 包。
  2. 调试项目更方便,无需配置 Tomcat,点击“运行”按钮就可以直接运行项目,因为 Spring Boot 内置了 Tomcat 容器可直接运行。
  3. 发布项目更加方便,无需配置 Tomcat,使用 java -jar xxx.jar 的方式就可以发布。
  4. 对象自动装配。
  5. 添加路由更加方便,无需每个访问地址都添加⼀个类。

Spring框架基本学习应用路线:Spring全家桶 -> MyBatis -> Redis ...等。

三、Spring核心概念

3.1 什么是容器?

通俗来理解,容器就是装某种东西的器件。

在Java开发中,容器通常是指Web容器或IOC容器。Web容器是一种用于运行Web应用程序的容器,例如Tomcat、Jetty等。IoC容器是一种反转控制容器,例如Spring框架的Bean容器,它管理了应用程序中的对象,并负责注入对象之间的依赖关系。

3.2 什么是IOC?

IOC = Inversion of Control 翻译成中⽂是“控制反转”的意思。这是一种思想,在java的常规代码中,我们需要程序猿自己进行 new 对象来控制生命周期,而控制反转就是将对象的生命周期交给Spring来控制,不再根据程序猿来创建对象。

说到这里,有些人可能不理解,下面来举个例子:

假如,我们现在构建⼀辆“汽⻋”的程序,要有车身、底盘、轮胎等
为什么学习SpringSpring框架核心与设计思想(IOC与DI)?_第1张图片   

传统思想的代码实现:

package old;

/**
 * 传统开发方式, 耦合性问题
 */
// 汽车类
public class Car {
    // 车身
    private Framework framework;

    public Car() {
        framework = new Framework();
    }

    public void init() {
        System.out.println("do car");
        // 汽车的组建依赖于车身
        framework.init();
    }
}

package old;

// 车身类
public class Framework {
    private Bottom bottom;

    public Framework() {
        bottom = new Bottom();
    }

    public void init() {
        System.out.println("do framework");
        // 车身的组建依赖于底盘
        bottom.init();
    }
}

package old;

// 底盘类
public class Bottom {
    private Tire tire;

    public Bottom() {
        tire = new Tire();
    }

    public void init() {
        System.out.println("do bottom");
        // 底盘的组建依赖于轮胎
        tire.init();
    }
}

package old;

// 轮胎类
public class Tire {
    private int size = 20;

    public void init() {
        System.out.println("size -> " + size);
    }
}

package old;

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

为什么学习SpringSpring框架核心与设计思想(IOC与DI)?_第2张图片

此时,如果我们需要定制个性化的轮胎,就需要改动Tire类的构造方法,进行传入颜色,大小等。但是问题就来了,一旦修改了最底层的Tire,上面所有互相依赖的类,都需要修改构造方法,进行传参。牵一发而动全身!这就是最大的问题!!

为什么学习SpringSpring框架核心与设计思想(IOC与DI)?_第3张图片

在传统的编程模式中,程序猿则需要手动创建对象,并负责它们之间的依赖关系。 而在IOC的编程模式中,程序员只需要定义好对象及其依赖关系的配置,IOC容器则根据这些配置来自动创建和管理对象。通过 IOC编程思想,我们可以很好的解决上述问题。

那么,使用IOC思想的代码:

尝试不在每个类中⾃⼰创建下级类,我们只需要将原来由⾃⼰创建的下级类,改为传递的⽅式(也就是注⼊的⽅式),所以下级类即使发⽣变化(创建或减少参数),当前类本身也⽆需修改任何代码。

为什么学习SpringSpring框架核心与设计思想(IOC与DI)?_第4张图片

public class Car {
    private Framework framework;

    public Car(Framework framework) {
        this.framework = framework;
    }

    public void init() {
        System.out.println("执行 Car");
        // 依赖车身
        framework.init();
    }
}

public class Framework {
    private Bottom bottom;

    public Framework(Bottom bottom) {
        this.bottom = bottom;
    }

    public void init() {
        System.out.println("执行 Framework");
        // 依赖底盘
        bottom.init();
    }
}


public class Bottom {
    private Tire tire;

    public Bottom(Tire tire) {
        this.tire = tire;
    }

    public void init() {
        System.out.println("执行 Bottom");
        // 依赖轮胎
        tire.init();
    }
}

public class Tire {
    private int size = 20;
    private String color;

    public Tire(int size, String color) {
        this.size = size;
        this.color = color;
    }

    public void init() {
        System.out.println("轮胎——size:" + size +
                " | color:" + color);
    }
}


public class App {
    public static void main(String[] args) {
        Tire tire = new Tire(30, "粉色");
        Bottom bottom = new Bottom(tire);
        Framework framework = new Framework(bottom);
        Car car = new Car(framework);
        car.init();
    }
}

为什么学习SpringSpring框架核心与设计思想(IOC与DI)?_第5张图片

代码经过调整,无论底层如何变化,怎么个性化定制,都不会影响上层,整个调用链都不需要改变,这样就完成了代码之间的解耦合。

同时,我们也能发现一些规律: 改进之后的控制权发⽣的反转,不再是上级对象创建并控制下级对象了,⽽是下级对象把注⼊将当前对象中,下级的控制权不再由上级类控制了, 这样即使下级类发⽣任何改变,当前类都是不受影响的,这就是典型的控制反转,也就是 IOC 的实现思想。

四、再谈Spring中的 IOC

那么如何理解”Spring 是一个IOC容器"这句话呢?

既然 Spring 是⼀个 IoC(控制反转)容器,重点还在“容器”⼆字上,那么它就具备两个最基础的功
能:

  • 将Bean对象存⼊到容器;
  • 从容器中取出Bean对象。
     

也就是说学 Spring 最核⼼的功能,就是学如何将对象存⼊到 Spring 中,再从 Spring 中获取对象的过程。即Spring IOC容器就像一个仓库,需要使用的时候直接取,不使用的时候再放回仓库,而此时,对象的创建和销毁的权利都交给 Spring 来管理了。

五、理解Spring中的 DI

Spring的依赖注入(Dependency Injection,DI)是指在应用程序运行过程中,由Spring容器负责创建和管理对象,并将对象之间的依赖关系注入给它们。简单来说:所谓依赖注入,就是由 IoC 容器 在运行期间,动态地将某种依赖关系注入到对象中。DI 也是 IoC思想实现的一种方式~

⽐如说我今天⼼情⽐较好,吃⼀顿好的犒劳犒劳⾃⼰,那么“吃⼀顿好的”是思想和⽬标(是 IoC),但最后我是吃海底捞还是杨国福?这就是具体的实现,就是 (DI)

在Spring中,对象之间的依赖关系分为两种:构造器注入和属性注入。在构造器注入中,Spring容器会通过构造方法来完成对对象的依赖注入。而在属性注入中,Spring容器则会通过setter方法或者直接设置对象的属性来完成依赖注入。

为什么学习SpringSpring框架核心与设计思想(IOC与DI)?_第6张图片

你可能感兴趣的:(JavaEE进阶,spring,java,后端)