软件架构设计原则

本文通过实例来讲解

开闭原则
依赖导致原则

开闭原则

开闭原则（Open-Close Principle，OCP）是指一个软件实体（如类、模块和函数）应该对扩展开放，对修改关闭。所谓的开闭，也正是对扩展和修改两个行为的一个原则。它强调的是用抽象构建框架，用实现扩展细节，可以提高软件系统的可复用性及可维护性。开闭原则是面向对象设计中最基础的设计原则，它指导我们如何简历稳定、灵活的系统。例如版本更新，我们尽可能不修改源代码，但是可以增加新功能。

比如说：弹性作息时间，只规定每天工作8个小时，但是你什么时候来，什么时候走是开放的，早来早走，晚来晚走。

开闭原则的核心思想就是面向抽象编程，接下来我们来看一段代码。
以课程体系位例，首先创建一个课程接口ICourse:

public interface ICourse {//获取课程IdInteger getId();//获取课程名称String getName();//获取课程价格Double getPrice();
}

整个课程生态有Java、大数据、等，我们创建一个Java课程的类JavaCourse：

public class JavaCourse implements ICourse {private Integer id;private String name;private Double price;//构造器public JavaCourse(Integer id, String name, Double price) {this.id = id;this.name = name;this.price = price;}@Overridepublic Integer getId() {return this.id;}@Overridepublic String getName() {return this.name;}@Overridepublic Double getPrice() {return this.price;}
}

现在我们要给Java课程做活动，价格优惠，如果修改JavaCourse中的getPrice()方法，则存在一定的风险，可能影响其他地方的调用结果。我们如何在不修改源代码的前提下，实现价格优惠这个功能呢？我们可以在写一个处理优惠逻辑的类JavaDiscountCourse

public class JavaDiscountCourse extends JavaCourse {public JavaDiscountCourse(Integer id, String name, Double price) {super(id, name, price);}//初始价格public Double getOriginPrice(){return super.getPrice();}//获取优惠价格价格public Double getPrice(){return super.getPrice()*0.6;}
}

简单来看一下类结构图

所谓的开闭原则就是不修改，多扩展。

依赖倒置原则

依赖倒置原则（Dependence Inversion Princip，DIP）是指设计代码结构时，高层模块不应该依赖底层模块，二者都应该依赖其抽象。抽象不应该依赖细节，细节应该依赖抽象。通过依赖倒置，可以减少类与类之间的耦合性，提高系统的稳定性，提高代码的可读性和可维护性，并且能够降低修改程序所造成的风险。

看一个案例，还是以Course为例，先来创建一个类Tom：

public class Tom {public void studyJavaCourse(){System.out.println("Tom在学习Java课程");}public void studyPythonCourse(){System.out.println("Tom在学习Python课程");}
}

来调用一下：

public static void main(String[] args) {Tom tom = new Tom();tom.studyJavaCourse();tom.studyPythonCourse();}

Tom非常热爱学习，现在他想在学一门新的技术AI，这时候，因为业务扩展，要从低层到高层（调用层）一次修改代码。在Tom类中增加StudyAICouese()方法，在高层也要追加调用。如此依赖，系统发布以后，实际上是非常不稳定的，在修改代码的同时也会带来意想不到的风险。接下来我们优化代码，创建一个课程的抽象接口ICouese接口：

public interface ICourse {void study();
}

然后编写JvaCourse类：

public class JavaCourse implements ICourse {@Overridepublic void study() {System.out.println("tom正在学习Java");}
}

在编写pythonCourse类：

public class PythonCourse implements ICourse {@Overridepublic void study() {System.out.println("tom正在学习Python");}
}

修改Tom类：

public class Tom {public  void study(ICourse course){course.study();}
}

看调用代码：

 public static void main(String[] args) {Tom tom = new Tom();tom.study(new JavaCourse());tom.study(new PythonCourse());}

此时无论Tom还想学习几门课程，对于新的课程，只需要创建一个类，通过传参的方式告诉Tom，而不需要修改底层代码。实际上这是一种依赖注入方式，注入的方式还有构造器方法和Setter方法。

构造器注入方式：

public class Tom {private ICourse course;public Tom(ICourse course) {this.course = course;}public  void study(){course.study();}}

调用代码：

public static void main(String[] args) {Tom tom = new Tom(new JavaCourse());tom.study();}

根据构造器方式注入，在调用时，每次都要创建实例。如果Tom是全局单例，则我们只能选择用Setter方式来注入：

public class Tom {private ICourse course;public void setCourse(ICourse course) {this.course = course;}public  void study(){course.study();}
}

调用代码：

public static void main(String[] args) {Tom tom = new Tom();tom.setCourse(new JavaCourse());tom.study();tom.setCourse(new PythonCourse());tom.study();}

最终的类图：

以抽象为基准比以细节为基准构建起来的架构要稳定的多，因此在拿到需求之后，要面向接口编程，先顶层在细节地设计代码结构。

最后

后序还有：

单一职责原理
接口隔离原理
迪米特原理
里氏替换原理
合成复用原理

如果感兴趣可以继续关注

参考：Spring 5 核心原理