目录介绍

• 00.问题思考分析
• 01.前沿简单介绍
• 02.如何理解开闭原则
• 03.举一个原始的例子
• 04.修改后的代码
• 05.修改代码违背原则么
• 06.如何做到开闭原则
• 07.如何运用开闭原则
• 08.总结一下内容

00.问题思考分析

• 01.什么叫作开闭原则他的主要用途是什么
• 02.如何做到拓展开放修改封闭这一准则结合案例说一下如何实现

01.前沿简单介绍

• 学习 SOLID 中的第二个原则开闭原则。个人觉得开闭原则是 SOLID 中最难理解、最难掌握同时也是最有用的一条原则。
• 之所以说这条原则难理解那是因为“怎样的代码改动才被定义为‘扩展’怎样的代码改动才被定义为‘修改’怎么才算满足或违反‘开闭原则’修改代码就一定意味着违反‘开闭原则’吗”等等这些问题都比较难理解。
• 之所以说这条原则难掌握那是因为“如何做到‘对扩展开放、修改关闭’如何在项目中灵活地应用‘开闭原则’以避免在追求扩展性的同时影响到代码的可读性”等等这些问题都比较难掌握。
• 之所以说这条原则最有用那是因为扩展性是代码质量最重要的衡量标准之一。在 23 种经典设计模式中大部分设计模式都是为了解决代码的扩展性问题而存在的主要遵从的设计原则就是开闭原则。

02.如何理解开闭原则

• 开闭原则的英文全称是 Open Closed Principle简写为 OCP。它的英文描述是software entities (modules, classes, functions, etc.) should be open for extension , but closed for modification。我们把它翻译成中文就是软件实体模块、类、方法等应该“对扩展开放、对修改关闭”。
  • 这个描述比较简略如果我们详细表述一下那就是添加一个新的功能应该是在已有代码基础上扩展代码新增模块、类、方法等而非修改已有代码修改模块、类、方法等。

03.举一个原始的例子

• 为了让你更好地理解这个原则我举一个例子来进一步解释一下。这是一段 API 接口监控告警的代码。
  • 其中AlertRule 存储告警规则可以自由设置。Notification 是告警通知类支持邮件、短信、微信、手机等多种通知渠道。NotificationEmergencyLevel 表示通知的紧急程度包括 SEVERE严重、URGENCY紧急、NORMAL普通、TRIVIAL无关紧要不同的紧急程度对应不同的发送渠道。关于 API 接口监控告警这部分更加详细的业务需求分析和设计我们会在后面的设计模式模块再拿出来进一步讲解这里你只要简单知道这些就够我们今天用了。

  public class Alert {
    private AlertRule rule;
    private Notification notification;
  
    public Alert(AlertRule rule, Notification notification) {
      this.rule = rule;
      this.notification = notification;
    }
  
    public void check(String api, long requestCount, long errorCount, long durationOfSeconds) {
      long tps = requestCount / durationOfSeconds;
      if (tps > rule.getMatchedRule(api).getMaxTps()) {
        notification.notify(NotificationEmergencyLevel.URGENCY, "...");
      }
      if (errorCount > rule.getMatchedRule(api).getMaxErrorCount()) {
        notification.notify(NotificationEmergencyLevel.SEVERE, "...");
      }
    }
  }
  

