文章目录
软件架构设计原则开闭原则依赖倒置原则最后软件架构设计原则
本文通过实例来讲解
开闭原则依赖导致原则
开闭原则
开闭原则(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 核心原理