Spring 核心与设计思想

1. Spring 是什么?

我们通常所说的 Spring 指的是 Spring Framework(Spring 框架),它是⼀个开源框架,⽤⼀句话概括 Spring:Spring 是包含了众多⼯具⽅法的 IoC 容器.

1.1 什么是容器?

就跟据字面来理解,装水的瓶子可以叫容器,可以装衣服的衣柜可以叫容器,总之,可以用来容纳某种物品(基本)装置我们都可以叫容器

向我们之前所学过的知识:

1.2 什么是 IoC?

IoC => Inversion of Control 翻译成中⽂是 “控制反转” 的意思,也就是说 Spring 是⼀个“控制反转”的容器,是 Spring 的核心,贯穿始终.这个 IOC ,对于 Spring框架来说,就是由 Spring 来负责控制对象的生命周期和对象间的关系.把所有类放在 Spring容器里,所有类的创建和销毁都由Spring来控制,而不再由引用他的对象来控制,这就是控制反转.

1.2.1 传统程序开发

接下来,我们具体来看一下实现过程,假如,我们要构建一辆”车”的程序,我们的思想是这样的:
在这里插入图片描述
构建一辆车(Car Class),车需要依赖于车身(FrameWork Class),车身需要依赖底盘(Bottom Class),而底盘要依赖轮胎(Tire Class),我们最终实现的程序如下:

  1. public class NewCar {
  2. public static void main(String[] args) {
  3. Car car = new Car();
  4. car.init();
  5. }
  6. /**
  7. * 汽车对象
  8. */
  9. static class Car {
  10. public void init() {
  11. //依赖车身
  12. Framework framework = new Framework();
  13. framework.init();
  14. }
  15. }
  16. /**
  17. * 车身类
  18. */
  19. static class Framework {
  20. public void init() {
  21. //依赖底盘
  22. Bottom bottom = new Bottom();
  23. bottom.init();
  24. }
  25. }
  26. /**
  27. * 地盘类
  28. */
  29. static class Bottom {
  30. public void init() {
  31. //依赖轮胎
  32. Tire tire = new Tire();
  33. tire.init();
  34. }
  35. }
  36. /**
  37. * 轮胎类
  38. */
  39. static class Tire {
  40. private int size = 30;
  41. public void init() {
  42. System.out.println("轮胎尺寸: " + size);
  43. }
  44. }
  45. }

在这里插入图片描述

以上程序中,轮胎尺寸都是固定的,然而,随着我们对车的需求越来越大,个性化需求也越来越多,这个时候我们就需要修改轮胎的尺寸,再改代码就显得很麻烦:

  1. /**
  2. * 造一个车
  3. */
  4. public class NewCar {
  5. public static void main(String[] args) {
  6. Car car = new Car(20);
  7. car.init();
  8. }
  9. /**
  10. * 汽车对象
  11. */
  12. static class Car {
  13. private Framework framework;
  14. public Car(int size){
  15. framework = new Framework(size);
  16. }
  17. public void init() {
  18. framework.init();
  19. }
  20. }
  21. /**
  22. * 车身类
  23. */
  24. static class Framework {
  25. private Bottom bottom;
  26. public Framework(int size){
  27. bottom = new Bottom(size);
  28. }
  29. public void init() {
  30. bottom.init();
  31. }
  32. }
  33. /**
  34. * 地盘类
  35. */
  36. static class Bottom {
  37. private Tire tire;
  38. public Bottom(int size){
  39. tire = new Tire(size);
  40. }
  41. public void init() {
  42. tire.init();
  43. }
  44. }
  45. /**
  46. * 轮胎类
  47. */
  48. static class Tire {
  49. private int size;
  50. public Tire(int size){
  51. this.size = size;
  52. }
  53. public void init() {
  54. System.out.println("轮胎尺寸: " + size);
  55. }
  56. }
  57. }

不难看出,当我们底层代码改动之后,整个调用链上的所有代码都需要修改,这是很麻烦的,因为代码耦合度很高

1.2.2 解决办法