• 上面这段代码非常简单业务逻辑主要集中在 check() 函数中。当接口的 TPS 超过某个预先设置的最大值时以及当接口请求出错数大于某个最大允许值时就会触发告警通知接口的相关负责人或者团队。
• 现在如果我们需要添加一个功能当每秒钟接口超时请求个数超过某个预先设置的最大阈值时我们也要触发告警发送通知。这个时候我们该如何改动代码呢主要的改动有两处第一处是修改 check() 函数的入参添加一个新的统计数据 timeoutCount表示超时接口请求数第二处是在 check() 函数中添加新的告警逻辑。具体的代码改动如下所示

  public class Alert {
    // ...省略AlertRule/Notification属性和构造函数...
    
    // 改动一添加参数timeoutCount
    public void check(String api, long requestCount, long errorCount, long timeoutCount, long durationOfSeconds) {
      long tps = requestCount / durationOfSeconds;
      if (tps > rule.getMatchedRule(api).getMaxTps()) {
        notification.notify(NotificationEmergencyLevel.URGENCY, "...");
      }
      if (errorCount > rule.getMatchedRule(api).getMaxErrorCount()) {
        notification.notify(NotificationEmergencyLevel.SEVERE, "...");
      }
      // 改动二添加接口超时处理逻辑
      long timeoutTps = timeoutCount / durationOfSeconds;
      if (timeoutTps > rule.getMatchedRule(api).getMaxTimeoutTps()) {
        notification.notify(NotificationEmergencyLevel.URGENCY, "...");
      }
    }
  }
  

• 这样的代码修改实际上存在挺多问题的。一方面我们对接口进行了修改这就意味着调用这个接口的代码都要做相应的修改。另一方面修改了 check() 函数相应的单元测试都需要修改关于单元测试的内容我们在重构那部分会详细介绍。

04.修改后的代码

• 上面的代码改动是基于“修改”的方式来实现新功能的。如果我们遵循开闭原则也就是“对扩展开放、对修改关闭”。那如何通过“扩展”的方式来实现同样的功能呢我们先重构一下之前的 Alert 代码让它的扩展性更好一些。重构的内容主要包含两部分
  • 第一部分是将 check() 函数的多个入参封装成 ApiStatInfo 类
  • 第二部分是引入 handler 的概念将 if 判断逻辑分散在各个 handler 中。
• 具体的代码实现如下所示

  public class Alert {
    private List<AlertHandler> alertHandlers = new ArrayList<>();
    
    public void addAlertHandler(AlertHandler alertHandler) {
      this.alertHandlers.add(alertHandler);
    }
  
    public void check(ApiStatInfo apiStatInfo) {
      for (AlertHandler handler : alertHandlers) {
        handler.check(apiStatInfo);
      }
    }
  }
  
  public class ApiStatInfo {//省略constructor/getter/setter方法
    private String api;
    private long requestCount;
    private long errorCount;
    private long durationOfSeconds;
  }
  
  public abstract class AlertHandler {
    protected AlertRule rule;
    protected Notification notification;
    public AlertHandler(AlertRule rule, Notification notification) {
      this.rule = rule;
      this.notification = notification;
    }
    public abstract void check(ApiStatInfo apiStatInfo);
  }
  
  public class TpsAlertHandler extends AlertHandler {
    public TpsAlertHandler(AlertRule rule, Notification notification) {
      super(rule, notification);
    }
  
    @Override
    public void check(ApiStatInfo apiStatInfo) {
      long tps = apiStatInfo.getRequestCount()/ apiStatInfo.getDurationOfSeconds();
      if (tps > rule.getMatchedRule(apiStatInfo.getApi()).getMaxTps()) {
        notification.notify(NotificationEmergencyLevel.URGENCY, "...");
      }
    }
  }
  
  public class ErrorAlertHandler extends AlertHandler {
    public ErrorAlertHandler(AlertRule rule, Notification notification){
      super(rule, notification);
    }
  
    @Override
    public void check(ApiStatInfo apiStatInfo) {
      if (apiStatInfo.getErrorCount() > rule.getMatchedRule(apiStatInfo.getApi()).getMaxErrorCount()) {
        notification.notify(NotificationEmergencyLevel.SEVERE, "...");
      }
    }
  }
  

