【23种设计模式】接口隔离原则
个人主页：金鳞踏雨
个人简介：大家好，我是金鳞，一个初出茅庐的Java小白
目前状况：22届普通本科毕业生，几经波折了，现在任职于一家国内大型知名日化公司，从事Java开发工作
我的博客：这里是CSDN，是我学习技术，总结知识的地方。希望和各位大佬交流，共同进步 ~
本文来自抖音《IT楠老师》设计模式课程，下面是本人结合原课件的一些学习心得。
一、原理概述
客户端不应该强迫依赖它不需要的接口。
前面我提到，理解接口隔离原则的关键，就是理解其中的"接口"二字。
- 一组 API 接口集合
- 单个 API 接口或函数
- OOP 中的接口概念
客户端不应该强迫依赖它不需要的接口。
接口隔离原则要求我们将大的、臃肿的接口拆分成更小、更专注的接口，以确保类之间的解耦。这样，客户端只需要依赖它实际使用的接口，而不需要依赖那些无关的接口。
接口隔离原则有以下几个要点：
- 将一个大的、通用的接口拆分成多个专用的接口。这样可以降低类之间的耦合度，提高代码的可维护性和可读性。
- 为每个接口定义一个独立的职责。这样可以确保接口的粒度适当，同时也有助于遵循单一职责原则。
- 在定义接口时，要考虑到客户端的实际需求。客户端不应该被迫实现无关的接口方法。
二、经典案例
1. 案例一
假设我们正在开发一个机器人程序，机器人具有多种功能，如行走、飞行和工作。我们可以为这些功能创建一个统一的接口：
public interface Robot {
void walk();
void fly();
void work();
}然而，这个接口并不符合接口隔离原则！因为它将多个功能聚合在了一个接口中。
对于那些只需要实现部分功能的客户端来说，这个接口会导致不必要的依赖。为了遵循接口隔离原则，我们应该将这个接口拆分成多个更小、更专注的接口。（或者可以形象一点的说，并不是所有的机器人都会飞！）
public interface Walkable {
void walk();
}
public interface Flyable {
void fly();
}
public interface Workable {
void work();
}现在，我们可以根据需要为不同类型的机器人实现不同的接口。
例如，对于一个只能行走和工作的机器人，我们只需要实现Walkable和Workable接口：
public class WalkingWorkerRobot implements Walkable, Workable {
@Override
public void walk() {
// 实现行走功能
}
@Override
public void work() {
// 实现工作功能
}
}通过遵循接口隔离原则，我们确保了代码的可维护性和可读性，同时也降低了类之间的耦合度。在实际项目中，要根据需求和场景来判断何时应用接口隔离原则。
接口隔离原则的关键是确保接口的职责清晰且单一，但是这个"单一"又并非是只有一个的意思，是相对的，依托于实际的业务场景。
2. 案例二
我们还是结合一个例子来讲解。
微服务用户系统提供了一组跟用户相关的 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 {
//...
}现在，我们的后台管理系统要实现删除用户的功能，希望用户系统提供一个删除用户的接口。这个时候我们该如何来做呢？你可能会说，这不是很简单吗，我只需要在 UserService 中新添加一个 deleteUserByCellphone() 或 deleteUserById() 接口就可以了。这个方法可以解决问题，但是也隐藏了一些安全隐患。
删除用户是一个非常慎重的操作，我们只希望通过后台管理系统来执行，所以这个接口只限于给后台管理系统使用。如果我们把它放到 UserService 中，那所有使用到 UserService 的系统，都可以调用这个接口。不加限制地被其他业务系统调用，就有可能导致误删用户。
当然，最好的解决方案是从架构设计的层面，通过接口鉴权的方式来限制接口的调用。不过，如果暂时没有鉴权框架来支持，我们还可以从代码设计的层面，尽量避免接口被误用。我们参照接口隔离原则，调用者不应该强迫依赖它不需要的接口，将删除接口单独放到另外一个接口 RestrictedUserService 中，然后将 RestrictedUserService 只打包提供给后台管理系统来使用。具体的代码实现如下所示：
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 {
// ... 省略实现代码...
}将 UserService 与 RestrictedUserService 接口隔离开来，避免误调用删除的方法。
3. 案例三
假设我们的项目中用到了三个外部系统：Redis、MySQL、Kafka。每个系统都对应一系列配置信息，比如地址、端口、访问超时时间等。为了在内存中存储这些配置信息，供项目中的其他模块来使用，我们分别设计实现了三个 Configuration 类：RedisConfig、MysqlConfig、KafkaConfig。
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 的配置信息进行热更新。
所谓“热更新（hot update）”就是，如果在配置中心中更改了配置信息，我们希望在不用重启系统的情况下，能将最新的配置信息加载到内存中（也就是 RedisConfig、KafkaConfig 类中）。
为了实现这样一个功能需求，我们设计实现了一个 ScheduledUpdater 类，以固定时间频率（periodInSeconds）来调用 RedisConfig、KafkaConfig 的 update() 方法更新配置信息。具体的代码实现如下所示：
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);
redisConfigUpdater.run();
}
}刚刚的热更新的需求我们已经搞定了。
现在，我们又有了一个新的监控功能需求。通过命令行来查看 Zookeeper 中的配置信息是比较麻烦的。所以，我们希望能有一种更加方便的配置信息查看方式。
我们可以在项目中开发一个内嵌的 SimpleHttpServer，输出项目的配置信息到一个固定的 HTTP 地址，我们只需要在浏览器中输入这个地址，就可以显示出系统的配置信息。不过，出于某些原因，我们只想暴露 MySQL 和 Redis 的配置信息，不想暴露 Kafka 的配置信息。
为了实现这样一个功能，我们还需要对上面的代码做进一步改造。
改造之后的代码如下所示：
public interface Updater {
void update();
}
public interface Viewer {
String outputInPlainText();
Map output();
}
public class RedisConfig implemets Updater, Viewer {
//... 省略其他属性和方法...
@Override
public void update() { //...
}
@Override
public String outputInPlainText() { //...
}
@Override
public Map output() { //...
}
}
public class KafkaConfig implements Updater {
//... 省略其他属性和方法...
@Override
public void update() { //...
}
}
public class MysqlConfig implements Viewer {
//... 省略其他属性和方法...
@Override
public String outputInPlainText() { //...
}
@Override
public Map output() { //...
}
}
public class SimpleHttpServer {
private String host;
private int port;
private Map> 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());
}
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 接口，也满足接口隔离原则。
4. 提问：getAndIncrement()是否满足接口隔离原则？
java.util.concurrent 并发包提供了 AtomicInteger 这样一个原子类，其中有一个函数 getAndIncrement() 是这样定义的：给整数增加一，并且返回未増之前的值。我的问题是，这个函数的设计是否符合单一职责原则和接口隔离原则？为什么？
/**
* Atomically increments by one the current value.
* @return the previous value
*/
public final int getAndIncrement() {//...}这个方法是为了解决多线程场景下的线程安全问题，如果我们将其拆分成 get() 和 increment() 显然是不能解决这个问题的，所以脱离业务讲设计都是刷流氓！！！
文章到这里就结束了，如果有什么疑问的地方，可以在评论区指出~
希望能和大佬们一起努力，诸君顶峰相见
再次感谢各位小伙伴儿们的支持！！！