从面向对象(OO)设计原则上理解Spring的IOC

最新推荐文章于 2022-07-10 13:18:11 发布

置顶 BugMaking

最新推荐文章于 2022-07-10 13:18:11 发布

阅读量559

点赞数

分类专栏： Spring 文章标签： Spring SSM OO

本文链接：https://blog.csdn.net/qq_20744321/article/details/80876065

版权

Spring 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

相信大多数人在刚接触Spring时候，对Spring最重要的几个概念：IOC(反转控制)，DI(依赖注入)，AOP(面向切面编程)概念很模糊，甚至感到很费解。不知道设计出这些模式的原因，只知道在实际编程中用上这些模式后代码的确变得简洁，清晰，软件的可维护性也得到了很大的提高。
这篇文章先介绍Spring的IOC，我们从面向对象的设计原则上理解Spring的IOC运用的目的，相信能为大家以后的Spring学习理解增加些帮助。

首先我们要知道IOC的实现方式并不是程序员凭空想象出来的，肯定是在遇到具体的问题后，从设计上解决的一种方法。

下面我们就从设计者的角度看看，到底是遇到了什么问题，让设计者有了优化设计的思考：

程序猿小A正在开发一个模拟手机的应用，通过该应用可以实现将各种手机的特征模拟到一台手机上。该应用当然也是采用了面向对象的技术，小A设计了一个手机的父类(CellPhone)，其他的各种手机继承了该手机父类。

父类CellPhone代码如下：

public abstract class CellPhone {

    // 手机外观
    public abstract void display();

    // 手机铃声
    public abstract void ringtone();

    // 发短信
    public void sms() {
        System.out.println("I can send sms!!");
    }

    // 打电话
    public void callPhone() {
        System.out.println("I can call someone!!");
    }

    // 连wifi
    public void wifi() {
        System.out.println("I can connect wifi");
    }
}

子类MiCellPhone代码如下：

public class MiCellPhone extends CellPhone{

    @Override
    public void display() {
        System.out.println("mi display!!");

    }

    @Override
    public void ringtone() {
        System.out.println("mi ringtone!!");

    }

}

子类HuaweiCellPhone代码如下：

public class HuaweiCellPhone extends CellPhone{

    @Override
    public void display() {
        System.out.println("huawei display!!");

    }

    @Override
    public void ringtone() {
        System.out.println("huawei ringtone!!");

    }

}

mi手机，huawei手机各自继承了cellphone类。

现在有一个模拟手机的方法simulateCellPhone，模拟各种手机的特征，代码如下：

public void simulateCellPhone(String cellType) {
        CellPhone cellPhone = null;

        if("mi".equals(cellType)){
            cellPhone = new MiCellPhone();
        }else if("huawei".equals(cellType)) {
            cellPhone = new HuaweiCellPhone();
        }else {
            // cellPhone = 更多的手机类型
        }
        // 模拟外观
        cellPhone.display();
        // 模拟铃声
        cellPhone.ringtone();
    }

可以看出来，当有一些需要实例化的实体类时，究竟实例化哪一个实体类，需要在实际运行的时候才能决定。
而且，对象间的耦合度过高，一旦需要增加模拟的手机类型如iphoneCellPhone等，就需要再次增加else if进行手机实例化。一旦某些手机的不需要模拟了，则需要将对应的实例化片段删去。

后期维护的时候一旦有变化或者扩展，就必须要再次修改这个方法，对代码进行检查或者修改。通常下这种修改过的代码将造成部分系统更难维护和更新，而且也更容易犯错。

要知道，软件开发中工作量占比最大，时间花费最长的就是系统维护了，占比甚至达到了70%

为了减少系统维护人员(主要可能还是自己维护0.0)花费的时间，善良，负责的(主要是为了懒。。)程序员小A必须想出一个法子，降低对象间的耦合性。

这时，程序员小A想到了面向对象设计原则之一：
依赖倒置原则：要依赖抽象，不要依赖具体类。

依据该原则实现的设计模式：工厂模式及反射机制，

进而引申出了IOC(反转控制)的概念，简单来说就是：
设计好的对象由自己“new”实例化调用，变成了交由Spring容器创建对象。
这里写图片描述

下面就是程序员小A用IOC来实现模拟手机功能的步骤，看看和上面的方式有什么不同吧！
在spring的配置文件applicationContext.xml中，代码如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/aop
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
   http://www.springframework.org/schema/tx
   http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
   http://www.springframework.org/schema/context     
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <!-- MiCellPhone的bean配置 -->
    <bean name="miCellPhone" class="pojo.MiCellPhone">   
    </bean>

    <!-- HuaweiCellPhone的bean配置 -->
    <bean name="huaweiCellPhone" class="pojo.HuaweiCellPhone">
    </bean>

</beans>

这时，整个模拟手机的测试类只需要写成：

public class SimulateTest {

    public static ApplicationContext context = null;

    public static void main(String[] args) {

        // 加载配置文件的路径
        context = new ClassPathXmlApplicationContext(new String[] { "applicationContext.xml" });

        SimulateTest s = new SimulateTest();
        s.simulateCellPhone("miCellPhone");

    }

    public void simulateCellPhone(String cellType) {        

        CellPhone cellPhone = (CellPhone)context.getBean(cellType);

        // 模拟外观
        cellPhone.display();
        // 模拟铃声
        cellPhone.ringtone();
    }

}

可以看出在模拟手机方法simulateCellPhone中，类的实例化直接通过Spring来获取，不需要自己通过”new”来实例化变量。

通过对比不使用IOC的模拟手机方法和使用IOC的模拟手机方法可以看出，使用IOC的模拟手机方法代码不仅简洁，而且对于系统维护时手机种类的增加或者删除，该方法都不需要进行改动。

至此，程序员小A终于满意了，可以安心的继续“懒”着了。

总结：

IOC模式就是：由程序员自己控制对象的生成过程，变成了由容器控制对象间的依靠关系。

使用IOC模式即是将类与类之间的耦合代码从程序中移出，放到统一的XML文件(applicationContext.xml)中管理。控制权由程序代码控制转移到xml文件中管理。

IOC模式的优点：
极大的降低了类与类间的耦合性，实现了类与类之间的解耦，提高了系统的维护性和灵活性。

因为IOC容器运用了反射的原理，实例化类的时候，通过xml文件临时决定生成哪一种对象，生成对象的速度相对较慢。

IOC模式的缺点：
1.使用IOC模式看起来没有直接在程序中实例化类来的直观，变得复杂了些。(但其实习惯了就会觉得很方便)
2.反射的使用，使得生成对象的速度相对较慢，效率相对降低。(但对于IOC模式的优点来说，这点几乎可以忽略)
3.xml文件不支持IDE的重构，如果修改了类名，还需到XML文件中手动修改。