• 上面的代码是对 Alert 的重构我们再来看下重构之后的 Alert 该如何使用呢具体的使用代码我也写在这里了。其中ApplicationContext 是一个单例类负责 Alert 的创建、组装alertRule 和 notification 的依赖注入、初始化添加 handlers工作。

  public class ApplicationContext {
    private AlertRule alertRule;
    private Notification notification;
    private Alert alert;
    
    public void initializeBeans() {
      alertRule = new AlertRule(/*.省略参数.*/); //省略一些初始化代码
      notification = new Notification(/*.省略参数.*/); //省略一些初始化代码
      alert = new Alert();
      alert.addAlertHandler(new TpsAlertHandler(alertRule, notification));
      alert.addAlertHandler(new ErrorAlertHandler(alertRule, notification));
    }
    public Alert getAlert() { return alert; }
  
    // 饿汉式单例
    private static final ApplicationContext instance = new ApplicationContext();
    private ApplicationContext() {
      instance.initializeBeans();
    }
    public static ApplicationContext getInstance() {
      return instance;
    }
  }
  
  public class Demo {
    public static void main(String[] args) {
      ApiStatInfo apiStatInfo = new ApiStatInfo();
      // ...省略设置apiStatInfo数据值的代码
      ApplicationContext.getInstance().getAlert().check(apiStatInfo);
    }
  }
  

• 现在我们再来看下基于重构之后的代码如果再添加上面讲到的那个新功能每秒钟接口超时请求个数超过某个最大阈值就告警我们又该如何改动代码呢主要的改动有下面四处。
  • 第一处改动是在 ApiStatInfo 类中添加新的属性 timeoutCount。
  • 第二处改动是添加新的 TimeoutAlertHander 类。
  • 第三处改动是在 ApplicationContext 类的 initializeBeans() 方法中往 alert 对象中注册新的 timeoutAlertHandler。
  • 第四处改动是在使用 Alert 类的时候需要给 check() 函数的入参 apiStatInfo 对象设置 timeoutCount 的值。
