当前位置：首页 > wzjs >正文

系统网站建设公司如何找做网站的公司

wzjs 2025/7/26 23:37:54

系统网站建设公司,如何找做网站的公司,自己做网站要花钱吗,类模板模板下载网站文章目录 Spring 是什么什么是容器什么是 IoCIoC 介绍传统程序开发解决方法IoC 程序开发IoC 的优势在前面中，我们学习了 Spring Boot 和 Spring MVC 的开发，可以完成一些基本功能的开发了，但是什么是 Spring 呢？Spring&…

文章目录

Spring 是什么
什么是容器
什么是 IoC
IoC 介绍
- 传统程序开发
- - 解决方法
  - IoC 程序开发
  - IoC 的优势

在前面中，我们学习了 Spring Boot 和 Spring MVC 的开发，可以完成一些基本功能的开发了，但是什么是 Spring 呢？Spring，Spring Boot，SpringMVC 又有什么关系呢？

Spring 是什么

通过前面的学习，我们知道了 Spring 是一个开源框架，他让我们的开发更加简单。他支持广泛的应用场景，有着活跃而庞大的社区，这也是 Spring 能后长久不衰的原因

但是这个概念相对来说是比较抽象的。我们用一句更具体的话来概括 Spring，那就是：Spring 是包含了众多工具方法的 IoC 容器

那问题来了，什么是容器？什么是 IoC 容器？

什么是容器

容器是用来容纳某种物品的（基本）装置。生活中的水杯，垃圾桶，冰箱等等这些都是容器。

我们想象，之前的内容中我们接触到了哪些容器

List/Map：数据存储容器
Tomcat：Web 容器

什么是 IoC

IoC 是 Spring 的核心思想，也是常见的面试题。其实我们在前面已经使用过了 IoC，在类上面添加 @RestController 注解，就是把这个对象交给 Spring 管理，Spring 框架启动时就会加载该类。把对象交给 Spring 管理，就是 IoC 思想

IoC：Inversion of Control（控制反转），也就是说 Spring 是一个“控制反转”的容器

什么是控制反转呢？
也就是控制权反转，获得依赖对象的过程被反转了，也就是说，当需要某个对象时，传统开发模式中需要自己通过 new 创建对象，现在不需要再及你选哪个创建，把创建对象的任务交给容器，程序中只需要依赖注入（Dependency Injection，DI）就可以了，这个容器称为：IoC 容器，Spring 是一个 IoC 容器，所以有时 Spring 也称为 Spring 容器

控制反转是一种思想，在生活中也是处处体现

比如自动驾驶，传统驾驶方式，车辆的横向和纵向驾驶控制权由驾驶员来控制，现在交给了驾驶自动化系统来控制，可也是控制反转思想在生活动的实现
比如招聘，企业的员工招聘，入职，解雇等控制权，由老板转交给 HR 来处理

IoC 介绍

需求：造一台车

传统程序开发

我们的实现思路是这样的：
先设计轮子（Tire），然后根据轮子的大小设计底盘（Bottom），接着根据底盘设计车身（Framework），最后根据车身设计好整个汽车（Car）。这里就出现了一个“依赖”关系：汽车依赖车身，车身依赖底盘，底盘依赖轮子

public class NewCarExample {public static void main(String[] args) {Car car = new Car();car.run();	}/***汽车对象*/static class Car {  private Framework framework;  public Car() {  framework = new Framework();  System.out.println("framework init...");  } public void run() {  System.out.println("car run...");  }  }/***车身类*/static class Framework {  private Bottom bottom;  public Framework() {  bottom = new Bottom();  System.out.println("bottom init...");  }  }	/***底盘类*/static class Bottom {  private Tire tire;  public Bottom() {  tire = new Tire();  System.out.println("tire init...");  }  }/***轮胎类*/public class Tire {  private int size = 21;  public Tire() {  System.out.println("tire size:" +size);  }  }
}

