客驿风尘面，花坐墨痕枝

设计原则04：接口隔离原则（ISP）

如何理解”接口隔离原则“？

接口隔离原则的英文翻译是”Interface Segregation Principle“，Robert Martin 在 SOLID 原则中是这样定义它的：“Clients should not be forced to depend upon interfaces that they do not use。”直译成中文的话就是：**客户端不应该被强迫依赖它不需要的接口。**其中的“客户端”，可以理解为接口的调用者或者使用者。

在这条原则中，接口一般可以理解为：一组API接口集合、单个API接口或函数、OOP中的接口概念。

下面分别针对这三种情况来详细讲解这个原则。

接口是一组API接口或集合

假如现在有一个微服务用户系统，提供了一组和用户相关的API给其他系统使用，比如提供了一个UserService接口，其中包含了注册、登录、获取用户信息等功能。现在后台想要增加一个删除用户的功能，一般来说，我们只需要在这个UserService增加一个函数，提供删除的接口就行了。

这个方法可以解决问题，但是也会带来一些隐患。

我们知道删除用户是一个非常慎重的操作，如果这样设计，在没有鉴权系统的情况下，这个接口有可能会被误用。所有有权限使用UserService的系统都有可以调用这个删除接口，这样不加限制的被使用就有可能导致误删用户。

我们参照接口隔离原则，调用者不应该强迫依赖它不需要的接口，将删除接口单独放在另外的一个接口RestrictedUserService中，然后将RestrictedUserService单独给后台系统使用，具体的代码实现如下所示：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


public interface UserService {
  boolean register(String cellphone, String password);
  boolean login(String cellphone, String password);
  UserInfo getUserInfoById(long id);
  UserInfo getUserInfoByCellphone(String cellphone);
}

public interface RestrictedUserService {
  boolean deleteUserByCellphone(String cellphone);
  boolean deleteUserById(long id);
}

public class UserServiceImpl implements UserService, RestrictedUserService {
  // ...省略实现代码...
}

所以，当接口理解成一组集合接口，在设计微服务或者类库接口时如果部分接口只被部分调用者使用，那我们需要将这部分接口隔离出来，单独给对应的调用者使用，而不是强迫其他调用者也依赖这部分不会用到的接口。

接口是单个API或者函数

如果接口是个函数，那么接口隔离原则就可以理解为：函数的设计要功能单一，不要将多个不同的功能逻辑在一个函数中实现。

这时候，接口隔离原则其实比较类似单一职责原则，不过还是稍微有些区别。单一职责原则针对的是模块、类、接口的设计。而接口隔离原则更侧重于接口的设计，另一方面思考的角度也是不同的，它提供了一种判断接口是否职责单一的标准——通过调用者如何使用接口来判断。如果调用者只使用部分接口或接口的部分功能，那接口的设计就不够职责单一。

把接口理解成OOP中的接口（Interface）

假设我们项目中用到了三个外部系统：Kafka、MySQL和Redis。每个系统都对应一系列配置信息，比如地址、端口、访问超时时间等。为了在内存中存储这些配置信息，供项目中的其他模块使用，我们分别设计了三个Configuration类：RedisConfig、MySQLConfig和KafkaConfig。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


public class RedisConfig {
    private ConfigSource configSource; //配置中心（比如zookeeper）
    private String address;
    private int timeout;
    private int maxTotal;
    //省略其他配置: maxWaitMillis,maxIdle,minIdle...

    public RedisConfig(ConfigSource configSource) {
        this.configSource = configSource;
    }

    public String getAddress() {
        return this.address;
    }
    //...省略其他get()、init()方法...

    public void update() {
      //从configSource加载配置到address/timeout/maxTotal...
    }
}

public class KafkaConfig { //...省略... }
public class MysqlConfig { //...省略... }

现在我们有一个新的功能需求，要求支持Redis和Kafka配置信息的热更新，如果在配置中心更改了配置信息，不需要重启系统就能将更新加载到内存中，但是我们不希望对MySQL的配置信息进行热更新。

为了实现这个功能，我们设计实现了一个ScheduledUpdater，以固定频率来调用RedisConfig和KafkaConfig中的update()方法。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55


public interface Updater {
  void update();
}

public class RedisConfig implemets Updater {
  //...省略其他属性和方法...
  @Override
  public void update() { //... }
}

public class KafkaConfig implements Updater {
  //...省略其他属性和方法...
  @Override
  public void update() { //... }
}

public class MysqlConfig { //...省略其他属性和方法... }

public class ScheduledUpdater {
    private final ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();;
    private long initialDelayInSeconds;
    private long periodInSeconds;
    private Updater updater;

