Spring的开幕式——Spring概述与设计思想

81 篇文章 0 订阅
77 篇文章 0 订阅

前面的话

本篇文章介绍Spring的定义,相比于与Servlet的优势,学习难点,以及Spring基本设计思想,Ioc控制反转,DI等。

??博客主页:的博客主页
??欢迎关注??点赞??收藏留言??
??本文由原创,CSDN首发!
??首发时间:??2022年7月21日
??推荐书籍:??《Spring实战》
??参考在线编程网站:??牛客网??力扣
博主的码云gitee,平常博主写的程序代码都在里面。
博主的github,平常博主写的程序代码都在里面。
??作者水平很有限,如果发现错误,一定要及时告知作者哦!感谢感谢!


??导航小助手??


封面区


1.Spring系列框架概述

1.1什么是Spring框架

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

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

1.2为什么要学习框架?

因为学习框架相当于从“作坊”到“”的升级,作坊什么都要做,是组件式装配,特点就 是效。 框架更加易、简单且效。

使 Spring Boot 项演示框架相于 Servlet 所具备的以下优点:

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

或者说使用Servlet相比于Spring Boot有以下的不足:

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

1.3Spring框架学习的难点

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

Spring框架基本学习路线:Spring->Spring Boot->Spring MVC->MyBatis等

2.Spring框架设计思想

2.1Spring框架的概念

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

2.2容器是什么?

容器是用来容纳某种物品的(基本)装置。 就比如Map与Set属于数据储存的容器,Tomcat属于Web容器,同理Spring是一个Ioc容器,它包含了许多的工具和方法。

2.3Ioc是什么?

Ioc即IoC = Inversion of Control,直译过来就是控制反转的意思,这是一个比较抽象的概念,我们来通过一个例子来了解它。

我们都知道汽车,它包含轮胎,底座,车身等,我们造一辆汽车时,需要有车身,而车身需要有轮胎,最原始的想法就是造车时,需要车身,于是就new一个车身,而车身需要底座,于是就new一个底座,同理底座需要轮胎,那就造底座前new一个轮胎。
1

我们不难得到以下代码:

public class NewCarExample {
    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);
        }
    }
}

但是,我们的产品不是一成不变的,产品经理提出一个需求,说这个轮胎大小希望可以个性化,在产品经理眼里,这个问题的解决方案只是改一个参数而已,但是根据我们上面写的代码,我们需要往轮胎Tire类的构造方法加上一个参数,由于底盘Bottom类控制着Tire类,那么底盘类的构造方法也需要加上一个参数,以此类推,我们的车身Framework类与汽车Car类都需要为构造方法加上参数,于是我们得到了如下的代码:

public class NewCarUpdateExample {
    public static void main(String[] args) {
        Car car = new Car(20);
        car.run();
    }
    /**
     * 汽?对象
     */
    static class Car {
        private Framework framework;
        public Car(int size) {
            framework = new Framework(size);
        }
        public void run() {
            // 依赖?身
            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);
        }
    }
}

这样,如果需要个性化定制轮胎的大小,就可以只改动构造Car对象传入的参数就可以了。但是,如果产品经理又加上一个需求,说要定制轮胎的颜色,那我们又要加参数,加参数就意味着代码都得改,这样的代码耦合性太高了,为了解决这个问题,我们可以依据loc的思想,我们将控制权交出去,换句话说,需要轮胎Tire类时,你给我传一个Tire对象,我不去new一个Tire对象了,这样的话,就算在Tire类加参数也只需要改动Tire类的构造方法与相关执行方法与属性,顶多再改一下Tire对象的创建,同理其他类也一样,将对象作为参数传入到上级类的构造方法中去就行了,这个过程也叫做传入或注入
loc
由于我们创建Car时需要Framework,所以先要实例一个Framework对象,同理实例一个Framework对象需要Bottom对象,那么需先实例一个Bottom对象,一样,在实例Bottom对象之前需要实例一个Tire对象,于是需要先后创建Tire对象,Bottom对象,Framework对象后才能创建一个Car对象,我们可以得到如下的代码:

public class IocCarExample {
    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.run();
    }

    static class Car {
        private Framework framework;
        public Car(Framework framework) {
            this.framework = framework;
        }
        public void run() {
            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;
        public Tire(int size) {
            this.size = size;
        }
        public void init() {
            System.out.println("轮胎:" + size);
        }
    }
}

所以如果产品经理更改了需求,需要加参数或减少参数,Ioc的代码只需改动图中的两处代码即可,达到了解耦的目的。
3

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

所以Ioc有以下的优点:对象(Bean)的生命周期交给Ioc框架维护,作为程序员无需关注,说白点就是程序员不需要关注对象创建和销毁时机,这些工作加个Ioc框架(也就是Spring)做就行。

2.4Spring 是Ioc容器

我们知道Spring框架包含了多个工具方法放入Ioc容器,既然是容器,那它就有存于取的功能,这也是Spring最核心的功能:

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

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

2.5DI(依赖注入)

DI,即Dependency Injection,依赖注入。在pom.xml有一个依赖项,用来导入外部的资源,而这里的依赖注入,导入的不是外部的资源,而是对象。

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

Ioc与DI的区别是什么?

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


下期预告:spring 项目创建

觉得文章写得不错的老铁们,点赞评论关注走一波!谢谢啦!

1-99

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值