Spring框架概述及核心设计思想

这篇具有很好参考价值的文章主要介绍了Spring框架概述及核心设计思想。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

一. Spring框架概述

1. 什么是Spring框架

我们通常所说的 Spring 指的是 Spring Framework(Spring 框架),它是⼀个开源框架,有着活跃而庞大的社区,这就是它之所以能长久不衰的原因;Spring 支持广泛的应用场景,它可以让 Java 企业级的应用程序开发起来更简单。

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

2. 为什么要学习框架?

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

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

Servlet有以下痛点:

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

而 Spring Boot 相比于 Servlet 具备以下优点:

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

3. Spring框架学习的难点

  1. 配置比较多。
  2. 需要⼤量的外部 jar 包,在下载时容易出错。
  3. 会涉及简单的软件⼯程的设计思想(分层思想:前后端的分层思想;后端工程的分层思想)。
  4. 知识点相对来说比之前的知识更加的分散,要仔细听才能搞懂各个知识点的逻辑关系。
  5. 要记的东西很多,所以要大量地重复练习才能记住,比如各种注解。

Spring框架基本学习应用路线:Spring全家桶(Spring/Spring Boot/Spring MVC) -> MyBatis -> Redis 等。

二. Spring核心设计思想

Spring 核心就是这么一句话:Spring 框架是包含了众多工具方法的 IoC 容器。

那么这句话怎么理解呢?什么是容器?什么又是 IoC?

1. 容器是什么?

容器是用来容纳某种物品的(基本)装置。 ——来⾃:百度百科

Java 中也有一些容器,比如 List,Map,Set 等这些集合,是属于数据储存的容器,它把我们常用的操作都封装到集合中了,我们只需要知道集合为我们提供的方法就可以使用各种集合了;还有 Tomcat 是属于 Web 容器,同理 Spring 是就一个 IoC 容器,它包含了许多的工具和方法。

2. IoC是什么?

IoC 即 Inversion of Control,直译过来就是控制反转的意思,这是一种思想,控制权反转,在 Java 的常规代码中,对象的生命周期,是由当前代码(程序员自己)控制的,而控制权反转就是对象的生命周期,不再由当前代码片段来控制,而是由 Spring(IoC 容器)来控制 。

这种思想还比较抽象,我们来通过一个例子来了解它。

我们都知道汽车,它包含轮胎,底座,车身等,现在我们要造一辆汽车时,需要有车身,而车身需要有底座和轮胎,最传统的思想就是造车时,需要车身,于是就new一个车身,而车身需要底座,于是就再new一个底座,同理底座需要轮胎,那就造底座前new一个轮胎。
Spring框架概述及核心设计思想,JavaEE,spring,java,后端,IoC,DI

我们可以得到以下代码:

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 = 17; // 轮胎的尺寸
    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();
    }
}

但是,但上面的代码中,轮胎的大小是固定写死的, 然而随着对的车的需求量越来越大,个性化需求也会越来越多,这 时候我们就需要加⼯多种尺寸的轮胎,那这个时候就要对上面的程序进行修改了,根据我们上面写的代码,我们需要往轮胎Tire类的构造方法加上一个参数,由于底盘Bottom类控制着Tire类,那么底盘类的构造方法也需要加上一个参数,以此类推,我们的车身Framework类与汽车Car类都需要为构造方法加上参数,于是我们得到了如下的代码:

package old;

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

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

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

package old;

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

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

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

package old;

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

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

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

package old;

// 轮胎类
public class Tire {
    private int size = 17; // 轮胎的尺寸

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

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

package old;

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

此时,如果需要个性化定制轮胎的大小,就可以只改动构造Car对象传入的参数就可以了;但是,如果再加上加上一个需求,还要定制轮胎的颜色,那我们又要加参数,此时就意味着像上面一样修改最底层的代码, 整个调⽤链上的所有代码都需要修改。

这样的代码耦合性就太高了,为了解决这个问题,我们可以使用loC的思想来实现代码,将控制权交出去,也就是说,IoC模式下,我们不再自己构造创建对象,当我们需要轮胎Tire类时,你就给我传一个Tire对象,我们不去new一个Tire对象了,这样的话,就算在Tire类加参数也只需要改动Tire类的构造方法与相关执行方法与属性,顶多再改一下Tire对象的创建,同理其他类也一样,将对象作为参数传入到上级类的构造方法中去就行了,但此时其他类是不需要修改的,这个过程也叫做传入或注入
Spring框架概述及核心设计思想,JavaEE,spring,java,后端,IoC,DI
由于我们创建Car时需要Framework,所以先要实例一个Framework对象,同理实例一个Framework对象需要Bottom对象,那么需先实例一个Bottom对象,一样,在实例Bottom对象之前需要实例一个Tire对象,于是需要先后创建Tire对象,Bottom对象,Framework对象后才能创建一个Car对象,我们可以得到如下的代码:

package ioc;

public class Car {
    // 汽车的组建依赖于车身的组建
    private Framework franmework;

