软件设计原则-依赖倒置原则

定义：高层模块不应该依赖低层模块，二者都应该依赖其抽象。

强调：抽象不应该依赖细节，细节应该依赖抽象。针对接口编程，不要针对实现编程。

优点：可以减少类之间的耦合性，提高系统的稳定性，提高代码的可读性和可维护性，降低修改程序所造成的风险。

案例：

以程序员学习课程为例，

V1的版本中，Galen学习了两种具体的课程：

public class Galen {
    public void studyJavaCourse() {
        System.out.println("Galen 在学习java课程");
    }

    public void studyFECourse() {
        System.out.println("Galen 在学习FE课程");
    }
}

在这个版本中，Galen学习课程，依赖了具体的实现，违反了依赖倒置原则。假如Galen需要再学习python，那就需要对Galen的这个类进行修改，再加一个studyPython（）的方法，进行具体的实现，显然增加了维护的成本。 

在此基础上，我们设计了V2版本：

将课程进行抽象成ICourse接口，

public interface ICourse {
    void studyCourse();
}

具体的课程实现了ICourse接口，

public class FECourse implements ICourse {
    @Override
    public void studyCourse() {
        System.out.println("Galen在学习FE课程");
    }

}

public class JavaCourse implements ICourse {
    @Override
    public void studyCourse() {
        System.out.println("Galen在学习Java课程");
    }
}

Galen依赖抽象接口ICourse，是不是有点眼熟，Spring中的依赖注入就是依赖倒置原则的一个体现。

public class Galen {
    public void setiCourse(ICourse iCourse) {
        this.iCourse = iCourse;
    }

    private ICourse iCourse;

    public void studyCourse(){
        iCourse.studyCourse();
    }
}

那这样的话，假如Galen要学习python课程，只需要再扩展一个python的课程，而上层的Galen不需要再进行调整，因为其依赖了抽象接口ICourse。

public class PythonCourse implements ICourse {
    @Override
    public void studyCourse() {
        System.out.println("Galen在学习Python课程");
    }
}

在应用层，只需要传入不同的实现即可，此处我们用test类来表示应用层。

public class Test {
    public static void main(String[] args) {
        Galen galen = new Galen();
        galen.setiCourse(new JavaCourse());
        galen.studyCourse();

        galen.setiCourse(new FECourse());
        galen.studyCourse();
    }
}

通过上述改造， Galen从依赖课程的具体实现，改造成依赖课程的抽象接口，无论Galen想学什么课程，我们都可以在不改变Galen的基础上，将ICourse进行扩展，在应用层传入不同的实现满足要求。在Spring应用的开发过程中，相信大家对@Autowired和@Resource两个注解并不陌生，开发者可以灵活的在应用层注入想要的接口的实现类，这也是依赖倒置原则的一个体现。