OOD&OOP-接口隔离原则

接口隔离原则

接口隔离原则：Clients should not be forced to depend upon interfaces that they do not use。客户端不应该强迫依赖它不需要的接口。其中的“客户端”，可以理解为接口的调用者或者使用者。

理解接口隔离原则的关键，就是理解其中的“接口”二字。在这条原则中，我们可以把“接口”理解为下面三种东西：

一组 API 接口集合
单个 API 接口或函数
OOP 中的接口概念

接下来，我们就按照这三种理解方式来详细分析，在不同的场景下，这条原则具体是如何解读和应用的。

把“接口”理解为一组 API 接口集合

微服务用户系统提供了一组跟用户相关的 API 给其他系统使用，比如：注册、登录、获取用户信息等。具体代码如下所示：

class UserInfo;
class UserService
{
public:
	virtual ~UserService();
	virtual void reg(string cellPhone, string password) = 0;
	virtual bool login(string cellPhone, string password) = 0;
	virtual UserInfo getUserInfoById(long id);
	virtual UserInfo getUserInfoByCellPhone(string cellPhone);
};

class UserServiceImpl : public UserService
{
	//...
};

现在，我们的后台管理系统要实现删除用户的功能，希望用户系统提供一个删除用户的接口。这个时候我们该如何来做呢？你可能会说，这不是很简单吗，我只需要在 UserService中新添加一个 deleteUserByCellphone() 或 deleteUserById() 接口就可以了。这个方法可以解决问题，但是也隐藏了一些安全隐患。

删除用户是一个非常慎重的操作，我们只希望通过后台管理系统来执行，所以这个接口只限于给后台管理系统使用。如果我们把它放到 UserService 中，那所有使用到 UserService的系统，都可以调用这个接口。不加限制地被其他业务系统调用，就有可能导致误删用户。

当然，最好的解决方案是从架构设计的层面，通过接口鉴权的方式来限制接口的调用。不过，如果暂时没有鉴权框架来支持，我们还可以从代码设计的层面，尽量避免接口被误用。我们参照接口隔离原则，调用者不应该强迫依赖它不需要的接口，将删除接口单独放到另外一个接口 RestrictedUserService 中，然后将 RestrictedUserService 只打包提供给后台管理系统来使用。具体的代码实现如下所示：

class UserInfo;
class UserService
{
public:
	virtual ~UserService();
	virtual void reg(string cellPhone, string password) = 0;
	virtual bool login(string cellPhone, string password) = 0;
	virtual UserInfo getUserInfoById(long id);
	virtual UserInfo getUserInfoByCellPhone(string cellPhone);
};

class RestrictedUserService
{
	virtual bool deleteUserByCellphone(string cellPhone) = 0;
	virtual bool deleteUserById(string id) = 0;
};

class UserServiceImpl : public UserService, RestrictedUserService
{
	//...
};

在刚刚的这个例子中，我们把接口隔离原则中的接口，理解为一组接口集合，它可以是某个微服务的接口，也可以是某个类库的接口等等。在设计微服务或者类库接口的时候，如果部分接口只被部分调用者使用，那我们就需要将这部分接口隔离出来，单独给对应的调用者使用，而不是强迫其他调用者也依赖这部分不会被用到的接口。

把“接口”理解为单个 API 接口或函数

把接口理解为单个接口或函数，那接口隔离原则就可以理解为：函数的设计要功能单一，不要将多个不同的功能逻辑在一个函数中实现。
判定功能是否单一，除了很强的主观性，还需要结合具体的场景，比如说某些需求只会用到函数中一部分信息，就应该将该函数拆分成粒度更细的多个函数。
单一职责和接口隔离的区别：单一职责原则针对的是模块、类、接口的设计。而接口隔离原则相对于单一职责原则，一方面它更侧重于接口的设计，另一方面它的思考的角度不同。它提供了一种判断接口是否职责单一的标准：通过调用者如何使用接口来间接地判定。如果调用者只使用部分接口或接口的部分功能，那接口的设计就不够职责单一。

把“接口”理解为 OOP 中的接口概念

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

class ConfigSource {/*...*/};
class RedisConfig {
private:
	ConfigSource configsource;
	string address;
	int timeout;
	int maxTotal;

public:
	RedisConfig(ConfigSource configsource) {
		configsource = configsource;
	}
	string getAddress()const {
		return address;
	}
	void update() {
		//从 configSource 加载配置到 address / timeout / maxTotal
	}
};
class KafkaConfig {/**/};
class MysqlConfig {/**/};

现在，我们有一个新的功能需求，希望支持 Redis 和 Kafka 配置信息的热更新，但是，因为某些原因，我们并不希望对 MySQL 的配置信息进行热更新。

为了实现这样一个功能需求，我们设计实现了一个 ScheduledUpdater 类，以固定时间频率来调用 RedisConfig、KafkaConfig 的 update() 方法更新配置信息。具体的代码实现如下所示：

class Updater {
	virtual void update() = 0;
	virtual ~Updater() {}
};

class RedisConfig : public Updater{
	/*...*/
public:
	void update()override {
    /*...*/
	}
};
class KafkaConfig : public Updater{
	void update()override {
	/*...*/
	}
};

class ScheduledExecutorService {
	/*...*/
};

class ScheduledUpdater {
private:
	ScheduledExecutorService executor;
	long initialDelayInSeconds;
	long periodInSeconds;
	Updater* updater;
public:
	ScheduledUpdater(Updater* updater, long initialDelayInSeconds, long periodInSeconds) {
		updater = updater;
		initialDelayInSeconds = initialDelayInSeconds;
		periodInSeconds = periodInSeconds;
	}

	void run() {/**/}
};

刚刚的热更新的需求我们已经搞定了。现在，我们又有了一个新的监控功能需求。通过命令行来查看 Zookeeper 中的配置信息是比较麻烦的。所以，我们希望能有一种更加方便的配
置信息查看方式。我们可以在项目中开发一个内嵌的 SimpleHttpServer，输出项目的配置信息到一个固定的HTTP 地址，比如：http://127.0.0.1:2389/config 。我们只需要在浏览器中输入这个地址，就可以显示出系统的配置信息。不过，出于某些原因，我们只想暴露 MySQL 和 Redis的配置信息，不想暴露 Kafka 的配置信息。
这时，与上面的方法 相似，我们可以定义Viewer监控接口（输出配置信息方法output()），并将RedisConfig、MysqlConfig类继承Viewer并实现output()方法，

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

如果我们不遵守接口隔离原则，不设计 Updater 和 Viewer 两个小接口，而是设计一个大而全的 Config 接口，让 RedisConfig、KafkaConfig、MysqlConfig 都实现
这个 Config 接口，并且将原来传递给 ScheduledUpdater 的 Updater 和传递给SimpleHttpServer 的 Viewer，都替换为 Config，哪种设计方法更好？

显然接口隔离的设计方法更好，因为这样的设计思路更加灵活、易扩展、易复用。因为 Updater、Viewer 职责更加单一，单一就意味了通用、复用性好。比如，我们现在又有一个新的需求，开发一个 Metrics性能统计模块，并且希望将 Metrics 也通过 SimpleHttpServer 显示在网页上，以方便查看。这个时候，尽管 Metrics 跟 RedisConfig 等没有任何关系，但我们仍然可以让Metrics 类实现非常通用的 Viewer 接口，复用 SimpleHttpServer 的代码实现。