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

最新推荐文章于 2025-07-25 15:26:41 发布

原创最新推荐文章于 2025-07-25 15:26:41 发布 · 58 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#软件系统 #抽象层次 #文件系统

解析《软件设计哲学》：复杂性与简约艺术专栏收录该内容

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 解决方案

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

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

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 用户界面设计

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

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