    public ScheduleUpdater(Updater updater, long initialDelayInSeconds, long periodInSeconds) {
        this.updater = updater;
        this.initialDelayInSeconds = initialDelayInSeconds;
        this.periodInSeconds = periodInSeconds;
    }

    public void run() {
        executor.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                updater.update();
            }
        }, this.initialDelayInSeconds, this.periodInSeconds, TimeUnit.SECONDS);
    }
}

public class Application {
  ConfigSource configSource = new ZookeeperConfigSource(/*省略参数*/);
  public static final RedisConfig redisConfig = new RedisConfig(configSource);
  public static final KafkaConfig kafkaConfig = new KakfaConfig(configSource);
  public static final MySqlConfig mysqlConfig = new MysqlConfig(configSource);

  public static void main(String[] args) {
    ScheduledUpdater redisConfigUpdater = new ScheduledUpdater(redisConfig, 300, 300);
    redisConfigUpdater.run();
    
    ScheduledUpdater kafkaConfigUpdater = new ScheduledUpdater(kafkaConfig, 60, 60);
    kafkaConfigUpdater.run();
  }
}

热更新的需求我们已经搞定了，不久之后，又来了一个新的需求，通过命令行来查看Zookeeper中的配置信息是比较麻烦的，所以我们需要有另外一种更加方便的配置信息查看方式。

我们开发了一个内嵌的SimpleHttpServer，输出项目的配置信息到一个固定的HTTP地址，不过出于某些原因，我们不想暴露Kafka的配置信息，只想暴露MySQL和Redis的。

为了实现这个功能，我们对代码进一步做了改造：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72


public interface Updater {
  void update();
}

public interface Viewer {
  String outputInPlainText();
  Map<String, String> output();
}

public class RedisConfig implemets Updater, Viewer {
  //...省略其他属性和方法...
  @Override
  public void update() { //... }
  @Override
  public String outputInPlainText() { //... }
  @Override
  public Map<String, String> output() { //...}
}

public class KafkaConfig implements Updater {
  //...省略其他属性和方法...
  @Override
  public void update() { //... }
}

public class MysqlConfig implements Viewer {
  //...省略其他属性和方法...
  @Override
  public String outputInPlainText() { //... }
  @Override
  public Map<String, String> output() { //...}
}

public class SimpleHttpServer {
  private String host;
  private int port;
  private Map<String, List<Viewer>> viewers = new HashMap<>();
  
  public SimpleHttpServer(String host, int port) {//...}
  
  public void addViewers(String urlDirectory, Viewer viewer) {
    if (!viewers.containsKey(urlDirectory)) {
      viewers.put(urlDirectory, new ArrayList<Viewer>());
    }
    this.viewers.get(urlDirectory).add(viewer);
  }
  
  public void run() { //... }
}

public class Application {
    ConfigSource configSource = new ZookeeperConfigSource();
    public static final RedisConfig redisConfig = new RedisConfig(configSource);
    public static final KafkaConfig kafkaConfig = new KakfaConfig(configSource);
    public static final MySqlConfig mysqlConfig = new MySqlConfig(configSource);
    
    public static void main(String[] args) {
        ScheduledUpdater redisConfigUpdater =
            new ScheduledUpdater(redisConfig, 300, 300);
        redisConfigUpdater.run();
        
        ScheduledUpdater kafkaConfigUpdater =
            new ScheduledUpdater(kafkaConfig, 60, 60);
        redisConfigUpdater.run();
        
        SimpleHttpServer simpleHttpServer = new SimpleHttpServer(“127.0.0.1”, 2389);
        simpleHttpServer.addViewer("/config", redisConfig);
        simpleHttpServer.addViewer("/config", mysqlConfig);
        simpleHttpServer.run();
    }
}

至此，热更新和监控的需求都实现了，我们来回顾一下其设计思想。

我们设计了两个功能非常单一的接口：Updater 和 Viewer。ScheduledUpdater 只依赖 Updater 这个跟热更新相关的接口，不需要被强迫去依赖不需要的 Viewer 接口，满足接口隔离原则。同理，SimpleHttpServer 只依赖跟查看信息相关的 Viewer 接口，不依赖不需要的 Updater 接口，也满足接口隔离原则。

课堂问题

java.util.concurrent 并发包提供了 AtomicInteger 这样一个原子类，其中有一个函数 getAndIncrement() 是这样定义的：给整数增加一，并且返回未増之前的值。我的问题是，这个函数的设计是否符合单一职责原则和接口隔离原则？为什么？

updatedupdated2023-06-032023-06-03
加载评论