设计模式与网络编程：协议解析中的解释器、连接管理中的状态、消息处理中的责任链

网络编程，说白了就是一堆机器在互相说话。但怎么让它们说得清楚、听得明白，还能在连接断了、消息乱了的时候不出岔子？这就得靠设计模式来帮忙了。

我个人习惯把网络编程拆成三个核心问题：协议怎么解析、连接状态怎么管、消息来了怎么处理。正好，解释器模式、状态模式、责任链模式，就是解决这三个问题的利器。

协议解析中的解释器模式

你想想看，网络上传过来的数据，就是一串字节流。怎么把它变成程序能理解的结构？比如一个简单的自定义协议：CMD:LOGIN|USER:admin|PASS:123456。

我刚开始做网络编程时，习惯用一堆 if-else 去解析。后来协议越来越复杂，if-else 堆成了山，改一个地方得牵动全身。这时候，解释器模式就派上用场了。

举个例子，上面的协议可以拆成：

• 命令解释器：解析 CMD:LOGIN
• 键值对解释器：解析 USER:admin
• 组合解释器：用 | 分隔，组合多个键值对

// Java 示例：协议解析的解释器模式
interface Expression {
    Map<String, String> interpret(String context);
}

class CommandExpression implements Expression {
    @Override
    public Map<String, String> interpret(String context) {
        Map<String, String> result = new HashMap<>();
        String[] parts = context.split("\\|");
        for (String part : parts) {
            String[] kv = part.split(":", 2);
            if (kv.length == 2) {
                result.put(kv[0].trim(), kv[1].trim());
            }
        }
        return result;
    }
}

// 使用
Expression parser = new CommandExpression();
Map<String, String> data = parser.interpret("CMD:LOGIN|USER:admin|PASS:123456");
System.out.println(data.get("CMD")); // 输出 LOGIN

连接管理中的状态模式

网络连接是有生命周期的。从建立、认证、数据传输，到断开，每个阶段能做的事情不一样。比如，连接还没建立时，你不能发数据；连接已经断开了，你也不能再发。

我记得有一次，一个同事在代码里用了一堆布尔变量：isConnected、isAuthenticated、isClosed。结果呢？状态一多，逻辑就乱了。比如 isConnected=true 但 isAuthenticated=false 时，该不该允许发数据？

状态模式就是来解决这个问题的。它把每个状态封装成一个类，状态之间的切换由状态类自己决定。

// C++ 示例：连接状态管理
class ConnectionState {
public:
    virtual void send(Connection* conn, const std::string& data) = 0;
    virtual void close(Connection* conn) = 0;
    virtual ~ConnectionState() = default;
};

class ConnectedState : public ConnectionState {
public:
    void send(Connection* conn, const std::string& data) override {
        // 正常发送数据
        std::cout << "发送数据: " << data << std::endl;
    }
    void close(Connection* conn) override {
        conn->setState(new DisconnectedState());
        delete this;
    }
};

class DisconnectedState : public ConnectionState {
public:
    void send(Connection* conn, const std::string& data) override {
        std::cerr << "错误：连接已断开，无法发送数据" << std::endl;
    }
    void close(Connection* conn) override {
        // 已经断开了，什么都不做
    }
};

class Connection {
private:
    ConnectionState* state_;
public:
    Connection() : state_(new DisconnectedState()) {}
    void setState(ConnectionState* state) { state_ = state; }
    void send(const std::string& data) { state_->send(this, data); }
    void close() { state_->close(this); }
};

消息处理中的责任链模式

网络消息来了，通常不是一步就能处理完的。比如一个 HTTP 请求，先要解析头部，然后做权限校验，接着路由到具体业务逻辑，最后记录日志。每一步都可能决定要不要继续往下走。

如果用 if-else 写，代码会变成这样：

if (parseHeader()) {
    if (checkAuth()) {
        if (route()) {
            log();
        }
    }
}

嗯，看着就头疼。加一个步骤，就得改这个嵌套结构。责任链模式就是把这些步骤串成一条链，每个处理器只关心自己那一段。

// Java 示例：消息处理的责任链
abstract class MessageHandler {
    protected MessageHandler next;
    public void setNext(MessageHandler next) { this.next = next; }
    public abstract void handle(String message);
}

class AuthHandler extends MessageHandler {
    @Override
    public void handle(String message) {
        if (message.contains("token=valid")) {
            System.out.println("权限校验通过");
            if (next != null) next.handle(message);
        } else {
            System.out.println("权限校验失败，终止处理");
        }
    }
}

class LogHandler extends MessageHandler {
    @Override
    public void handle(String message) {
        System.out.println("记录日志: " + message);
        if (next != null) next.handle(message);
    }
}

// 使用
MessageHandler auth = new AuthHandler();
MessageHandler log = new LogHandler();
auth.setNext(log);
auth.handle("GET /api/data token=valid");

三者如何协同工作

在实际项目中，这三个模式经常一起出现。我画了一张图，帮你理清它们的关系：

你看，数据从网络进来，先经过解释器模式解析成结构化数据，然后状态模式确保连接处于正确状态，最后责任链模式把消息一步步处理掉。每一步各司其职，互不干扰。

这三个模式组合起来，能让你的网络编程代码清晰、可维护、易扩展。嗯，我这些年做网络编程的经验，基本都浓缩在这里了。