7、 不同层次，不同抽象：构建高效软件系统的关键

不同层次，不同抽象：构建高效软件系统的关键

1 引言

软件系统通常由多个层次组成，每个层次依赖于下一层提供的功能。在设计良好的系统中，每一层都提供了不同于其上下层的独特抽象。这意味着，当我们跟踪一个操作在不同层次之间的传递时，每次方法调用都会改变抽象级别。本篇文章将探讨这一原则的重要性，并通过具体例子和策略帮助开发者更好地理解和实践。

2 文件系统与网络传输协议中的抽象层次

2.1 文件系统

文件系统是一个很好的例子，展示了不同层次如何提供不同的抽象。最顶层实现了文件抽象，文件由可变长度的字节数组组成，可以通过读取和写入可变长度的字节范围来更新。下一层实现了内存中的固定大小磁盘块缓存，确保常用块可以快速访问。最低层则是设备驱动程序，负责在辅助存储设备和内存之间移动数据块。

2.2 网络传输协议（如TCP）

在网络传输协议中，最顶层提供了一个可靠的字节流抽象，确保数据从一台机器可靠地传输到另一台。这一层建立在较低层次之上，后者以尽力而为的方式传输有界大小的数据包。大多数数据包将成功传输，但可能会丢失或顺序错乱。

层次	抽象描述
最高层	文件抽象：可变长度的字节数组，支持读写操作
中间层	缓存抽象：内存中的固定大小磁盘块缓存
最底层	设备驱动程序：辅助存储设备和内存之间的数据块移动

3 传递方法的问题及其解决

3.1 传递方法的定义

传递方法（pass-through methods）是指一个方法除了传递参数给另一个方法外几乎不做任何其他操作。这种设计通常表明类之间没有清晰的责任划分。例如，一个GUI文本编辑器项目中的 TextDocument 类几乎完全由传递方法组成。

public class TextDocument {
    private TextArea textArea;
    private TextDocumentListener listener;

    public Character getLastTypedCharacter() {
        return textArea.getLastTypedCharacter();
    }

    public int getCursorOffset() {
        return textArea.getCursorOffset();
    }

    public void insertString(String textToInsert, int offset) {
        textArea.insertString(textToInsert, offset);
    }

    public void willInsertString(String stringToInsert, int offset) {
        if (listener != null) {
            listener.willInsertString(this, stringToInsert, offset);
        }
    }
}

3.2 传递方法的影响

传递方法增加了类的接口复杂性，却没有增加系统的总功能。此外，它们还会在类之间创建依赖关系。例如，如果 TextArea 中的 insertString 方法签名发生变化， TextDocument 中的相应方法也需要更改。

3.3 解决方案

为了解决传递方法带来的问题，可以通过重构类来确保每个类都有一个独特且连贯的责任集。以下是几种重构方法：

1. 直接暴露低级类 ：将低级类直接暴露给高级类的调用者，移除高级类对特性的所有责任。
2. 重新分配功能 ：重新分配类之间的功能，避免类之间的直接调用。
3. 合并类 ：如果类无法解开，最佳解决方案可能是将它们合并。

graph TD;
    A[原始设计] --> B[直接暴露低级类];
    A --> C[重新分配功能];
    A --> D[合并类];

4 何时接口复制是可以接受的

拥有相同签名的方法并不总是坏事，特别是当每个新方法都提供了显著的功能时。例如，调度器（dispatcher）可以基于输入参数选择调用不同的方法，从而提供有用且不同的功能。调度器的签名通常与它调用的方法相同，但它选择哪个方法来执行任务，从而减少了认知负担。

graph TD;
    A[调度器] --> B[选择方法1];
    A --> C[选择方法2];
    A --> D[选择方法3];

5 装饰器模式的应用

装饰器模式通过动态地将责任附加到对象上来增强功能。虽然装饰器模式本身不是本章的重点，但它与不同层次的不同抽象相关，因为它涉及到如何在不同层次间适当地分配职责。装饰器模式允许我们在不改变原有类的前提下，动态地添加行为。

5.1 装饰器模式的优点

• 灵活性 ：可以在运行时动态地添加功能。
• 可维护性 ：避免了类的膨胀，保持了代码的简洁性。

5.2 使用场景

• 日志记录 ：在不改变原有方法的前提下，添加日志记录功能。
• 权限控制 ：在不改变原有方法的前提下，添加权限验证功能。

6 接口与实现的分离

确保接口和实现之间的清晰分离是减少复杂性和依赖的关键。内部表示应与接口中出现的抽象不同。如果两者有相似的抽象，类可能不够深。

6.1 示例：文本编辑器项目

在文本编辑器项目中，大多数团队将文本模块实现为文本行，每行分别存储。一些团队还围绕文本行设计了API，例如 getLine 和 putLine 。然而，这使得文本类浅显且难以使用。在高级用户界面代码中，通常需要在一行文本的中间插入文本或删除跨越多行的文本范围。对于文本类的面向行的API，调用者被迫进行拆分和合并操作，增加了复杂性。

6.2 改进建议

为了简化文本类的使用，可以提供基于字符的API，而不是基于行的API。例如， insertString 方法可以直接在指定位置插入文本，而无需考虑行边界。这使得用户界面代码更加直观和易用。

public class TextDocument {
    private String content;

    public void insertString(String textToInsert, int offset) {
        content = content.substring(0, offset) + textToInsert + content.substring(offset);
    }
}

