【设计模式】依赖倒置原则与工厂方法模式与spring

目录

一、引言：

二、概述：

三、举例：

“简单工厂”：

依赖倒置：

四、问题来了

五、在spring中

---

一、引言：

设计模式的六大原则有：

Single Responsibility Principle：单一职责原则
Open Closed Principle：开闭原则
Liskov Substitution Principle：里氏替换原则
Law of Demeter：迪米特法则
Interface Segregation Principle：接口隔离原则
Dependence Inversion Principle：依赖倒置原则
把这六个原则的首字母联合起来（两个 L 算做一个）就是 SOLID （solid，稳定的）。六大原则是设计模式的基石，这篇文章中，我们来看一下依赖倒置原则。

二、概述：

依赖倒置原则是：

1、高层模块不应该依赖低层模块。两个都应该依赖抽象；

2、抽象不应该依赖细节。细节应该依赖抽象；

 

三、举例：

以《大话设计模式》中，大鸟要求小菜实现计算机加减乘除功能为例

“简单工厂”：

运算类 Operation

public class Operation {

    private double numberA = 0;

    private double numberB = 0;

    public double getResult() {
        double result = 0;
        return result;
    }

    public double getNumberA() {
        return this.numberA;
    }

    public void setNumberA(double numberA) {
        this.numberA = numberA;
    }

    public double getNumberB() {
        return numberB;
    }

    public void setNumberB(double numberB) {
        this.numberB = numberB;
    }

}

加法类 OperationAdd

public class OperationAdd extends Operation {
    @Override
    public double getResult() {
        double result;
        result = getNumberA() + getNumberB();
        return result;
    }
}

减法类 OperationSub

public class OperationSub extends Operation {
    @Override
    public double getResult() {
        double result;
        result = getNumberA() - getNumberB();
        return result;
    }
}

 

乘法类  OperationMul

public class OperationMul extends Operation {
    @Override
    public double getResult() {
        double result;
        result = getNumberA() * getNumberB();
        return result;
    }
}

除法类  OperationDiv

public class OperationDiv extends Operation {
    @Override
    public double getResult() {
        double result;
        if (getNumberB() == 0) {
            System.out.println("除数不能为0");
            return 0;
        }
        result = getNumberA() / getNumberB();
        return result;
    }
}

简单工厂类 OperationFactory

public class OperationFactory {
    public static Operation createOperate(String operate) {
        Operation oper = null;
        switch (operate) {
            case "+":
                oper = new OperationAdd();
                break;
            case "-":
                oper = new OperationSub();
                break;
            case "*":
                oper = new OperationMul();
                break;
            case "/":
                oper = new OperationDiv();
                break;
        }
        return oper;
    }
}

main 方法

public static void main(String[] args) {
        Operation oper;
        oper = OperationFactory.createOperate("+");
        oper.setNumberA(1);
        oper.setNumberB(2);
        double result = oper.getResult();
        System.out.println(result);
    }

在这段代码中，可以看出，实现加法功能，加法工厂（高层）需要调用加法实现（低层），在main方法中，通过传入“+”，在工厂中生成实现类。此时如果增加“求平方”的功能。添加子类的同时，需要修改OperationFactory类。上层依赖下层实现。

依赖倒置：

使用依赖倒置原则，试着解决下这个问题。以工厂方法模式为例：

在“简单工厂”的基础上，加上抽象工厂。

抽象接口：IFactory

public interface IFactory {
    Operation createOperation();
}

加法工厂类：AddFactory（实现抽象接口）

public class AddFactory implements IFactory{
    @Override
    public Operation createOperation() {
        return new OperationAdd();
    }
}

减法工厂类： SubFactory（实现抽象接口）

public class SubFactory implements IFactory {
    @Override
    public Operation createOperation() {
        return new OperationSub();
    }
}

乘法工厂类：OperationMul（实现抽象接口）

public class MulFactory implements IFactory {
    @Override
    public Operation createOperation() {
        return new OperationMul();
    }
}

除法工厂类：DivFactory（实现抽象接口）

public class DivFactory implements IFactory{
    @Override
    public Operation createOperation() {
        return new OperationDiv();
    }
}

main 方法：

public static void main(String[] args) {
  IFactory factory = new AddFactory();
  Operation oper = factory.createOperation();
  oper.setNumberA(1);
  oper.setNumberB(2);
  double result = oper.getResult();
  System.out.println(result);
}

加入工厂方法模式，最直观的感受是：代码多了。

从main方法可以看出，工厂（高层）不直接调用具体的子类（低层），而是工厂和子类都依赖抽象接口，工厂只需要调用抽象接口，将具体实现延迟到了子类。此时如果增加“求平方”的功能，只需要新增实现类，实现抽象接口IFactory即可。实现了依赖倒置。

四、对比

1、工厂方法中，父类依赖抽象不依赖具体，那在哪里决定生成哪个子类？

换句话说：IFactory factory = new AddFactory();

main方法中的这段代码，应该写在哪里？

答案是，这段代码，可以任何形式由调用者传入，可以写在具体调用者的事件下，也可以写在配置文件中。调用者只需“告诉”程序要实现什么功能，具体交给子类实现。

2、两种方式都能实现功能，使用依赖倒置的好处是什么？

1）高层和低层都依赖抽象，低层修改不影响高层，实现解耦合，增加了低层的可扩展性；

2）高层仅需考虑调用哪个接口，无需关注具体实现，由低层实现，低层功能内聚；

 

五、在spring中

       IFactory factory = new AddFactory();

       其实，这段代码，spring帮我们实现了。spring的IOC容器就是工厂，生成各种功能工厂，高层根据功能选择生成哪个工厂。低层是实现类bean，可通过配置，注解等方式，注入到工厂中。高层通过反射从spring工厂中获取bean；bean依赖spring容器，注入到容器中，交给容器管理。spring IOC容器，将调用和实现解耦，使高层和低层都面向了spring IOC容器。