腾讯大佬总结的代码重构原则，看完再也不怕面试官问啦！

前言

上一篇开闭原则最有用的代码改动是基于 “修改” 的方式来实现新功能的。如果我们遵循开闭原则，也就是 “对扩展开放、对修改关闭”。那如何通过 “扩展” 的方式，来实现同样的功能呢？

重构

我们先重构一下之前的 Alert 代码，让它的扩展性更好一些。重构的内容主要包含两部分：

1. 第一部分是将 check () 函数的多个入参封装成 ApiStatInfo 类；

2. 第二部分是引入 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);

  }

}

现在，我们再来看下，基于重构之后的代码，如果再添加上面讲到的那个新功能，每秒钟接口超时请求个数超过某个最大阈值就告警，我们又该如何改动代码呢？主要的改动有下面四处。

1. 第一处改动是：在 ApiStatInfo 类中添加新的属性 timeoutCount。
2. 第二处改动是：添加新的 TimeoutAlertHander 类。
3. 第三处改动是：在 ApplicationContext 类的 initializeBeans () 方法中，往 alert 对象中注册新的 timeoutAlertHandler。
4. 第四处改动是：在使用 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 类添加单元测试，老的单元测试都不会失败，也不用修改。

重点回顾

如何理解 “对扩展开放、对修改关闭”？

添加一个新的功能，应该是通过在已有代码基础上扩展代码（新增模块、类、方法、属性等），而非修改已有代码（修改模块、类、方法、属性等）的方式来完成。关于定义，我们有两点要注意。第一点是，开闭原则并不是说完全杜绝修改，而是以最小的修改代码的代价来完成新功能的开发。第二点是，同样的代码改动，在粗代码粒度下，可能被认定为 “修改”；在细代码粒度下，可能又被认定为 “扩展”。

更多java原创阅读：https://javawu.com