    public Car(Framework franmework) {
        this.franmework = franmework;
    }
    public void init() {
        System.out.println("do car...");
        franmework.init();
    }
}

package ioc;

public class Framework {
    // 车身的组建依赖于底盘
    private Bottom bottom;

    public Framework(Bottom bottom) {
        this.bottom = bottom;
    }
    public void init() {
        System.out.println("do franmework");
        bottom.init();
    }
}

package ioc;

public class Bottom {
    // 底盘的组建依赖于轮胎
    private Tire tire;

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

    public void init() {
        System.out.println("do bottom...");
        tire.init();
    }
}

package ioc;

public class Tire {
    private int size = 17;
    private String color = "黑色";

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

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

package ioc;

public class IOCDemo {
    // 这里的内容包含就相当于是 IoC 容器做的事情
    // 对象的生命周期控制权就翻转给 IoC 容器了, 不再由程序员控制
    private Tire tire;
    private Bottom bottom;
    private Framework framework;
    public Car car;
    public IOCDemo() {
        tire = new Tire(17, "红色");
        bottom = new Bottom(tire);
        framework = new Framework(bottom);
        car = new Car(framework);
    }
}

package ioc;

/**
 * 模拟 IoC 容器
 */
public class Test {
    public static void main(String[] args) {
        // 直接使用, 创建就交给IoC了
        IOCDemo ioc = new IOCDemo();
        Car car = ioc.car;
        car.init();
    }
}

此时如果要变需求,需要加参数或减少参数,IoC 的代码只需改动图中的两处代码即可, 整个调用链是不用做任何改变的, 达到了解耦的目的。

Spring框架概述及核心设计思想,JavaEE,spring,java,后端,IoC,DI
Spring框架概述及核心设计思想,JavaEE,spring,java,后端,IoC,DI

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

到这里我们就可以发现,传统的代码类创建顺序是反着的,Car 控制 FrameWork,FrameWork 控制着 Bottom,Bottom 控制着 Tire;而改进之后的控制权发生了反转,是下层将对象注入到当前对象当中,下级的控制权不再由上级控制了,下级在发生改变时会将改变完成后的对象注入上级,这样上级就是不受影响的,这就是 IoC 的实现思想。

所以 IoC 有以下的优点:对象(Bean)的生命周期交给 IoC 框架维护,作为程序员无需关注,说白了就是程序员不需要关注对象创建、销毁时机以及对象的依赖关系,这些工作加个 IoC 框架(也就是 Spring)做就行,实现了代码的解耦,对象的使用更加方便高效。

3. Spring是IoC容器

Spring 框架就是包含了多个工具方法的 IoC 容器,既然是容器,那它就有存和取的功能,这也是 Spring 最核心的两个功能:

  1. 将 Bean(对象)存储到 Spring 容器中。
  2. 将 Bean(对象)从 Spring 容器中取出来。

将对象存放到容器有什么好处呢?
将对象存储到 IoC 容器相当于我们将所有可能用到的工具制作好都放到仓库,当我们需要使用时直接取即可,用完归还仓库;而 new 对象的方式相当于我们每次需要用工具的时候现场制作,制作完了扔掉,下次需要的时候重新做。

Spring 是⼀个 IoC 容器,说的是对象的创建和销毁的权利都交给 Spring 来管理了,它本身⼜具备了存储对象和获取对象的能力。

4. DI(依赖注入)

DI,即Dependency Injection,依赖注入。

所谓依赖注⼊,就是由 IoC 容器在运行期间,动态地将某种依赖关系注入到对象之中,在pom.xml有一个依赖项,就是用来导入外部的资源,而这里的依赖注入,导入的不是外部的资源,而是对象;当某个 Java 实例需要另一个 Java 实例时,创建被调用者的工作不是由调用者实现,而是由 Spring 容器来完成,然后注入调用者,因此称为依赖注入。

IoC 与 DI 的区别是什么?

依赖注入(DI)和控制反转(IoC)是从不同的角度的描述的同⼀件事情,就是指通过引入 IoC 容器,利用依赖关系注入的方式,实现对象之间的解耦。

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

5. DL(依赖查找)

DL,即Dependency Lookup,依赖查找,也是 IoC的一种实现。

依赖查找和依赖注入的区别在于,依赖注入是将依赖关系委托给容器,由容器来管理对象之间的依赖关系,容器外部是不关心这种依赖关系的,需要时由容器判断提供什么;而依赖查找是由对象自己来查找它所依赖的对象,容器只负责管理对象的生命周期,也就是说此时需要容器外部自己确定要容器提供哪种依赖关系;两者之间是主动和被动的区别。文章来源地址https://www.toymoban.com/news/detail-569661.html

到了这里,关于Spring框架概述及核心设计思想的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

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

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

相关文章