• 改动之后的代码如下所示

  public class Alert { // 代码未改动... }
  public class ApiStatInfo {//省略constructor/getter/setter方法
    private String api;
    private long requestCount;
    private long errorCount;
    private long durationOfSeconds;
    private long timeoutCount; // 改动一添加新字段
  }
  public abstract class AlertHandler { //代码未改动... }
  public class TpsAlertHandler extends AlertHandler {//代码未改动...}
  public class ErrorAlertHandler extends AlertHandler {//代码未改动...}
  // 改动二添加新的handler
  public class TimeoutAlertHandler extends AlertHandler {//省略代码...}
  
  public class ApplicationContext {
    private AlertRule alertRule;
    private Notification notification;
    private Alert alert;
    
    public void initializeBeans() {
      alertRule = new AlertRule(/*.省略参数.*/); //省略一些初始化代码
      notification = new Notification(/*.省略参数.*/); //省略一些初始化代码
      alert = new Alert();
      alert.addAlertHandler(new TpsAlertHandler(alertRule, notification));
      alert.addAlertHandler(new ErrorAlertHandler(alertRule, notification));
      // 改动三注册handler
      alert.addAlertHandler(new TimeoutAlertHandler(alertRule, notification));
    }
    //...省略其他未改动代码...
  }
  
  public class Demo {
    public static void main(String[] args) {
      ApiStatInfo apiStatInfo = new ApiStatInfo();
      // ...省略apiStatInfo的set字段代码
      apiStatInfo.setTimeoutCount(289); // 改动四设置tiemoutCount值
      ApplicationContext.getInstance().getAlert().check(apiStatInfo);
  }
  

• 重构之后的代码更加灵活和易扩展。如果我们要想添加新的告警逻辑只需要基于扩展的方式创建新的 handler 类即可不需要改动原来的 check() 函数的逻辑。而且我们只需要为新的 handler 类添加单元测试老的单元测试都不会失败也不用修改。

05.修改代码违背原则么

• 看了上面重构之后的代码你可能还会有疑问在添加新的告警逻辑的时候尽管改动二添加新的 handler 类是基于扩展而非修改的方式来完成的但改动一、三、四貌似不是基于扩展而是基于修改的方式来完成的那改动一、三、四不就违背了开闭原则吗
• 我们先来分析一下改动一往 ApiStatInfo 类中添加新的属性 timeoutCount。
  • 实际上我们不仅往 ApiStatInfo 类中添加了属性还添加了对应的 getter/setter 方法。那这个问题就转化为给类中添加新的属性和方法算作“修改”还是“扩展”
  • 我们再一块回忆一下开闭原则的定义软件实体模块、类、方法等应该“对扩展开放、对修改关闭”。从定义中我们可以看出开闭原则可以应用在不同粒度的代码中可以是模块也可以类还可以是方法及其属性。同样一个代码改动在粗代码粒度下被认定为“修改”在细代码粒度下又可以被认定为“扩展”。比如改动一添加属性和方法相当于修改类在类这个层面这个代码改动可以被认定为“修改”但这个代码改动并没有修改已有的属性和方法在方法及其属性这一层面它又可以被认定为“扩展”。
  • 实际上我们也没必要纠结某个代码改动是“修改”还是“扩展”更没必要太纠结它是否违反“开闭原则”。我们回到这条原则的设计初衷只要它没有破坏原有的代码的正常运行没有破坏原有的单元测试我们就可以说这是一个合格的代码改动。
• 我们再来分析一下改动三和改动四在 ApplicationContext 类的 initializeBeans() 方法中往 alert 对象中注册新的 timeoutAlertHandler在使用 Alert 类的时候需要给 check() 函数的入参 apiStatInfo 对象设置 timeoutCount 的值。
  • 这两处改动都是在方法内部进行的不管从哪个层面模块、类、方法来讲都不能算是“扩展”而是地地道道的“修改”。不过有些修改是在所难免的是可以被接受的。为什么这么说呢
  • 在重构之后的 Alert 代码中我们的核心逻辑集中在 Alert 类及其各个 handler 中当我们在添加新的告警逻辑的时候Alert 类完全不需要修改而只需要扩展一个新 handler 类。如果我们把 Alert 类及各个 handler 类合起来看作一个“模块”那模块本身在添加新的功能的时候完全满足开闭原则。
  • 而且我们要认识到添加一个新功能不可能任何模块、类、方法的代码都不“修改”这个是做不到的。类需要创建、组装、并且做一些初始化操作才能构建成可运行的的程序这部分代码的修改是在所难免的。我们要做的是尽量让修改操作更集中、更少、更上层尽量让最核心、最复杂的那部分逻辑代码满足开闭原则。

06.如何做到开闭原则

• 在刚刚的例子中我们通过引入一组 handler 的方式来实现支持开闭原则。如果你没有太多复杂代码的设计和开发经验你可能会有这样的疑问这样的代码设计思路怎么想不到呢你是怎么想到的呢
• 先给你个结论之所以我能想到靠的就是理论知识和实战经验这些需要你慢慢学习和积累。对于如何做到“对扩展开放、修改关闭”我们也有一些指导思想和具体的方法论我们一块来看一下。实际上开闭原则讲的就是代码的扩展性问题是判断一段代码是否易扩展的“金标准”。如果某段代码在应对未来需求变化的时候能够做到“对扩展开放、对修改关闭”那就说明这段代码的扩展性比较好。
• 在讲具体的方法论之前我们先来看一些更加偏向顶层的指导思想。为了尽量写出扩展性好的代码我们要时刻具备扩展意识、抽象意识、封装意识。这些“潜意识”可能比任何开发技巧都重要。
  • 在写代码的时候后我们要多花点时间往前多思考一下这段代码未来可能有哪些需求变更、如何设计代码结构事先留好扩展点以便在未来需求变更的时候不需要改动代码整体结构、做到最小代码改动的情况下新的代码能够很灵活地插入到扩展点上做到“对扩展开放、对修改关闭”。
  • 在识别出代码可变部分和不可变部分之后我们要将可变部分封装起来隔离变化提供抽象化的不可变接口给上层系统使用。当具体的实现发生变化的时候我们只需要基于相同的抽象接口扩展一个新的实现替换掉老的实现即可上游系统的代码几乎不需要修改。
• 讲了实现开闭原则的一些偏向顶层的指导思想现在我们再来看下支持开闭原则的一些更加具体的方法论。
  • 代码的扩展性是代码质量评判的最重要的标准之一。实际上我们整个专栏的大部分知识点都是围绕扩展性问题来讲解的。专栏中讲到的很多设计原则、设计思想、设计模式都是以提高代码的扩展性为最终目的的。特别是 23 种经典设计模式大部分都是为了解决代码的扩展性问题而总结出来的都是以开闭原则为指导原则的。
  • 今天我重点讲一下如何利用多态、依赖注入、基于接口而非实现编程来实现“对扩展开放、对修改关闭”。实际上多态、依赖注入、基于接口而非实现编程以及前面提到的抽象意识说的都是同一种设计思路只是从不同的角度、不同的层面来阐述而已。这也体现了“很多设计原则、思想、模式都是相通的”这一思想。
• 接下来我就通过一个例子来解释一下如何利用这几个设计思想或原则来实现“对扩展开放、对修改关闭”。
  • 注意依赖注入后面会讲到如果你对这块不了解可以暂时先忽略这个概念只关注多态、基于接口而非实现编程以及抽象意识。
  • 比如我们代码中通过 Kafka 来发送异步消息。对于这样一个功能的开发我们要学会将其抽象成一组跟具体消息队列Kafka无关的异步消息接口。所有上层系统都依赖这组抽象的接口编程并且通过依赖注入的方式来调用。当我们要替换新的消息队列的时候比如将 Kafka 替换成 RocketMQ可以很方便地拔掉老的消息队列实现插入新的消息队列实现。具体代码如下所示

  // 这一部分体现了抽象意识
  public interface MessageQueue { //... }
  public class KafkaMessageQueue implements MessageQueue { //... }
  public class RocketMQMessageQueue implements MessageQueue {//...}
  
  public interface MessageFormatter { //... }
  public class JsonMessageFormatter implements MessageFormatter {//...}
  public class MessageFormatter implements MessageFormatter {//...}
  
  public class Demo {
    private MessageQueue msgQueue; // 基于接口而非实现编程
    public Demo(MessageQueue msgQueue) { // 依赖注入
      this.msgQueue = msgQueue;
    }
    
    // msgFormatter多态、依赖注入
    public void sendNotification(Notification notification, MessageFormatter msgFormatter) {
      //...    
    }
  }
  

07.如何运用开闭原则

• 如果你开发的是一个业务导向的系统比如金融系统、电商系统、物流系统等要想识别出尽可能多的扩展点就要对业务有足够的了解能够知道当下以及未来可能要支持的业务需求。如果你开发的是跟业务无关的、通用的、偏底层的系统比如框架、组件、类库你需要了解“它们会被如何使用今后你打算添加哪些功能使用者未来会有哪些更多的功能需求”等问题。
• 不过有一句话说得好“唯一不变的只有变化本身”。即便我们对业务、对系统有足够的了解那也不可能识别出所有的扩展点即便你能识别出所有的扩展点为这些地方都预留扩展点这样做的成本也是不可接受的。我们没必要为一些遥远的、不一定发生的需求去提前买单做过度设计。
• 最合理的做法是对于一些比较确定的、短期内可能就会扩展或者需求改动对代码结构影响比较大的情况或者实现成本不高的扩展点在编写代码的时候之后我们就可以事先做些扩展性设计。但对于一些不确定未来是否要支持的需求或者实现起来比较复杂的扩展点我们可以等到有需求驱动的时候再通过重构代码的方式来支持扩展的需求。
• 而且开闭原则也并不是免费的。有些情况下代码的扩展性会跟可读性相冲突。比如我们之前举的 Alert 告警的例子。为了更好地支持扩展性我们对代码进行了重构重构之后的代码要比之前的代码复杂很多理解起来也更加有难度。很多时候我们都需要在扩展性和可读性之间做权衡。在某些场景下代码的扩展性很重要我们就可以适当地牺牲一些代码的可读性在另一些场景下代码的可读性更加重要那我们就适当地牺牲一些代码的可扩展性。
• 之前举的 Alert 告警的例子中如果告警规则并不是很多、也不复杂那 check() 函数中的 if 语句就不会很多代码逻辑也不复杂代码行数也不多那最初的第一种代码实现思路简单易读就是比较合理的选择。相反如果告警规则很多、很复杂check() 函数的 if 语句、代码逻辑就会很多、很复杂相应的代码行数也会很多可读性、可维护性就会变差那重构之后的第二种代码实现思路就是更加合理的选择了。总之这里没有一个放之四海而皆准的参考标准全凭实际的应用场景来决定。

08.总结一下内容

• 1.如何理解“对扩展开放、对修改关闭”
  • 添加一个新的功能应该是通过在已有代码基础上扩展代码新增模块、类、方法、属性等而非修改已有代码修改模块、类、方法、属性等的方式来完成。关于定义我们有两点要注意。第一点是开闭原则并不是说完全杜绝修改而是以最小的修改代码的代价来完成新功能的开发。第二点是同样的代码改动在粗代码粒度下可能被认定为“修改”在细代码粒度下可能又被认定为“扩展”。
• 2.如何做到“对扩展开放、修改关闭”
  • 我们要时刻具备扩展意识、抽象意识、封装意识。在写代码的时候我们要多花点时间思考一下这段代码未来可能有哪些需求变更如何设计代码结构事先留好扩展点以便在未来需求变更的时候在不改动代码整体结构、做到最小代码改动的情况下将新的代码灵活地插入到扩展点上。
• 3.学习设计原则要多问个为什么。
  • 不能把设计原则当真理而是要理解设计原则背后的思想。搞清楚这个比单纯理解原则讲的是啥更能让你灵活应用原则。

09.实践案例分析

• 将不同对象分类的服务方法进行抽象把业务逻辑的紧耦合关系拆开实现代码的隔离保证了方便的扩展
• 看看下面这段代码改编某伟大公司产品代码你觉得可以利用面向对象设计原则如何改进

  public class VIPCenter {
      void serviceVIP(T extend User user>) {
       if (user instanceof SlumDogVIP) {
          // 穷 X VIP活动抢的那种
          // do somthing
        } else if(user instanceof RealVIP) {
          // do somthing
        }
        // ...
  }
  

  • 这段代码的一个问题是业务逻辑集中在一起当出现新的用户类型时比如大数据发现了我们是肥羊需要去收获一下 这就需要直接去修改服务方法代码实现这可能会意外影响不相关的某个用户类型逻辑。
  • 利用开关原则可以尝试改造为下面的代码。将不同对象分类的服务方法进行抽象把业务逻辑的紧耦合关系拆开实现代码的隔离保证了方便的扩展。技术博客大总结

  public class VIPCenter {
      private Map<User.TYPE, ServiceProvider> providers;
      void serviceVIP(T extend User user {
          providers.get(user.getType()).service(user);
      }
  }
  
  interface ServiceProvider{
      void service(T extend User user) ;
  }
  
  class SlumDogVIPServiceProvider implements ServiceProvider{
      void service(T extend User user){
          // do somthing
      }
  }
  
  class RealVIPServiceProvider implements ServiceProvider{
      void service(T extend User user) {
          // do something
      }
  }
  

开源项目https://github.com/yangchong211/YCAppTool

开源博客https://github.com/yangchong211/YCBlogs