模块化设计原则：高内聚低耦合、接口隔离、依赖倒置

模块化设计，说白了就是把一个大系统拆成一个个小积木。每个积木只管自己的事，对外只露个接口。我做了十几年嵌入式，见过太多「一锅粥」式的代码——一个文件几千行，全局变量满天飞。嗯，这种代码改起来，真的会让人想砸键盘。

今天咱们聊聊三个核心原则：高内聚低耦合、接口隔离、依赖倒置。这三个东西，你理解透了，代码质量能上一个台阶。

1. 高内聚低耦合：模块的「内功」与「外功」

先说说内聚。内聚指的是模块内部元素之间的关联程度。高内聚，就是模块里的东西都围绕同一个职责。比如一个温度传感器驱动模块，它只负责读温度、转换格式、校验数据。别把WiFi配置、日志打印也塞进去。

耦合呢，是模块之间的依赖关系。低耦合，就是模块之间尽量少牵连。你改A模块，B模块不用跟着改。这才是好设计。

举个例子，一个常见的错误写法：

// 糟糕的设计：高耦合
void system_init(void) {
    uart_init();
    spi_init();
    sensor_init();
    wifi_connect();
    mqtt_connect();
    // 这里还偷偷做了校准
    sensor_calibrate();
    // 还启动了看门狗
    watchdog_enable();
}

这个函数干了太多事。初始化、连接、校准、看门狗，全搅在一起。你想想看，如果我想单独测试传感器初始化，还得把WiFi和MQTT都带上。这不合理。

改进后：

// 好的设计：高内聚，每个模块只做自己的事
void sensor_init(void) {
    // 只做传感器相关的事情
    gpio_config();
    i2c_init();
    sensor_reset();
}

void comm_init(void) {
    // 只做通信相关的事情
    uart_init();
    wifi_connect();
    mqtt_connect();
}

void system_init(void) {
    sensor_init();
    comm_init();
    watchdog_init();
}

你看，每个函数职责清晰。测试传感器时，我只需要调用 sensor_init()，不用管通信的事。这就是低耦合的好处。

2. 接口隔离：别让调用者知道太多

接口隔离原则，简单说就是：不要强迫调用者依赖它不需要的东西。

你想想看，一个传感器模块，对外暴露了10个函数。但大多数调用者只需要用其中2个。那剩下的8个函数，就是多余的负担。调用者得理解它们，还得小心别误用。

我建议的做法是：

• 最小接口原则：只暴露调用者真正需要的函数
• 接口粒度适中：太粗了不灵活，太细了调用麻烦
• 隐藏实现细节：内部函数用 static 隐藏

看个例子：

// 不好的接口：暴露太多
// sensor.h
void sensor_init(void);
void sensor_read_raw(void);
void sensor_convert_to_temp(void);
void sensor_apply_filter(void);
void sensor_calibrate(void);
void sensor_get_result(float *temp);

调用者其实只需要初始化、读结果。其他函数是内部实现细节。改进后：

// 好的接口：只暴露必要的
// sensor.h
void sensor_init(void);
float sensor_get_temperature(void);

// sensor.c 内部隐藏细节
static void sensor_read_raw(void) { ... }
static void sensor_convert_to_temp(void) { ... }
static void sensor_apply_filter(void) { ... }

调用者看到头文件，一目了然。不需要知道内部怎么转换、怎么滤波。这就是接口隔离。

3. 依赖倒置：面向接口编程，而不是面向实现

依赖倒置原则，听起来有点绕。其实核心就一句话：高层模块不应该依赖低层模块，两者都应该依赖抽象接口。

举个例子。你的应用层需要存储数据，它直接调用了EEPROM的驱动函数。这看起来没问题，对吧？但有一天，产品升级了，要改用Flash存储。这时候，你得改应用层的所有代码。因为应用层直接依赖了EEPROM的具体实现。

依赖倒置的做法是：定义一个存储接口，应用层只依赖这个接口。EEPROM和Flash都实现这个接口。这样换存储介质时，应用层代码不用动。

看代码：

// 定义抽象接口
// storage_if.h
typedef struct {
    int (*init)(void);
    int (*write)(uint32_t addr, uint8_t *data, uint32_t len);
    int (*read)(uint32_t addr, uint8_t *data, uint32_t len);
} storage_if_t;

// 应用层只依赖接口
// app.c
#include "storage_if.h"

void app_save_config(storage_if_t *storage) {
    storage->write(0x100, config_data, sizeof(config_data));
}

// EEPROM实现
// eeprom_driver.c
static int eeprom_init(void) { ... }
static int eeprom_write(uint32_t addr, uint8_t *data, uint32_t len) { ... }
static int eeprom_read(uint32_t addr, uint8_t *data, uint32_t len) { ... }

storage_if_t eeprom_storage = {
    .init = eeprom_init,
    .write = eeprom_write,
    .read = eeprom_read
};

// Flash实现
// flash_driver.c
static int flash_init(void) { ... }
static int flash_write(uint32_t addr, uint8_t *data, uint32_t len) { ... }
static int flash_read(uint32_t addr, uint8_t *data, uint32_t len) { ... }

storage_if_t flash_storage = {
    .init = flash_init,
    .write = flash_write,
    .read = flash_read
};

你看，应用层只依赖 storage_if_t 这个接口。换存储介质时，只需要换一个实现。应用层代码完全不用改。

4. 三个原则如何协同工作

这三个原则不是孤立的。它们一起用，效果更好。

原则	关注点	解决的问题
高内聚低耦合	模块内部结构	模块职责清晰，修改影响范围小
接口隔离	模块对外暴露	调用者只依赖需要的东西
依赖倒置	模块间依赖方向	高层不依赖低层，可灵活替换

举个例子。一个温控系统，有传感器模块、控制算法模块、执行器模块。

• 高内聚：每个模块只做自己的事。传感器只管读温度，控制算法只管算PID，执行器只管输出。
• 低耦合：传感器模块不直接调用控制算法。它通过回调或消息传递数据。
• 接口隔离：控制算法模块只暴露 calculate() 和 reset() 两个函数，内部细节隐藏。
• 依赖倒置：控制算法依赖一个抽象的传感器接口，而不是具体的温度传感器型号。

这样设计出来的系统，换传感器、换执行器、甚至换控制算法，都只需要改对应的模块。其他模块不受影响。

5. 总结

模块化设计，说白了就是「分而治之」的思想。高内聚让你每个模块都专注，低耦合让你改一处不影响全局。接口隔离让调用者轻松，依赖倒置让系统灵活。

你想想看，一个嵌入式系统，动辄几十万行代码。如果没有好的模块化设计，维护起来就是噩梦。我见过太多项目，因为前期设计没做好，后期改一个功能要动十几个文件。嗯，那种痛苦，经历过的人都懂。

所以，从今天开始，写代码前先想想：这个模块的职责是什么？它应该暴露什么接口？它依赖什么？想清楚了再动手。你会发现，代码质量会慢慢提升，bug会越来越少。

记住一句话：好的设计，是改出来的，不是写出来的。不断重构，不断优化，你的代码会越来越好。