  • Spring核心设计思想

    目录 前言: Spring是什么 什么是IoC 传统开发思想 IoC开发思想 Spring IoC 什么是DI 小结:     官网中提出:Spring makes programming Java quicker, easier, and safer for everybody. Spring’s focus on speed, simplicity, and productivity has made it the world\\\'s most popular Java framework.     Spring 使编程 Java 对每个人来

    2023年04月17日
    浏览(41)
  • Spring 核心与设计思想

    ✏️作者:银河罐头 📋系列专栏:JavaEE 🌲 “种一棵树最好的时间是十年前,其次是现在” 通常所说的 Spring 指的是 Spring Framework(Spring 框架)。 Spring 是包含多种工具方法的 IoC 容器。 IoC(Inversion of Control): 控制反转 \\\"控制反转\\\"又是什么意思? 下面以一个程序来举例。 假如我

    2024年02月02日
    浏览(55)
  • 【Spring】核心与设计思想

     哈喽,哈喽,大家好~ 我是你们的老朋友: 保护小周ღ   谈起Java 圈子里的框架,最年长最耀眼的莫过于 Spring 框架啦,如今已成为最流行、最广泛使用的Java开发框架之一。不知道大家有没有在使用 Spring 框架的时候思考过这些问题, 什么是框架?Spring 是什么?如何理解

    2024年02月08日
    浏览(42)
  • 【Spring】(一)Spring设计核心思想

    Spring 是一个开源的轻量级 Java 框架,旨在简化 Java 应用程序的开发。它提供了一个全面的编程和配置模型,用于构建各种类型的应用,包括企业级应用和独立的 Java 应用。 Spring 的设计理念是基于依赖注入(Dependency Injection)和面向切面编程(Aspect-Oriented Programming),使得应

    2024年02月14日
    浏览(42)
  • 【Spring】学习Spring需要掌握的核心设计思想

    目录 一、Spring是什么 二、什么是IoC容器 1、什么是容器 2、什么是IoC   3、Spring IoC 4、DI(依赖注入) 4.1、IoC和DI的区别 5、 DL(依赖查找) 我们通常所说的Spring指的是Spring Framework(Framework的意思就是框架),它是一个开源的框架,有着庞大的社区,这就是它之所以能长久不

    2024年02月14日
    浏览(58)
  • 【Spring】Spring有什么用?Spring核心与设计思想之IOC与DI

     Spring是一个开源的、轻量级的、面向企业级的Java应用框架。它提供了一种基于依赖注入和面向切面编程的方式,帮助开发者构建高效、可扩展的应用程序。  具体来说, Spring可以看作一个包含众多工具方法的IOC容器。 Spring的出现是为了让开发更简单~ 那么问题就很明确了

    2024年02月10日
    浏览(44)
  • 【开源与项目实战:开源实战】84 | 开源实战四(上):剖析Spring框架中蕴含的经典设计思想或原则

    在 Java 世界里,Spring 框架已经几乎成为项目开发的必备框架。作为如此优秀和受欢迎的开源项目,它是我们源码阅读的首选材料之一,不管是设计思想,还是代码实现,都有很多值得我们学习的地方。接下来,我们就详细讲讲 Spring 框架中蕴含的设计思想、原则和模式。因为

    2024年02月12日
    浏览(43)
  • 敏捷设计的的4个核心思想

    来自《互联网产品之美》。 4个核心思想 1、强调面对面的沟通,也就是说沟通很重要,任何人的相互交流胜于任何流程和工具; 2、要把精力集中在可执行的程序上,可以运行的产品胜于综合性文档,也就是强调了原型、模型、演示等的重要性; 3、团队合作和团队激励,合

    2024年02月09日
    浏览(48)
  • 一文带你了解QT Model/View框架的设计思想和实现机制

    目录 1、QT Model/View框架简介 1.1、QT Model/View是什么? 1.2、QT Model/View框架核心思想 1.3、Model/View框架工作机制 1.4、Model/View框架的类 2、Model 2.1模型简介 2.2、模型索引 2.3、数据角色 2.4、QStringListModel 2.5、QFileSystemModel 2.6、QSortFilterProxyModel 3、View 4、Delegate 5、项选择模型 5.1、QIt

    2024年02月05日
    浏览(89)
  • 二十四种设计模式与六大设计原则(三):【装饰模式、迭代器模式、组合模式、观察者模式、责任链模式、访问者模式】的定义、举例说明、核心思想、适用场景和优缺点

    接上次博客:二十四种设计模式与六大设计原则(二):【门面模式、适配器模式、模板方法模式、建造者模式、桥梁模式、命令模式】的定义、举例说明、核心思想、适用场景和优缺点-CSDN博客 目录 装饰模式【Decorator Pattern】 定义 举例说明 核心思想 适用场景 优缺点 迭代

    2024年04月17日
    浏览(56)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包