认识Spring IOC容器

知识要点

• 什么是Spring IoC容器
• 什么是IoC
• 什么是依赖倒置
• 什么是依赖注入
• 为什么需要Spring IoC

一、什么是Spring IoC容器

Spring Ioc容器的最主要作用就是：完成对象的创建管理和依赖注入等 

二、什么是IoC

IoC（Inversion of Control，控制反转）是Spring的核心，贯穿始终。不是什么技术提供强大的功能，而是一种设计思想。对于spring框架来说，就是由 IoC 来负责控制对象的生命周期和对象之间的关系。而不是传统的在你的对象内部直接控制。如何理解好Ioc呢？理解好Ioc的关键是要明确“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”，那我们来深入分析一下：

谁控制谁，控制什么：

传统Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IoC是有专门一个容器来创建这些对象，即由Ioc容器来控制对 象的创建；

谁控制谁？当然是IoC 容器控制了对象；控制什么？那就是主要控制了外部资源获取（不只是对象包括比如文件等）。

为何是反转，哪些方面反转了：

有反转就有正转，传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转；而反转则是由容器来帮忙创建及注入依赖对象；为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，所以是反转；哪些方面反转了？依赖对象的获取被反转了。

IoC很好的体现了面向对象设计法则之一—— 好莱坞法则：“别找我们，我们找你”；即由IoC容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。

设计模式之 “依赖倒置”

既然提到了IoC，我们就不得不提及设计模式中的六大原则。因为原则之一的“依赖倒置”跟IoC有很大的关系。

控制反转（IoC）是DIP（Dependence Inversion Principle，依赖倒置原则）的一种具体实现方式。

依赖注入（DI，Dependence Injection）是IoC的一种具体实现方式，用来实现依赖倒置。

面向接口编程是依赖倒置原则的核心，上层定义接口，下层实现这个接口， 从而使得下层依赖于上层，降低耦合度。

 

让我们来看一段代码：

class Laptop {

        public void start(){

              System.out.println("Laptop启动....");

        }

        public void run(){

              System.out.println("Laptop运行....");

       }

}

class Programmer {

       Laptop laptop = new Laptop();

       // 编写代码

       public void coding(){

              laptop.start();

              laptop.run();

       }

}

上面这段代码的问题在：如果某一天业务需求要改换成台式电脑（Desktop），这个修改工作肯定是避免不了的。而且工程越复杂修改量越大。怎么处理好呢？

如果我们不进行解耦，它们的关系就会是这样：

而且，在采用面向对象方法设计的软件系统中，底层实现都是由非常多的对象组成，所有的对象通过彼此的合作，最终实现系统的业务逻辑。 随着应用的规模越来越庞大，对象之间的依赖关系也越来越复杂，经常会出现对象之间的多重依赖性关系。这是致命的，不管对于开发还是维护来说。

三、什么是依赖倒置

如何降低系统之间、模块之间和对象之间的耦合度，是软件工程永远追求的目标之一。为了解决对象之间的耦合度过高的问题，我们使用IoC理论来实现对象之间的“解耦”。

上面的代码，对象和对象之间的耦合太严重。那我们应该如何进行解耦呢？

我们再来看一段代码：

interface Computer {

       public void start();

       public void run();

}

class Laptop implements Computer{

       public void start(){

              System.out.println("Laptop启动....");

       }

       public void run(){

              System.out.println("Laptop运行....");

       }

}

 

class Desktop implements Computer{

       public void start(){

              System.out.println("Desktop启动....");

       }

       public void run(){

              System.out.println("Desktop运行....");

       }

}

       

class Programmer {

       Computer c;

       Programmer(Computer c){

              this.c = c;

       }

       public void coding(){

              c.start();

              c.run();

              c.stop();

       }

 

       // DI 解决依赖问题

       // IOC 解决实例化问题

       public static void main(String[] args){

              Computer c = new Desktop();

              Programmer p = new Programmer(p);

              p.coding();

      }

}