这时我们就需要解耦,我们把轮胎交给别人做,我们只管提需求别人做好了拿来用就行了,这就是控制反转式程序开发

  1. /**
  2. * 造一辆车
  3. */
  4. public class NewCar {
  5. public static void main(String[] args) {
  6. Tire tire = new Tire(20,"猛男粉");
  7. Bottom bottom = new Bottom(tire);
  8. Framework framework = new Framework(bottom);
  9. Car car = new Car(framework);
  10. car.init();
  11. }
  12. /**
  13. * 车类
  14. */
  15. static class Car{
  16. private Framework framework;
  17. public Car(Framework framework){
  18. this.framework = framework;
  19. }
  20. public void init() {
  21. framework.init();
  22. }
  23. }
  24. /**
  25. * 车身类
  26. */
  27. static class Framework{
  28. private Bottom bottom;
  29. public Framework(Bottom bottom){
  30. this.bottom = bottom;
  31. }
  32. public void init() {
  33. bottom.init();
  34. }
  35. }
  36. /**
  37. * 地盘类
  38. */
  39. static class Bottom {
  40. private Tire tire;
  41. public Bottom(Tire tire) {
  42. this.tire = tire;
  43. }
  44. public void init() {
  45. tire.init();
  46. }
  47. }
  48. /**
  49. * 轮胎类
  50. */
  51. static class Tire{
  52. private int size ;
  53. private String color;
  54. public Tire(int size,String color){
  55. this.size = size;
  56. //我还可以加颜色
  57. this.color = color;
  58. }
  59. public void init() {
  60. System.out.println("轮胎尺寸: " + size+",颜色: "+color);
  61. }
  62. }
  63. }

在这里插入图片描述

这样改制后,我们在想去改车的一些属性,就不用调用整个类了,这样就很好的完成了代码之间的解耦,从而实现更加灵活,通用的程序设计了
在这里插入图片描述
在这里插入图片描述

1.2.3 对比总结

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

在这里插入图片描述
在我们改进之后的控制权发⽣的反转,不再是上级对象创建并控制下级对象了,⽽是下级对象把注⼊将当前对象中,下级的控制权不再由上级类控制了,这样即使下级类发⽣任何改变,当前类都是不受影响的,这就是典型的控制反转,也就是 IoC 的实现思想

1.3 什么是 DI?

DI 是 Dependency Injection 的缩写,翻译成中⽂是“依赖注⼊”的意思

2. 总结

2.1 Spring 是什么?如何理解 Spring?

Spring 是包含了多个⼯具⽅法的 IoC 容器,说的是对象的创建和销毁的权利都交给 Spring 来管理了,它本身⼜具备了存储对象和获取对象的能⼒。也就是 Spring 最核心的功能就是:就是学如何将对象(Bean)存⼊到 Spring (容器)中,再从 Spring(容器) 中获取对象(Bean)的过程

2.2 IoC 和 DI 是啥?有什么区别?

2.3 Spring 最核心的功能是啥?

1: 将 Bean(对象) 储到 Spring(容器)中

2: 将 Bean(对象) 从 Spring(容器)中出来


文章标签:

原文连接:https://juejin.cn/post/7118588503419535374

相关推荐

领域驱动设计:事件溯源架构简介

Figma自编教程第三篇(也是做产品实习生的第三天)

Flutter 绘制探索 | 箭头端点的设计

为什么设计的软件不好用?那是因为不熟悉软件开发模型!一文熟悉软件开发模型

Netty 案例之 IM 方案设计

【设计模式】责任链模式(Chain of Responsibility Pattern)

VGA设计(原理说明。Verilog代码实现,仿真结果)

提升UI产品体验的14个细节!你都知道吗?

【毕业设计】深度学习 opencv python 实现中国交通标志识别

TiFlash 源码阅读(五) DeltaTree 存储引擎设计及实现分析 - Part 2

还记得当年的超级玛丽么?来吧,动手设计一款小霸王游戏机

Figma自编教程第二篇(也是做产品实习生的第二天)

【毕业设计】python+大数据构建疫情可视化分析系统

Go的错误处理设计

Figma自编教程第一篇(也是做产品实习生的第一天)

【设计模式】模板模式,学会它咱也写出优雅健壮的代码!

从全局角度,如何设计一个秒杀系统?

【分享】从Mybatis源码中,学习到的10种设计模式

【干货】MySQL底层架构设计,你了解多少?

【C++】从设计原理来看string类