C++装饰器模式在流处理系统中的设计与实现-源码库

C++装饰器模式在流处理系统中的设计与实现：打造灵活可扩展的数据管道

作为一名长期奋战在数据处理一线的开发者，我深刻体会到流处理系统设计的复杂性。记得去年重构公司日志处理系统时，面对不断变化的数据格式和业务需求，传统的硬编码方式让我吃尽了苦头。直到引入装饰器模式，才真正实现了数据处理管道的灵活扩展。今天，我就来分享如何运用C++装饰器模式构建优雅的流处理系统。

装饰器模式的核心思想

装饰器模式允许我们动态地为对象添加新功能，而无需修改其结构。在流处理场景中，这意味着我们可以像搭积木一样组合各种数据处理功能。想象一下，一个基础的数据流经过加密、压缩、校验等多个处理环节，每个环节都是一个独立的装饰器，这种设计让系统具备了极佳的扩展性。

与继承相比，装饰器模式的优势在于运行时动态组合，避免了类爆炸问题。我在实际项目中就遇到过这样的教训：最初使用继承设计处理链，结果每增加一个新功能就要创建大量子类，维护成本急剧上升。

流处理系统的基础架构设计

首先，我们需要定义流处理的核心接口。这个接口应该足够抽象，能够涵盖各种数据流操作：


class IDataStream {
public:
    virtual ~IDataStream() = default;
    virtual void write(const std::string& data) = 0;
    virtual std::string read() = 0;
    virtual bool eof() const = 0;
};

接下来实现基础的数据流类，这里以文件流为例：


class FileStream : public IDataStream {
private:
    std::fstream file_;
    std::string filename_;
    
public:
    explicit FileStream(const std::string& filename) : filename_(filename) {
        file_.open(filename, std::ios::in | std::ios::out | std::ios::app);
    }
    
    ~FileStream() override {
        if (file_.is_open()) {
            file_.close();
        }
    }
    
    void write(const std::string& data) override {
        if (file_.is_open()) {
            file_ << data;
        }
    }
    
    std::string read() override {
        std::string content;
        std::string line;
        while (std::getline(file_, line)) {
            content += line + "n";
        }
        return content;
    }
    
    bool eof() const override {
        return file_.eof();
    }
};

装饰器基类的实现

装饰器基类是整个模式的关键，它维护对基础组件的引用，并转发所有操作：


class StreamDecorator : public IDataStream {
protected:
    std::unique_ptr stream_;
    
public:
    explicit StreamDecorator(std::unique_ptr stream)
        : stream_(std::move(stream)) {}
        
    void write(const std::string& data) override {
        stream_->write(data);
    }
    
    std::string read() override {
        return stream_->read();
    }
    
    bool eof() const override {
        return stream_->eof();
    }
};

这里有个重要的设计决策：使用unique_ptr来管理流对象的所有权。在实际开发中，我最初使用原始指针，结果出现了内存泄漏问题。改用智能指针后，内存管理变得简单可靠。

具体装饰器的实现

现在让我们实现几个实用的装饰器。首先是加密装饰器：


class EncryptStream : public StreamDecorator {
private:
    std::string key_;
    
    std::string encrypt(const std::string& data) {
        std::string result = data;
        for (char& c : result) {
            c ^= key_[0];  // 简单异或加密，实际项目请使用标准加密算法
        }
        return result;
    }
    
    std::string decrypt(const std::string& data) {
        return encrypt(data);  // 异或加密的解密就是再次异或
    }
    
public:
    EncryptStream(std::unique_ptr stream, const std::string& key)
        : StreamDecorator(std::move(stream)), key_(key) {}
        
    void write(const std::string& data) override {
        stream_->write(encrypt(data));
    }
    
    std::string read() override {
        return decrypt(stream_->read());
    }
};

压缩装饰器的实现：


class CompressStream : public StreamDecorator {
private:
    std::string compress(const std::string& data) {
        // 简化的压缩逻辑 - 实际项目应使用zlib等库
        if (data.length() < 100) return data;
        
        std::stringstream compressed;
        compressed << "[COMPRESSED]" << data.length();
        return compressed.str();
    }
    
    std::string decompress(const std::string& data) {
        if (data.find("[COMPRESSED]") == 0) {
            return "Original data (decompressed)";
        }
        return data;
    }
    
public:
    using StreamDecorator::StreamDecorator;
    
    void write(const std::string& data) override {
        stream_->write(compress(data));
    }
    
    std::string read() override {
        return decompress(stream_->read());
    }
};

装饰器的组合使用

装饰器模式的真正威力在于组合使用。我们可以像搭积木一样构建复杂的数据处理管道：


// 创建基础文件流
auto stream = std::make_unique("data.txt");

// 添加加密功能
stream = std::make_unique(std::move(stream), "secret_key");

// 添加压缩功能
stream = std::make_unique(std::move(stream));

// 使用装饰后的流
stream->write("Hello, Decorator Pattern!");
std::string content = stream->read();

这种组合方式极其灵活。记得在日志处理系统中，我们根据不同的业务场景动态组合装饰器：生产环境使用"加密+压缩"，测试环境只使用基础流，开发环境可能加上"日志记录"装饰器。

性能优化与注意事项

在实际使用中，我发现装饰器模式虽然灵活，但也需要注意性能问题：


// 避免过度装饰 - 这会增加调用栈深度
auto stream = std::make_unique("data.txt");
stream = std::make_unique(std::move(stream), "key1");
stream = std::make_unique(std::move(stream), "key2"); // 不必要的多层加密
stream = std::make_unique(std::move(stream));
stream = std::make_unique(std::move(stream)); // 重复压缩，性能浪费

// 更好的做法是合理设计装饰器组合

另一个重要经验是异常处理。装饰器应该正确处理底层流可能抛出的异常，并确保资源正确释放：


void write(const std::string& data) override {
    try {
        stream_->write(processData(data));
    } catch (const std::exception& e) {
        // 记录日志或进行其他错误处理
        throw;  // 重新抛出或处理异常
    }
}