Java EE --- spring 核心与设计思想

最新推荐文章于 2023-11-21 12:41:23 发布

梦の澜

最新推荐文章于 2023-11-21 12:41:23 发布

阅读量237

点赞数

分类专栏： JavaEE 文章标签： spring java-ee java

本文链接：https://blog.csdn.net/baiyang2001/article/details/125593416

版权

JavaEE 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

文章目录：

1、spring 是什么

Spring 指的是 Spring Framework（Spring 框架）它是⼀个开源框架
用一句话概括：Spring 是包含了众多工具方法的 IoC 容器

1.1、什么是容器

容器是容纳某种物品的基本装置：
List / Map ——> 数据存储容器 Tomcat ——> web 容器(运行 web 程序)

1.2、IoC 是什么

IoC，Inversion of Control，即 “控制反转”（原控制权在你，现在把控制权交出去）。控制的是一个一个类, 反转就是类的生命周期不由程序员来控制了, 而是交给这个 IoC 容器来控制.

1.2.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);
       }
   }
}

这样的代码中，车里有需要 new 框架，框架里 new 底盘，底盘里 new 轮胎，所以这个代码耦合性非常强，如果后期需要改动需求（需要根据用户的需求来设计轮胎的大小），这时候 size 就不能是固定的 50 了，需要把 size 属性放置在 Tire 类的 init 方法中

static class Tire {
            // 尺⼨
        public void init(int size) {
            System.out.println("轮胎尺⼨：" + size);
       }
   }

Tire 的控制权在 Bottom ，所以这里 init 方法的变化，会导致 Bottom 里面的 new Tire() 发生变化，会一直层层向上变化………………后期可能会有更多的需求变化，所以每次修改最底层的类会影响整个调用链变化，虽然可以实现但是成本比较大

static class Bottom {
        public void init(int size) {
            // 依赖轮胎
            Tire tire = new Tire(size);
            tire.init();
       }
   }

所以这里需要进行解耦合，这里就是把控制权交出去了，当一个 bottom 类需要一个 Tire 类时，直接向去要即可，不需要关心其生命周期，这样底层的类再怎么变化都不会影响到整个调用链

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);
       }
   }
}