---

下一部分将继续探讨不同层次的抽象如何影响软件设计，并提供更多的实践建议和代码示例。

7 传递变量的优化

在不同层次之间有效地传递数据的同时保持抽象级别的差异，是软件设计中的一个重要挑战。传递变量的方式直接影响系统的性能和可维护性。以下是几种优化传递变量的方法：

7.1 避免不必要的传递

尽量减少不必要的参数传递，尤其是在跨多个层次时。过多的参数传递不仅增加了代码的复杂性，还可能导致依赖关系的增加。可以通过重构代码，将相关功能合并到同一层，从而减少参数传递的次数。

7.2 使用上下文对象

在某些情况下，可以使用上下文对象来传递多个相关变量。上下文对象可以包含多个属性，减少了方法签名的复杂性。例如，在处理HTTP请求时，可以使用一个 RequestContext 对象来传递请求头、请求体和其他相关信息。

public class RequestContext {
    private Map<String, String> headers;
    private String body;
    // 其他属性和方法
}

public void processRequest(RequestContext context) {
    // 处理请求
}

7.3 使用回调函数

对于需要异步处理的情况，可以使用回调函数来传递结果。回调函数可以在异步操作完成后被调用，减少了对全局状态的依赖。例如，在处理文件I/O时，可以使用回调函数来处理读取或写入操作的结果。

public interface FileCallback {
    void onComplete(String result);
}

public void readFile(String filePath, FileCallback callback) {
    // 异步读取文件并在完成后调用回调函数
}

8 重构以消除问题

当系统中相邻层具有相似抽象时，通常表明类分解存在问题。重构是解决问题的有效方法。以下是几种常见的重构策略：

8.1 消除重复代码

重复代码是系统复杂性的主要来源之一。通过提取公共代码到独立的方法或类中，可以减少重复代码的数量。例如，多个类中都有类似的日志记录逻辑，可以将其提取到一个公共的日志记录类中。

public class Logger {
    public static void log(String message) {
        System.out.println("Log: " + message);
    }
}

public class MyClass1 {
    public void doSomething() {
        Logger.log("Doing something in MyClass1");
    }
}

public class MyClass2 {
    public void doSomethingElse() {
        Logger.log("Doing something else in MyClass2");
    }
}

8.2 合并类

如果多个类之间的职责重叠，可以考虑将它们合并为一个类。合并类可以减少类的数量，简化系统的结构。例如， TextDocument 、 TextArea 和 TextDocumentListener 三个类的职责交织在一起，可以合并为两个类，职责更加明确。

graph TD;
    A[原始设计] --> B[合并类];
    B --> C[职责明确的类1];
    B --> D[职责明确的类2];

8.3 重构传递方法

对于传递方法，可以通过重构来消除它们。例如，将 TextDocument 类中的传递方法移到 TextArea 类中，直接调用 TextArea 的方法，减少不必要的层次。

public class TextArea {
    public Character getLastTypedCharacter() {
        // 实现逻辑
    }

    public int getCursorOffset() {
        // 实现逻辑
    }

    public void insertString(String textToInsert, int offset) {
        // 实现逻辑
    }
}

public class TextDocument {
    private TextArea textArea;

    public void insertString(String textToInsert, int offset) {
        textArea.insertString(textToInsert, offset);
    }
}

9 设计原则的应用

在实际开发中，应用“不同层次，不同抽象”的原则可以帮助我们设计出更简洁、更易于维护的系统。以下是几种具体的应用场景：

9.1 文件系统设计

在设计文件系统时，可以将文件操作分为多个层次。最顶层提供文件抽象，中间层提供缓存机制，最低层提供设备驱动程序。每一层的职责明确，抽象级别不同，减少了系统的复杂性。

层次	抽象描述	主要职责
最高层	文件抽象	提供文件读写操作
中间层	缓存抽象	提供内存中的数据块缓存
最底层	设备驱动程序	负责数据块的物理传输

9.2 网络传输协议设计

在网络传输协议设计中，可以将传输层分为多个层次。最顶层提供可靠的字节流抽象，中间层提供数据包传输机制，最低层提供物理链路控制。每一层的职责明确，抽象级别不同，提高了系统的可靠性。

层次	抽象描述	主要职责
最高层	字节流抽象	提供可靠的字节流传输
中间层	数据包传输	提供数据包的传输和重组
最底层	物理链路控制	负责物理链路的控制和管理

9.3 用户界面设计

在用户界面设计中，可以将界面分为多个层次。最顶层提供用户交互抽象，中间层提供事件处理机制，最低层提供图形绘制功能。每一层的职责明确，抽象级别不同，提高了用户的使用体验。

层次	抽象描述	主要职责
最高层	用户交互抽象	提供用户交互操作
中间层	事件处理机制	提供事件的捕获和处理
最底层	图形绘制功能	提供图形绘制和渲染

10 结论

不同层次提供不同的抽象是构建高效软件系统的关键原则。通过合理的设计，可以减少系统的复杂性，提高系统的可维护性和性能。在实际开发中，我们应该时刻关注系统的层次结构，确保每一层的职责明确，抽象级别不同。通过不断优化和重构，我们可以设计出更加简洁、高效的软件系统。

---

通过以上内容，我们深入探讨了不同层次提供不同抽象的原则，并提供了具体的例子和策略来帮助开发者更好地理解和实践这一原则。希望这些内容能够对大家的开发工作有所帮助。