前言
今天开始我们专题的第一课了, 也是我开始进阶学习的第一天, 我们先从经典设计思想开始, 看看大牛市如何写代码的, 提升技术审美, 提高核心竞争力. 本章节参考资料书籍《Spring 5 核心原理》中的第一篇 Spring 内功心法(没有电子档, 都是我取其精华并结合自己的理解, 一个字一个字手敲出来的).
开闭原则
开闭原则 (Open-Closed Principle,OCP) 是指一个软件实体 (如类, 模块和函数) 应该对扩展开发, 对修改关闭. 所谓的开闭, 也正是对扩展和修改的两种行为的一个原则. 它强调的是用抽象构建框架, 用实现扩展细节, 可以提高软件系统的可复用性及可维护性. 开闭原则他是面向对象设计中最基础的设计原则. 它知道我们如何建立稳定, 灵活的系统. 例如版本更新, 我们尽可能不修改源码, 但可以增加新功能. 常见于我们经常写的接口与实现类的使用上, 先接口定义好, 对于不同的需求写不同的实现类, 后期有改动若不修改原有代码, 可以重新写一个实现类.
依赖倒置原则
依赖倒置原则 (Dependence Inversion Principle,DIP) 是指设计代码结构时, 高层模块不应该依赖底层模块, 二者都应该依赖其抽象. 抽象不应该依赖细节, 细节应该依赖抽象. 通过依赖倒置, 可以减少类与类之间的耦合性, 提高系统的稳定性, 提高代码的可读性和可维护性, 并且能够降低修改程序所造成的风险. 这是一个比较重要的设计原则, 在我们日常开发中, 经常有使用该思想的场景, 能避免很多时候业务更改时, 只需要改动少量代码就可以完成需求. 下面我们通过一个例子, 来深入理解该思想.
以学习课程为例:
- //Tom 正在学习两个课程
- public class Tom {
- public void studyJva() {
- System.out.println("正在学习 Java");
- }
- public void studyPython() {
- System.out.println("正在学习 Python");
- }
- }
- // 这里调用 Tom 的两个学习方法
- public static void main(String[] args) {
- Tom tom = new Tom();
- tom.studyJva();;
- tom.studyPython();
- }
看上去以上两个类的方法与调用没有毛病, 但是随着业务的扩展, Tom 又想继续学习 Go 语言, 这时候我们就需要从低层到高层 (调用层) 依次修改代码. 先在 Tom 里面正在 studyGo()方法, 然后在 main 中加以调用. 这样一来, 系统发布以后, 实际上非常不稳定, 现在代码少能清晰知晓, 但是实际项目中, 代码量, 涉及的业务非常多, 修改多个类的代码, 可能会代码意想不到的风险.
接下来我们根据依赖倒置的思想来优化代码, 先创建一个 ICourse 接口.
- public interface ICourse {
- /**
- * 抽象出来一个专门用来学习的方法, 抽象不依赖细节, 不去关心去学习什么课程
- */
- void study();
- }
- // 创建一个 Java 课程学习
- public class JavaCourse implements ICourse {
- /**
- * 由实现类去觉得具体学习什么课程(细节应该依赖抽象)
- */
- public void study() {
- System.out.println("Tom 在学习 Java");
- }
- }
- // 创建一个 Python 课程学习
- public class PythonCourse implements ICourse {
- public 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, 而不在需要修改底层代码(也体现了开闭原则).
大家要切记: 以抽象为基准比以细节为基准搭建起来的架构要稳定的多, 因此在拿到需求之后, 要面向接口编程, 先顶层再细节设计代码结构.
单一职责原则
单一职责 (Simple Responsibility Pinciple,SRP) 是指不要存在多于一个导致类变更的原因. 假设我们有一个类负责两个职责, 一旦发生需求变更, 修改其中一个职责的代码, 有可能导致另外一个职责的功能发生故障. 这样一来, 这个类就存在两个导致类发生变更的原因. 如何解决这个问题呢? 将两个职责用两个类来实现, 进行解耦. 后期需求变更维护互不影响. 这样的设计, 可以降低类的复杂度, 提高类的可读性, 提高系统的可维护性, 降低变更引起的风险. 总体来说, 就是一个类, 接口或方法只负责一项职责.
接下来, 我们来看代码示例, 还用课程举例, 我们的课程有直播课和录播课. 直播课不能快进和快退, 录播课程可以任意反复观看, 功能职责不一样, 还是想创建一个 Course 类:
- public class Course {
- public void study(String courseName){
- if ("直播课".equals(courseName)){
- System.out.println(courseName + "不能快进");
- }else {
- System.out.println(courseName + "可以反复回看");
- }
- }
- }
- // 看下调用代码
- public static void main(String[] args) {
- Course course = new Course();
- course.study("直播课");
- course.study("录播课");
- }
从上面的的代码来看, Course 类承担了两种处理逻辑. 假如现在要对课程进行加密, 直播课与录播课的加密逻辑不一样, 必须修改代码. 而修改代码的逻辑势必会相互影响, 容易带来不可控的风险. 我们对职责进行解耦, 来看代码, 分别创建两个类
- // 直播
- public class LiveCourse {
- public void study(String courseName){
- System.out.println(courseName + "不能快进看");
- }
- }
- // 录播
- public class ReplayCourse {
- public void study(String courseName){
- System.out.println(courseName + "可以反复回看");
- }
- }
- // 调用代码
- public static void main(String[] args) {
- LiveCourse liveCourse = new LiveCourse();
- liveCourse.study("直播课!");
- ReplayCourse replayCourse = new ReplayCourse();
- replayCourse.study("录播课!");
- }
此时业务继续发展, 课程要做权限. 没有付费的学员可以获得课程基本信息, 已经付费的学员可以获得视频流, 即学习权限. 设计一个顶层接口, 创建 ICourse 接口:
- public interface ICourse {
- // 获取课程基本信息
- String getCourseName();
- // 获取视频流
- byte[] getCourseVideo();
- // 学习课程
- void studyCourse();
- // 退款
- void refundCourse();
- }
其实在控制课程层面上至少有两个职责. 我们可以把展示职责和管理职责分离开来, 都实现同一个抽象依赖. 我们可以把这个接口拆成两个接口: ICourseInfo 和 ICourseManager.
- public interface ICourseInfo {
- // 获取课程基本信息
- String getCourseName();
- // 获取视频流
- byte[] getCourseVideo();
- }
- public interface ICourseManager {
- // 学习课程
- void studyCourse();
- // 退款
- void refundCourse();
- }
我们看下类图

以上是类 / 接口的单一职, 下面我们看下方法层面的单一职责, 有时候我们会偷懒, 把一个方法写成下面这样:
- /**
- * 修改用户信息
- */
- private void modityUserInfo(String userName,String address){
- userName="LaoWang";
- address = "BeiJin";
- }
- private void modityUserInfo(String userName,String... fileds){
- userName="LaoWang";
- for (String filed : fileds) {
- //....
- }
- }
- private void modityUserInfo(String userName,String address,boolean bool){
- if (bool){
- //...
- }else {
- //...
- }
- userName = "LaoWang";
- address = "BeiJin";
- }
显然, 上面的 modityUserInfo()方法承担了多个职责, 既可以修改 userName 又可以修改 address, 甚至更多, 明显不符合单一职责. 我们做如下修改, 可以拆成两个方法
- private void modifyUserName(String userName){
- userName="LaoWang";
- }
- private void modifyAddress(String address){
- address = "BeiJin";
- }
修改之后, 开发起来简单, 维护起来也容易. 我们在实际开发中会有项目依赖, 组合, 聚合这些关系, 还有的项目的规模, 周期, 技术人员的水平, 对进度的把控, 很多类都不符合单一职责. 但是, 我们在编写代码的过程中, 尽可能的让接口和方法保持单一职责, 对项目后期的维护是有很大的帮助的.
来源: https://www.cnblogs.com/whgk/p/12456239.html