SOLID：SOLID 原则并非单纯的1个原则，而是由5个设计原则组成，它们分别是：单一职责原则、开闭原则、里式替换原则、接口隔离原则和依赖反转原则，SOLID 由5个设计原则的头一个字母组成。
如何理解接口隔离原则？
接口隔离原则（Interface Segregation Principle，ISP），Robert Martin 在 SOLID 原则中这样定义它：
Clients should not be forced to depend upon interfaces that they do not use
客户端不应该被强迫依赖它不需要的接口
其中的 “客户端”，可以理解为接口的调用者或者使用者。
理解接口隔离原则的关键，在于理解 “接口” 二字。在这条原则中，我们可以把 “接口” 理解为下面三种东西：
-
一组API接口集合
-
单个API接口或函数
-
OOP中的接口概念
把 “接口” 理解为一组API接口集合
我们还是结合一个例子来讲解。微服务用户系统提供了一组跟用户相关的API给其他系统使用，比如：注册、登陆、获取用户信息等。
public interface UserService {
boolean register(String cellphone, String password);
boolean login(String cellphone, String password);
UserInfo getUserInfoById(long id);
UserInfo getUserInfoByCellphone(String cellphone);
}
public class UserServiceImpl implements UserService {
// ...
}
现在，我们的后台管理系统要实现删除用户的功能，希望 UserSerivce 提供一个删除用户的接口。
你可能会想，这不是很简单吗，只需要在 UserService 中新添加一个 deleteUserByCellphone() 或 deleteUserById() 接口就可以了。这种方式虽然可以，但也隐藏了一些安全隐患：将删除用户的接口放在 UserSerivce，那其他使用到 UserSerivce 的系统都可以调用这个接口，有可能会被误删用户。我们只希望后台管理系统有删除用户的权限。
最好的解决方案是从架构设计层面，通过接口鉴权的方式来限制接口的调用；不过，如果暂时没有鉴权框架来支持，也可以从代码设计层面，尽量避免接口被误用。
参照接口隔离原则，调用者不应该强迫依赖它不需要的接口，我们单独提供只有删除接口的 RestrictedUserService 给后台管理系统使用：
public interface RestrictedUserSerivce {
boolean deleteUserByCellphone(String cellphone);
boolean deleteUserById(long id);
}
public class UserServiceImpl implements UserService, RestrictedUserService {
// ...省略实现代码...
}
在这个例子中，我们把接口隔离原则中的 “接口”，理解为一组接口的集合，它可以是某个微服务的接口，也可以是某个类库的接口等等。
如果部分接口只被部分调用者使用，那我们就需要将这部分接口隔离出来，单独给对应的调用者使用，而不是强迫其他调用者也依赖这部分不会被用到的接口。
把 “接口” 理解为单个API接口或函数
把 “接口” 理解为单个接口或函数，那接口隔离原则可以理解为：函数的设计要功能单一，不要将多个不同的功能逻辑在一个函数中实现，把函数拆分成粒度更细的多个函数，让调用者只依赖它需要的那个细粒度函数。
还是通过一个例子来解释一下。
public class Statistics {
private Long max;
private Long min;
private Long average;
private Long sum;
// ...省略constructor/getter/setter等方法...
}
public Statistics count(Collection<Long> dataSet) {
Statistics statistics = new Statistics();
// ...省略计算逻辑...
return statistics;
}
上面有四类统计信息分别是 max、min、average、sum，上面的代码是将所有统计处理的逻辑都放在了 count()，在不同的场景中 count() 的功能可能不够单一。按照接口隔离原则，我们应该把 count() 拆分成几个更小粒度的函数，每个函数负责一个独立的统计功能：
public Long max(Collection<Long> dataSet) { //... }
public Long min(Collection<Long> dataSet) { //... }
public Long average(Collection<Long> dataSet) { //... }
// ...其他统计函数...
是否要将 count() 进行拆分还是要根据不同的场景需求，比如有些场景需求就是需要同时统计 max、min、average 等，那 count() 不拆分是合理的；有些场景只需要一部分统计信息 max、min 即可，那应该将 count() 进行拆分。
你应该已经返现，接口隔离原则跟单一职责原则有点类似，不过稍微有点区别：单一职责原则针对的是模块、类、接口的设计。接口隔离原则相对于单一职责原则，一方面它更侧重于接口的设计，另一方面它的思考角度不同。它提供了一种判断接口是否职责单一的标准：通过调用者如何使用接口来间接地判定。如果调用者只使用部分接口或接口的部分功能，那接口的设计就不够职责单一。
把 “接口” 理解为 OOP 中的接口概念
把 “接口” 理解为 OOP 中的接口概念，那接口隔离原则可以理解为：接口的设计要尽量单一，不要让接口的实现类和调用者，依赖不需要的接口函数。
还是用一个例子解释一下。
项目中用到了三个外部系统：Redis、MySQL、Kafka。每个系统对应一系列配置信息，比u地址、端口、访问超时时间等。为了在内存中存储这些配置信息，供项目中的其他模块来使用，我们分别设计了三个 Configuration 类：RedisConfig、MysqlConfig、KafkaConfig。
public class RedisConfig {
private ConfigSource configSource;
private String address;
private int timeout;
private int maxTotal;
// ...省略其他配置...
public RedisConfig(ConfigSource configSource) {
this.configSource = configSource;
}
// ... 其他配置方法...
}
public class MysqlConfig { //... }
public class KafkaConfig { //... }
现在有一个新的功能需求，希望支持 Redis 和 Kafka 配置信息的热更新，就是在配置中心中更改了配置信息，我们希望不用重启系统的情况下，能将最新的配置信息加载到内存中（也就是 RedisConfig、KafkaConfig 类中），不希望 MySQL 的配置信息进行热更新。
我们设计了一个 ScheduledUpdater 类，以固定时间频率来调用 RedisConfig、KafkaConfig 的 update() 更新配置信息。
public interface Updater {
void update();
}
public class RedisConfig implements Updater {
// ...省略其他属性和方法...
@Override
public void update() { //... }
}
public class KafkaConfig implements Updater {
// ...省略其他属性和方法...
@Override
public void update() { //... }
}
public class ScheduledUpdater {
private final ScheduledExecutorService executor = new Executors.newSingleThreadScheduledExecutor();
private long initialDelayInSeconds;
private long periodInSeconds;
private Updater updater;
pulbic 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();
}
}, initialDelayInSeconds, periodInSeconds, TimeUnit.SECONDS);
}
}
public class Application {
ConfigSource configSource = new ZookeeperConfigSource(/*省略参数*/);
public static final RedisConfig redisConfig = new RedisConfig(configSource);
public static final KafkaConfig kafkaConfig = new KafkaConfig(configSource);
public static final MysqlConfig mysqlConfig = new MySqlConfig(configSource);
public static void main(String[] args) {
ScheduledUpdater regisConfigUpdater = new ScheduledUpdater(redisConfig, 300, 300);
redisConfigUpdater.run();
ScheduledUpdater kafkaConfigUpdater = new ScheduledUpdater(kafkaConfig, 60, 60);
kafkaConfigUpdater.run();
}
}
现在又有一个新需求，添加监控功能。只想 MySQL 和 Redis 暴露配置信息，不想暴露 Kafka 的配置信息。
public interface Viewer {
//...
}
public class RedisConfig implements Updater, Viewer {
//...
}
public class MysqlConfig implements Updater, Viewer {
//...
}
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) { //... }
public void run() { //... }
}
public class Application {
//...
public static void main(String[] args) {
SimpleHttpServer simpleHttpServer = new SimpleHttpServer(/*省略参数*/);
simpleHttpServer.addViewer("/config", redisConfig);
simpleHttpServer.addViewer("/config", mysqlConfig);
simpleHttpServer.run();
}
}
至此，热更新和监控的需求我们就都实现了。回顾一下这个例子的设计思想。
我么设计了两个功能非常单一的接口：Updater 和 Viewer。ScheduledUpdater 只依赖 Updater 这个跟热更新相关的接口，不需要被强迫去依赖不需要的 Viewer 接口，满足接口隔离原则。同理，SimpleHttpServer 只依赖跟查看信息相关的 Viewer 接口，不依赖不需要的 Updater 接口，也满足接口隔离原则。
或许你会想：为什么不提供一个 Config 接口即有 Updater 接口又有 Viewer 接口，只需要实现一个 Config 接口就行了。
这样的设计思路也是能正常工作的，但是细粒度和功能单一的接口设计思想会更好，主要有两点原因：
-
更加灵活、易扩展、易复用。后续有一个
Metrics性能统计模块，希望将 Metrics 也通过 SimpleHttpServer 显示，尽管 Metrics 和 RedisConfig 等没有任何关系，但我们仍然可以让 Metrics 实现非常通用的 Viewer 接口，复用 SimpleHttpServer 的代码实现 -
统一放在一个 Config 接口中在代码是线上做了一些无用功。RedisConfig、KafkaConfig、MysqlConfig 必须实现 Config 的所有接口，而这些接口中有一些并不需要，而且后续在 Config 添加一个新的接口，那所有的实现类都要改动
总结
如何理解接口隔离原则？
主要在于接口隔离原则中对 “接口” 的理解和解释，主要有三个：
1、一组API接口集合
不要将不需要的接口强迫提供给其他调用者，而是应该将这部分接口单独隔离提供接口出来。
2、单个API接口或函数
函数的设计要功能单一，将不同功能的逻辑拆分成更细粒度的多个函数，让调用者只依赖它需要的那个函数。
此时的接口隔离原则和单一职责的关系是子集关系，即单一职责原则包含接口隔离原则。
与单一职责原则的区别在于，单一职责原则针对的是模块、类、接口的设计；而接口隔离原则一方面它更侧重于接口的设计，另一方面它的思考角度不同，它提供了一种判断接口是否职责单一的标准。
3、OOP中的接口概念
接口的设计要尽量单一，不要让接口的实现类和调用者，依赖不需要的接口函数。
扫一扫
785
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