在这段代码里面，就体现了几个设计模式中的原则，当然也包括“依赖倒置”—— 高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象。

上面的第一段代码中的类是Programmer类依赖了具体Laptop类，如Programmer中的use方法drive，这样Programmer就对具体的Laptop产生了依赖，如果这个时候想要使用其它的工具如Desktop（桌面台式电脑），就需要修改Programmer类。因此我们需要抽象接口Computer，这样Programmer只需要依赖Computer即可，至于到底选择哪种电脑，就交给IOC容器，进行依赖注入即可。

高层模块不应该依赖底层模块

这句话是依赖倒置的核心。指的是概念的自包含，上层模块不应该去依赖具体的某个底层提供方。在设计系统时，常常会采用分层的方式：数据访问层，业务逻辑层，展示层等，而每一层会依赖下层的API，这样导致的问题就是难以替换下层的提供方。那应该如何做呢？业务逻辑层需要有自己的数据访问规范，也就是SPI，然后数据提供层去适配这个SPI，这样如果替换了下层的数据层之后对业务逻辑层也不会产生影响。

抽象不应该依赖细节，细节应该依赖抽象

有了上面的概念之后，自然也就有了依赖抽象而非细节，因为上层制定的是SPI（Service Provider Interface）, 也就是一种通用的实现接口，由不同的实现方来提供实现。另外一般实现方也会提供自己的API接口供其他应用来使用，因此一般实现方会在自己的API上面封装一层SPI的适配层来提供给上层使用。

依赖抽象而非细节也是依赖注入与IOC实现的基础。

 

四、依赖注入

DI — Dependency Injection，即“依赖注入”：组件之间依赖关系由容器在运行期决定，形象的说，即由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能，而是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资源来自何处，由谁实现。

理解DI的关键是：“谁依赖谁，为什么需要依赖，谁注入谁，注入了什么”，那我们来深入分析一下：

• 　　谁依赖于谁：当然是应用程序依赖于IoC容器；
• 　　为什么需要依赖：应用程序需要IoC容器来提供对象需要的外部资源；
• 　　谁注入谁：很明显是IoC容器注入应用程序某个对象，应用程序依赖的对象；
• 　　注入了什么：就是注入某个对象所需要的外部资源（包括对象、资源、常量数据）。

IoC和DI由什么关系呢？IoC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通DI（Dependency Injection，依赖注入）来实现的。比如对象A需要操作数据库，以前我们总是要在A中自己编写代码来获得一个Connection对象，有了 spring我们就只需要告诉spring，A中需要一个Connection，至于这个Connection怎么构造，何时构造，A不需要知道。在系统运行时，spring会在适当的时候制造一个Connection，然后像打针一样，注射到A当中，这样就完成了对各个对象之间关系的控制。A需要依赖 Connection才能正常运行，而这个Connection是由spring注入到A中的，依赖注入的名字就这么来的。那么DI是如何实现的呢？ Java 1.3之后一个重要特征是反射（reflection），它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，spring就是通过反射来实现注入的。

五、为什么需要Spring IoC

IoC 不是一种技术，只是一种思想，一个重要的面向对象编程的法则，它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象，从而导致类与类之间高耦合，难于测试；有了IoC容器后，把创建和查找依赖对象的控制权交给了容器，由容器进行注入组合对象，所以对象与对象之间是 松散耦合，这样也方便测试，利于功能复用，更重要的是使得程序的整个体系结构变得非常灵活。

其实IoC对编程带来的最大改变不是从代码上，而是从思想上，发生了“主从换位”的变化。应用程序原本是老大，要获取什么资源都是主动出击，但是在IoC/DI思想中，应用程序就变成被动的了，被动的等待IoC容器来创建并注入它所需要的资源了。

IoC很好的体现了面向对象设计法则之一—— 好莱坞法则：“别找我们，我们找你”；即由IoC容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。

IOC理论提出的观点大体是这样的：借助于“第三方”实现具有依赖关系的对象之间的解耦，如下图：