这样的设计看起来没问题，但是可维护性却很低.

接下来需求有了变更: 随着对的的需求量越来越, 个性化需求也会越来越多，我们需要加多种尺
的轮胎.

那这个时候就要对上的程序进修改了，修改后的代码如下所
修改之后, 其他调程序也会报错, 我们需要继续修改

完整代码如下：

public class NewCarExample {public static void main(String[] args) {Car car = new Car(21);car.run();	}/***汽车对象*/static class Car {  private Framework framework;  public Car(int size) {  framework = new Framework(size);  System.out.println("framework init...");  } public void run() {  System.out.println("car run...");  }  }/***车身类*/static class Framework {  private Bottom bottom;  public Framework(int size) {  bottom = new Bottom(size);  System.out.println("bottom init...");  }  }	/***底盘类*/static class Bottom {  private Tire tire;  public Bottom(int size) {  tire = new Tire(size);  System.out.println("tire init...");  }  }/***轮胎类*/public class Tire {  private int size = 21;  public Tire(int size) {  this.size = size;System.out.println("tire size:" +size);  }  }
}

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

程序的耦合度常(修改处代码, 影响其他处的代码修改)

解决方法

在上的程序中, 我们是根据轮的尺设计的底盘，轮的尺改，底盘的设计就得修改. 同样因
为我们是根据底盘设计的，那么也得改，同理汽设计也得改, 也就是整个设计乎都得改

我们尝试换种思路, 我们先设计汽的概样，然后根据汽的样来设计，根据来设计底盘，最后根据底盘来设计轮. 这时候，依赖关系就倒置过来了：轮依赖底盘，底盘依赖，依赖汽

这就类似我们打造辆完整的汽, 如果所有的配件都是造，那么当客需求发改变的时候，
如轮胎的尺不再是原来的尺了，那我们要动来改了，但如果我们是把轮胎外包出去，那
么即使是轮胎的尺发变变了，我们只需要向代理下订单就了，我们是不需要出的.

如何来实现呢:

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

此时，我们只需要将原来由创建的下级类，改为传递的式（也就是注的式），因为我们不
需要在当前类中创建下级类了，所以下级类即使发变化（创建或减少参数），当前类本也需修

改任何代码，这样就完成了程序的解耦

IoC 程序开发

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

public class NewCarExample {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(framewoek);car.run();	}/***汽车对象*/static class Car {  private Framework framework;  public Car(Framework framework) {  framework = new Framework();  System.out.println("framework init...");  } public void run() {  System.out.println("car run...");  }  }/***车身类*/static class Framework {  private Bottom bottom;  public Framework(Bottom bottom) {  bottom = new Bottom();  System.out.println("bottom init...");  }  }	/***底盘类*/static class Bottom {  private Tire tire;  public Bottom(Tire tire) {  tire = new Tire();  System.out.println("tire init...");  }  }/***轮胎类*/public class Tire {  private int size = 21;  public Tire(int size) {  this.size = size;System.out.println("tire size:" +size);  }  }
}

代码经过以上调整，论底层类如何变化，整个调链是不做任何改变的，这样就完成了代码之间的解耦，从实现了更加灵活、通的程序设计了。

IoC 的优势

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

我们发现了个规律，通程序的实现代码，类的创建顺序是反的，传统代码是 Car 控制并创建了 Framework，Framework 创建并创建了 Bottom，依次往下，改进之后的控制权发的反转，不再是使对象创建并控制依赖对象了，是把依赖对象注将当前对象中，依赖对象的控制权不再由当前类控制了.

这样的话, 即使依赖类发任何改变，当前类都是不受影响的，这就是典型的控制反转，也就是 IoC 的实现思想。

学到这, 我们概就知道了什么是控制反转了, 那什么是控制反转容器呢, 也就是 IoC 容器
这部分代码, 就是 IoC 容器做的作.