【Spring】——Spring的创建与使用

热爱编程的林兮

已于 2023-06-03 13:11:41 修改

阅读量4.8k

点赞数 149

于 2023-06-03 09:27:01 首次发布

本文链接：https://blog.csdn.net/m0_63951142/article/details/130924074

版权

本文详细介绍了Spring的创建过程，包括通过Maven创建项目、添加Spring框架支持和创建启动类。此外，还讲解了如何存储和获取Bean对象，以及在遇到Maven下载jar包失败时的解决方法。同时，探讨了ApplicationContext与BeanFactory的区别，并展示了getBean方法的不同用法。

摘要由CSDN通过智能技术生成

注意：maven 项目下载 jar 失败的解决方案🍉

多学一招：ApplicationContext与BeanFactory（常见面试题）

Ⅱ、获取指定的 Bean 对象🍓

Ⅲ、使用Bean对象🍓

多学一招：getBean 方法的更多用法🍉

上期我们讲解了Spring是什么及Spring的核心特点，其中重点讲解了控制反转（IoC）和依赖注入（DI），下面我们通过示例代码来去更深刻了解这其中的含义。

一、传统程序开发与控制反转🍭

1、传统程序开发🍉

在传统开发中，如果我们现在想构建⼀辆“⻋”的程序，我们的实现思路是这样的：

构建⼀辆车（Car Class），然而车需要依赖车身(FrameWork Class)，而车身需要依赖底盘（Bottom Class），而底盘需要依赖轮胎（Tire Class），最终程序的实现代码如下

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 {
        public void init() {
            // 尺⼨
            int size = 30;
            System.out.println("轮胎尺⼨：" + size);
        }
    }
}

传统程序开发的缺陷🍓

以上程序中，轮胎的尺寸的固定的，然而随着对的车的需求量越来越大，个性化需求也会越来越多，这时候我们就需要加工多种尺寸的轮胎，那这个时候就要对上面的程序进行修改了，修改后的代码如下所示：

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

从以上代码可以看出，以上程序的问题是：当最底层代码改动之后，整个调用链上的所有代码都需要修改。

解决传统开发中的缺陷🍓

如何解决上述问题呢？

我们可以尝试不在每个类中自己创建下级类，如果自己创建下级类就会出现当下级类发生改变操作，自己也要跟着修改。

此时，我们只需要将原来由自己创建的下级类，改为传递的方式（也就是注入的方式），因为我们不需要在当前类中创建下级类了，所以下级类即使发生变化（创建或减少参数），当前类本身也无需修改任何代码，这样就完成了程序的解耦。

PS：解耦指的是解决了代码的耦合性，耦合性也可以换⼀种叫法叫程序相关性。好的程序代码的耦合性（代码之间的相关性）是很低的，也就是代码之间要实现解耦。

这就好比我们打造⼀辆完整的汽车，如果所有的配件都是自己造，那么当客户需求发生改变的时候，比如轮胎的尺寸不再是原来的尺寸了，那我们要自己动手来改了，但如果我们是把轮胎外包出去，那么即使是轮胎的尺寸发生改变了，我们只需要向代理工厂下订单就行了，我们自身是不需要出力的。

2、控制反转思维程序开发🍉

基于以上思路，我们把调用汽车的程序示例改造⼀下，把创建子类的方式，改为注入传递的方式，具体实现代码如下：

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

代码经过以上调整，无论底层类如何变化，整个调用链是不用做任何改