Envoy 使用的设计模式技术文档

1. 概述

Envoy 是一个高性能的开源边缘和服务代理，其代码库中大量使用了经典的设计模式。这些模式使得 Envoy 具备了高度的可扩展性、可维护性和灵活性。本文档整理了 Envoy 中使用的主要设计模式及其实现细节，旨在帮助开发人员理解 Envoy 的架构设计，并为扩展开发提供参考。

Envoy 通过合理运用各种设计模式，实现了：

1. 高度可扩展性：通过工厂模式和插件架构，可以轻松添加新的过滤器和扩展，无需修改核心代码

2. 高性能：通过线程本地存储和反应器模式，实现了高并发、低延迟的处理能力

3. 可维护性：通过分层架构和清晰的设计模式，代码结构清晰，职责分明

4. 灵活性：通过策略模式和责任链模式，可以灵活组合功能，满足不同场景需求

5. 可靠性：通过状态模式和观察者模式，确保了系统的稳定运行和正确状态转换

Envoy 通过合理运用设计模式，实现了以下核心非功能性需求：

需求	实现方式
可扩展性	工厂模式 + 插件架构
高性能	线程本地存储 + 反应器模式
可维护性	分层架构 + 清晰的设计模式
灵活性	策略模式 + 责任链模式
可靠性	状态模式 + 观察者模式

---

2. 创建型模式

创建型模式抽象了对象的实例化过程，Envoy 使用这些模式来解耦对象的创建和使用。

2.1 工厂模式 (Factory Pattern)

工厂模式是 Envoy 最核心的设计模式之一，用于创建各种扩展组件。Envoy 实现了分层级的工厂体系。

2.1.1 简单工厂

基础工厂接口用于创建特定类型的组件：

// 文件位置: envoy/network/client_connection_factory.hclass ClientConnectionFactory {public:  virtual ~ClientConnectionFactory() = default;
  virtual Network::ConnectionHandlePtr  createConnection(Event::Dispatcher& dispatcher,                    const Address::InstanceConstSharedPtr& address,                   Address::InstanceConstSharedPtr& source_address,                   TransportSocketPtr&& transport_socket,                   const StreamInfo::StreamInfo& stream_info,                   Network::TransportSocketOptionsConstSharedPtr transport_socket_options) PURE;};

2.1.2 抽象工厂

Envoy 通过 FactoryRegistry 实现了完整的插件化扩展机制：

// 文件位置: envoy/registry/registry.htemplate <class Base> class FactoryRegistry {public:  static void registerFactory(Base& factory, absl::string_view name);  static Base* getFactory(absl::string_view name);  static absl::flat_hash_map<std::string, Base*>& factories();
private:  static absl::flat_hash_map<std::string, Base*>* factories_;};
// 自动注册模板类template <class T, class Base> class RegisterFactory {public:  RegisterFactory() {    FactoryRegistry<Base>::registerFactory(instance_, instance_.name());  }
private:  T instance_{};};

使用示例：

// 1. 定义工厂基类class NamedNetworkFilterConfigFactory : public Config::TypedFactory {public:  ~NamedNetworkFilterConfigFactory() override = default;  std::string category() const override { return "envoy.network.filters"; }};
// 2. 实现具体工厂class MyFilterFactory : public NamedNetworkFilterConfigFactory {public:  std::string name() const override { return "my_filter"; }
  Network::FilterFactoryCb createFilterFactoryFromProto(      const Protobuf::Message& proto_config,      Server::Configuration::FactoryContext& context) override {    return [context](Network::FilterManager& filter_manager) {      filter_manager.addFilter(std::make_shared<MyFilter>(context));    };  }
  ProtobufTypes::MessagePtr createEmptyConfigProto() override {    return std::make_unique<MyFilterConfig>();  }};
// 3. 静态注册（编译时自动注册）REGISTER_FACTORY(MyFilterFactory, NamedNetworkFilterConfigFactory);

工厂注册的生命周期：

编译时: REGISTER_FACTORY 宏创建静态对象   ↓静态初始化: RegisterFactory 构造函数调用 registerFactory   ↓运行时: 配置加载时调用 getFactory(name) 获取工厂   ↓使用: 工厂创建具体的过滤器实例

2.1.3 工厂方法模式

在过滤器链创建过程中使用工厂方法：

// 文件位置: envoy/http/filter.husing FilterFactoryCb = std::function<void(FilterChainFactoryCallbacks& callbacks)>;
class FilterChainFactory {public:  virtual ~FilterChainFactory() = default;
  virtual void createFilterChain(FilterChainManager& manager) PURE;
  virtual bool createUpgradeFilterChain(absl::string_view upgrade,                                        const UpgradeMap* per_route_upgrade_map,                                        FilterChainManager& manager) PURE;};

2.2 单例模式 (Singleton Pattern)

Envoy 实现了自己的单例管理器来管理全局单例，支持延迟初始化和线程安全的访问。

// 文件位置: envoy/singleton/manager.hclass Manager {public:  virtual ~Manager() = default;
  template <class T>  std::shared_ptr<T> getTyped(const std::string& name, SingletonFactoryCb cb) {    return std::dynamic_pointer_cast<T>(get(name, cb));  }
  virtual InstanceSharedPtr get(const std::string& name, SingletonFactoryCb cb) PURE;};
// 单例注册宏#define SINGLETON_MANAGER_REGISTRATION(NAME)                                                       \  static constexpr char NAME##_singleton_name[] = #NAME "_singleton";                              \  static Envoy::Registry::RegisterInternalFactory<                                                 \      Envoy::Singleton::RegistrationImpl<NAME##_singleton_name>, Envoy::Singleton::Registration>   \      NAME##_singleton_registered_;

使用示例：

// 1. 注册单例类型SINGLETON_MANAGER_REGISTRATION(my_singleton);
// 2. 获取单例实例auto singleton = singleton_manager.getTyped<MySingleton>(    SINGLETON_MANAGER_REGISTERED_NAME(my_singleton),    []() { return std::make_shared<MySingleton>(); });

单例生命周期管理：

Server 启动   ↓SingletonManager 初始化   ↓首次 getTyped() 调用 → 执行工厂回调创建实例   ↓后续调用返回缓存的实例   ↓Server 关闭 → 单例随 Server 销毁

2.3 建造者模式 (Builder Pattern)

在配置构建过程中使用建造者模式创建复杂对象：

// 示例：监听器建造者class ListenerBuilder {public:  ListenerBuilder& withName(absl::string_view name);  ListenerBuilder& withAddress(Address::InstanceConstSharedPtr address);  ListenerBuilder& withFilterChain(FilterChainPtr filter_chain);  ListenerBuilder& withSocketOptions(SocketOptions options);  ListenerBuilder& withConnectionLimit(uint32_t limit);  ListenerPtr build();};
// 使用示例auto listener = ListenerBuilder()    .withName("http_listener")    .withAddress(address)    .withFilterChain(http_filter_chain)    .withConnectionLimit(10000)    .build();

3. 结构型模式

结构型模式关注如何组合类和对象形成更大的结构。

3.1 适配器模式 (Adapter Pattern)

适配器模式用于在不兼容的接口之间建立桥梁：

// 将 HTTP 过滤器适配为网络过滤器class NetworkFilterAdapter : public Network::ReadFilter {public:  explicit NetworkFilterAdapter(Http::StreamFilterSharedPtr http_filter)      : http_filter_(http_filter) {}
  Network::FilterStatus onData(Buffer::Instance& data, bool end_stream) override {    // 将网络数据适配为 HTTP 流数据    http_filter_->decodeData(data, end_stream);    return Network::FilterStatus::Continue;  }
  Network::FilterStatus onNewConnection() override {    // 适配为 HTTP 流开始    return Network::FilterStatus::Continue;  }
private:  Http::StreamFilterSharedPtr http_filter_;};

典型使用场景：将 HTTP 级别的过滤器复用到网络过滤器链中。

3.2 装饰器模式 (Decorator Pattern)

过滤器链本质上是装饰器模式的经典实现，每个过滤器装饰了流的处理逻辑：

// 每个过滤器装饰处理逻辑class BufferFilter : public Http::StreamDecoderFilter {public:  FilterHeadersStatus decodeHeaders(RequestHeaderMap& headers, bool end_stream) override {    // 装饰：添加缓冲逻辑    return FilterHeadersStatus::Continue;  }
  FilterDataStatus decodeData(Buffer::Instance& data, bool end_stream) override {    // 装饰：缓冲数据而不是立即转发    buffer_.add(data);    if (buffer_.length() >= min_buffer_size_ || end_stream) {      return FilterDataStatus::Continue;    }    return FilterDataStatus::StopIterationAndBuffer;  }
private:  Buffer::OwnedImpl buffer_;  uint32_t min_buffer_size_;};

3.3 代理模式 (Proxy Pattern)

Envoy 本身就是一个代理，其内部也大量使用代理模式：

// 上游请求代理class UpstreamRequest : public Http::StreamCallbacks {public:  void encodeHeaders(RequestHeaderMap& headers, bool end_stream) override {    // 代理：将请求头转发到上游连接    if (upstream_stream_) {      upstream_stream_->encodeHeaders(headers, end_stream);    }  }
  void encodeData(Buffer::Instance& data, bool end_stream) override {    // 代理：将数据转发到上游    if (upstream_stream_) {      upstream_stream_->encodeData(data, end_stream);    }  }
private:  Http::StreamEncoder* upstream_stream_{nullptr};};

3.4 桥接模式 (Bridge Pattern)

桥接模式用于分离抽象和实现，Envoy 在传输层使用此模式：

// 抽象：传输 Socket 接口class TransportSocket {public:  virtual ~TransportSocket() = default;  virtual void setTransportSocketCallbacks(TransportSocketCallbacks& callbacks) PURE;  virtual void doRead(Buffer::Instance& read_buffer) PURE;  virtual void doWrite(Buffer::Instance& write_buffer, bool end_stream) PURE;  virtual void close() PURE;};
// 实现 A：普通 TCP Socketclass TcpSocket : public TransportSocket {public:  void doRead(Buffer::Instance& read_buffer) override {    // TCP 实现：从 socket fd 读取    ssize_t len = recv(fd_, buffer, size, 0);    read_buffer.add(buffer, len);  }};
// 实现 B：TLS Socketclass SslSocket : public TransportSocket {public:  void doRead(Buffer::Instance& read_buffer) override {    // TLS 实现：通过 SSL_read 解密读取    int ret = SSL_read(ssl_, buffer, size);    read_buffer.add(buffer, ret);  }};

3.5 组合模式 (Composite Pattern)

过滤器链使用组合模式将多个过滤器组合为统一结构：

class FilterManager {public:  void addDecoderFilter(StreamDecoderFilterSharedPtr filter) {    decoder_filters_.push_back(std::make_shared<ActiveDecoderFilter>(filter));  }
  void addEncoderFilter(StreamEncoderFilterSharedPtr filter) {    encoder_filters_.push_back(std::make_shared<ActiveEncoderFilter>(filter));  }
  // 组合操作：递归调用所有过滤器  FilterHeadersStatus decodeHeaders(RequestHeaderMap& headers, bool end_stream) {    for (auto& filter : decoder_filters_) {      auto status = filter->decodeHeaders(headers, end_stream);      if (status != FilterHeadersStatus::Continue) {        return status;      }    }    return FilterHeadersStatus::Continue;  }
private:  std::vector<ActiveDecoderFilterPtr> decoder_filters_;  std::vector<ActiveEncoderFilterPtr> encoder_filters_;};

4. 行为型模式

行为型模式关注算法和对象间职责的分配。

4.1 观察者模式 (Observer Pattern)

Envoy 广泛使用观察者模式进行事件通知和回调管理：

// 文件位置: envoy/server/lifecycle_notifier.hclass ServerLifecycleNotifier {public:  enum class Stage {     Startup,      // 服务启动阶段    PostInit,     // 初始化后阶段    ShutdownExit  // 关闭退出阶段  };
  using StageCallback = std::function<void()>;  using HandlePtr = std::unique_ptr<Handle>;
  virtual HandlePtr registerCallback(Stage stage, StageCallback callback) PURE;};
// 连接事件观察者class ConnectionCallbacks {public:  virtual ~ConnectionCallbacks() = default;  virtual void onEvent(ConnectionEvent event) PURE;  virtual void onAboveWriteBufferHighWatermark() PURE;  virtual void onBelowWriteBufferLowWatermark() PURE;};

使用示例：

// 注册服务生命周期观察者class MyComponent {public:  void registerLifecycleNotifications(ServerLifecycleNotifier& notifier) {    startup_handle_ = notifier.registerCallback(        ServerLifecycleNotifier::Stage::Startup,        [this]() { this->onServerStartup(); });
    shutdown_handle_ = notifier.registerCallback(        ServerLifecycleNotifier::Stage::ShutdownExit,        [this]() { this->onServerShutdown(); });  }
private:  void onServerStartup() { /* 启动逻辑 */ }  void onServerShutdown() { /* 清理逻辑 */ }
  ServerLifecycleNotifier::HandlePtr startup_handle_;  ServerLifecycleNotifier::HandlePtr shutdown_handle_;};

4.2 策略模式 (Strategy Pattern)

策略模式用于实现可插拔的算法：

// 文件位置: envoy/common/backoff_strategy.hclass BackOffStrategy {public:  virtual ~BackOffStrategy() = default;  virtual uint64_t nextBackOffMs() PURE;  virtual void reset() PURE;};
// 具体策略 1：指数退避class ExponentialBackOffStrategy : public BackOffStrategy {public:  ExponentialBackOffStrategy(uint64_t base_interval_ms, uint64_t max_interval_ms)      : base_interval_ms_(base_interval_ms),        max_interval_ms_(max_interval_ms),        current_interval_ms_(base_interval_ms) {}
  uint64_t nextBackOffMs() override {    uint64_t backoff = current_interval_ms_;    current_interval_ms_ = std::min(current_interval_ms_ * 2, max_interval_ms_);    return backoff;  }
  void reset() override {    current_interval_ms_ = base_interval_ms_;  }
private:  const uint64_t base_interval_ms_;  const uint64_t max_interval_ms_;  uint64_t current_interval_ms_;};
// 具体策略 2：固定间隔退避class FixedBackOffStrategy : public BackOffStrategy {public:  explicit FixedBackOffStrategy(uint64_t interval_ms) : interval_ms_(interval_ms) {}
  uint64_t nextBackOffMs() override { return interval_ms_; }  void reset() override {}
private:  const uint64_t interval_ms_;};

负载均衡策略示例：

// 负载均衡策略接口class LoadBalancer {public:  virtual HostConstSharedPtr chooseHost(const HostSet& hosts) PURE;};
// 轮询策略class RoundRobinLoadBalancer : public LoadBalancer { /* ... */ };
// 最少连接策略class LeastRequestLoadBalancer : public LoadBalancer { /* ... */ };
// 一致性哈希策略class ConsistentHashLoadBalancer : public LoadBalancer { /* ... */ };

4.3 责任链模式 (Chain of Responsibility Pattern)

Envoy 的过滤器链是责任链模式的完美体现：

// 文件位置: envoy/http/filter.henum class FilterHeadersStatus {  Continue,                    // 继续执行链中的下一个过滤器  StopIteration,               // 停止执行，不再传递给后续过滤器  StopAllIterationAndBuffer,   // 停止并缓冲数据};
class StreamDecoderFilter {public:  virtual FilterHeadersStatus decodeHeaders(RequestHeaderMap& headers, bool end_stream) PURE;  virtual FilterDataStatus decodeData(Buffer::Instance& data, bool end_stream) PURE;  virtual FilterTrailersStatus decodeTrailers(RequestTrailerMap& trailers) PURE;};
// 过滤器链处理class FilterChain {public:  void decodeHeaders(RequestHeaderMap& headers, bool end_stream) {    for (auto& filter : filters_) {      auto status = filter->decodeHeaders(headers, end_stream);
      switch (status) {        case FilterHeadersStatus::Continue:          continue;  // 继续传递给下一个过滤器
        case FilterHeadersStatus::StopIteration:          return;    // 停止链的执行
        case FilterHeadersStatus::StopAllIterationAndBuffer:          buffering_ = true;          return;      }    }  }
private:  std::vector<StreamDecoderFilterPtr> filters_;  bool buffering_{false};};

过滤器链执行流程图：

请求 → Filter1.decodeHeaders() → Filter2.decodeHeaders() → ... → FilterN.decodeHeaders()         │                            │         ├─ Continue ─────────────────┤         ├─ StopIteration → 停止转发         └─ StopAndBuffer → 缓冲后异步处理

4.4 命令模式 (Command Pattern)

使用命令模式封装异步操作：

// 命令接口using PostCb = std::function<void()>;class Dispatcher {public:  virtual void post(PostCb callback) PURE;  virtual void defer(PostCb callback) PURE;};// 使用示例class AsyncOperation {public:  void execute(Dispatcher& dispatcher) {    dispatcher.post([this]() {      // 在目标线程执行的操作      this->doWork();    });  }private:  void doWork() { /* 实际工作 */ }};

4.5 状态模式 (State Pattern)

管理连接和请求的状态转换：

// 连接状态机class ConnectionImpl {public:  enum class State {    Connecting,   // 连接中    Connected,    // 已连接    Draining,     // 排空中    Closed        // 已关闭  };  void onConnected() {    if (state_ == State::Connecting) {      state_ = State::Connected;      notifyConnected();    }  }  void onRemoteClose() {    if (state_ == State::Connected || state_ == State::Draining) {      state_ = State::Closed;      notifyRemoteClosed();    }  }  void close() {    if (state_ == State::Connecting || state_ == State::Connected) {      state_ = State::Draining;      initiateGracefulClose();    }  }private:  State state_{State::Connecting};};

4.6 模板方法模式 (Template Method Pattern)

定义算法骨架，让子类实现具体步骤：

// 基类定义模板方法class ConnectionImplBase {public:  // 模板方法：定义了关闭连接的算法骨架  void close(ConnectionCloseType type) {    // 1. 前置处理    onPreClose();
    // 2. 执行具体关闭（由子类实现）    doClose(type);
    // 3. 清理资源    releaseResources();
    // 4. 后置处理    onPostClose();  }
protected:  virtual void onPreClose() {}                    // 钩子方法（可选覆盖）  virtual void doClose(ConnectionCloseType type) PURE;  // 抽象方法（必须实现）  virtual void onPostClose() {}                   // 钩子方法（可选覆盖）
private:  void releaseResources() {    // 通用清理逻辑    read_buffer_.drain(read_buffer_.length());    write_buffer_.drain(write_buffer_.length());  }
  Buffer::Instance read_buffer_;  Buffer::Instance write_buffer_;};

4.7 访问者模式 (Visitor Pattern)

用于 Protobuf 消息验证，分离验证算法和数据结构：

// 文件位置: envoy/protobuf/message_validator.hclass ValidationVisitor {public:  virtual ~ValidationVisitor() = default;
  virtual void onUnknownField(absl::string_view description) PURE;  virtual void onDeprecatedField(absl::string_view description, bool soft_deprecation) PURE;  virtual void onWorkInProgress(absl::string_view description) PURE;};
// 严格模式访问者class StrictValidationVisitor : public ValidationVisitor {public:  void onUnknownField(absl::string_view description) override {    throw EnvoyException(fmt::format("Unknown field: {}", description));  }
  void onDeprecatedField(absl::string_view description, bool soft_deprecation) override {    if (!soft_deprecation) {      throw EnvoyException(fmt::format("Deprecated field: {}", description));    }  }
  void onWorkInProgress(absl::string_view description) override {    throw EnvoyException(fmt::format("WIP feature: {}", description));  }};
// 宽松模式访问者class LenientValidationVisitor : public ValidationVisitor {public:  void onUnknownField(absl::string_view description) override {    ENVOY_LOG(warn, "Unknown field: {}", description);  }
  void onDeprecatedField(absl::string_view description, bool soft_deprecation) override {    ENVOY_LOG(warn, "Deprecated field: {}", description);  }
  void onWorkInProgress(absl::string_view description) override {    ENVOY_LOG(info, "WIP feature: {}", description);  }};

4.8 中介者模式 (Mediator Pattern)

ClusterManager 作为中介者协调多个组件：

class ClusterManager {public:  virtual ~ClusterManager() = default;
  // 集群管理  virtual Upstream::ClusterInfoConstSharedPtr getCluster(absl::string_view cluster) PURE;  virtual ThreadLocalCluster* getThreadLocalCluster(absl::string_view cluster) PURE;  virtual bool addOrUpdateCluster(const envoy::config::cluster::v3::Cluster& cluster,                                  const std::string& version_info) PURE;
  // HTTP 连接池管理  virtual Http::ConnectionPool::Instance* httpConnPoolForCluster(absl::string_view cluster) PURE;
  // TCP 连接池管理  virtual Tcp::ConnectionPool::Instance* tcpConnPoolForCluster(absl::string_view cluster) PURE;
  // CDS 回调  virtual void setPrimaryClustersInitializedCb(std::function<void()> callback) PURE;};

中介者模式交互图：

---

5. 并发模式

5.1 线程本地存储模式 (Thread Local Storage Pattern)

Envoy 大量使用线程本地存储来避免锁竞争，实现无锁并发：

// 文件位置: envoy/thread_local/thread_local.hclass ThreadLocalObject {public:  virtual ~ThreadLocalObject() = default;};
class Slot {public:  virtual ~Slot() = default;  virtual void set(std::function<std::shared_ptr<ThreadLocalObject>(Event::Dispatcher&)> create_cb) PURE;  virtual std::shared_ptr<ThreadLocalObject> get() PURE;};
class Instance {public:  virtual ~Instance() = default;  virtual SlotPtr allocateSlot() PURE;
  template <class T>  std::shared_ptr<T> getTyped(Slot& slot) {    return std::dynamic_pointer_cast<T>(slot.get());  }};
// 使用示例class MyThreadLocalData : public ThreadLocalObject {public:  int counter_{0};  std::vector<ConnectionPtr> connections_;};
// 分配槽位并设置 TLS 对象auto slot = tls.allocateSlot();slot->set([](Event::Dispatcher& dispatcher) {  return std::make_shared<MyThreadLocalData>();});
// 在任一工作线程中访问auto data = tls.getTyped<MyThreadLocalData>(*slot);data->counter_++;  // 无需加锁，每个线程独立

Envoy 线程模型：

5.2 反应器模式 (Reactor Pattern)

Envoy 基于 libevent 实现了高性能的反应器模式：

// 事件调度器（反应器）class Dispatcher {public:  virtual ~Dispatcher() = default;
  // 运行事件循环  virtual void run(RunType type) PURE;
  // 创建定时器  virtual TimerPtr createTimer(const TimerCb& callback) PURE;
  // 延迟执行回调  virtual void post(PostCb callback) PURE;
  // 创建文件事件监听  virtual FileEventPtr createFileEvent(int fd, FileReadyCb cb, int events,                                       FileTriggerType trigger_type) PURE;};
// 定时器实现class Timer {public:  virtual void enableTimer(const std::chrono::milliseconds& timeout) PURE;  virtual void disableTimer() PURE;};
// 使用示例auto timer = dispatcher->createTimer([this]() {  this->onTimeout();});timer->enableTimer(std::chrono::milliseconds(1000));

5.3 主动器模式 (Proactor Pattern)

Envoy 的异步 I/O 使用了主动器模式：

// 异步连接操作class Connection {public:  virtual void connect() PURE;  virtual void close() PURE;  virtual void addConnectionCallbacks(ConnectionCallbacks& callbacks) PURE;};
// 异步操作完成时的回调（主动器）class ConnectionCallbacks {public:  virtual void onEvent(ConnectionEvent event) PURE;  virtual void onAboveWriteBufferHighWatermark() PURE;  virtual void onBelowWriteBufferLowWatermark() PURE;};
// 异步连接示例class AsyncConnector {public:  void connect(Dispatcher& dispatcher, const Address::InstanceConstSharedPtr& address) {    auto connection = dispatcher.createClientConnection(address, ...);    connection->addConnectionCallbacks(*this);    connection->connect();  // 异步连接，立即返回    // 连接完成后 onEvent(Connected) 会被调用  }
  void onEvent(ConnectionEvent event) override {    if (event == ConnectionEvent::Connected) {      // 连接成功，开始发送数据      sendRequest();    }  }};

---

6. 架构模式

6.1 插件架构

Envoy 通过工厂注册实现了完整的插件架构：

// 插件基类class NamedNetworkFilterConfigFactory : public Config::TypedFactory {public:  std::string category() const override { return "envoy.network.filters"; }};
// 插件自动发现与注册// 在编译时，所有 REGISTER_FACTORY 宏都会创建静态注册对象// 运行时，配置加载器会查询 FactoryRegistry 获取对应的工厂
// 配置加载流程void Configuration::loadConfiguration(const std::string& config) {  // 1. 解析配置  auto proto_config = parseConfig(config);
  // 2. 根据类型查找工厂  auto* factory = FactoryRegistry<NamedNetworkFilterConfigFactory>::getFactory(      proto_config.name());
  // 3. 使用工厂创建插件实例  auto filter = factory->createFilterFactoryFromProto(proto_config, context);}

支持的扩展点：

扩展类别	注册宏	描述
网络过滤器	REGISTER_FACTORY	Layer 4 过滤器
HTTP 过滤器	REGISTER_FACTORY	Layer 7 过滤器
接入点	REGISTER_FACTORY	监听器接入点
负载均衡器	REGISTER_FACTORY	负载均衡策略
传输 Socket	REGISTER_FACTORY	TLS/明文传输
健康检查器	REGISTER_FACTORY	主动/被动健康检查

6.2 分层架构

Envoy 采用清晰的分层架构，各层职责明确：

6.3 事件驱动架构

Envoy 的核心是事件驱动架构：

// 事件循环的主循环void DispatcherImpl::run(RunType type) {  running_ = true;
  while (running_) {    // 1. 等待事件    event_base_loop(event_base_, EVLOOP_ONCE | ...);
    // 2. 处理就绪的事件    processReadyEvents();
    // 3. 执行延迟回调    drainPostCallbacks();
    // 4. 检查退出条件    if (type == RunType::NonBlock && !hasPendingEvents()) {      break;    }  }}
// 事件驱动流程// I/O事件 → 事件循环 → 回调处理 → 产生新事件 → 继续循环

7. 设计模式汇总

7.1 模式使用概览

分类	模式名称	使用场景	重要性
创建型	工厂模式	扩展组件创建	★★★★★
	单例模式	全局资源管理	★★★★☆
	建造者模式	配置对象构建	★★★☆☆
结构型	适配器模式	接口兼容转换	★★★★☆
	装饰器模式	过滤器链	★★★★★
	代理模式	上游请求代理	★★★★☆
	桥接模式	传输层抽象	★★★☆☆
	组合模式	过滤器组合	★★★★☆
行为型	观察者模式	事件通知	★★★★★
	策略模式	负载均衡/退避	★★★★☆
	责任链模式	过滤器链	★★★★★
	命令模式	异步操作	★★★★☆
	状态模式	连接状态管理	★★★☆☆
	模板方法	算法骨架	★★★☆☆
	访问者模式	配置验证	★★★☆☆
	中介者模式	集群管理	★★★★☆
并发型	TLS 模式	无锁并发	★★★★★
	反应器模式	事件循环	★★★★★
	主动器模式	异步I/O	★★★★☆
架构型	插件架构	扩展系统	★★★★★
	分层架构	系统组织	★★★★☆
	事件驱动	主循环	★★★★★

7.2 模式关系图

7.3 模式组合示例

过滤器链创建流程中的模式组合：

1. 配置加载   └── 工厂模式：创建过滤器实例
2. 过滤器链构建   └── 建造者模式：构建过滤器链   └── 组合模式：组织过滤器结构
3. 请求处理   └── 责任链模式：依次调用过滤器   └── 装饰器模式：每个过滤器添加功能
4. 异步处理   └── 命令模式：封装回调   └── 观察者模式：事件通知

---

8. 最佳实践与常见陷阱

8.1 扩展开发最佳实践

1. 正确注册工厂：

// 确保使用正确的 categoryclass MyFilterFactory : public NamedNetworkFilterConfigFactory {public:  std::string category() const override {     return "envoy.network.filters";  // 必须与扩展点匹配  }};
// 使用正确的注册宏REGISTER_FACTORY(MyFilterFactory, NamedNetworkFilterConfigFactory);

2. 线程安全考虑：

// 无状态过滤器：可以在多个线程间共享class StatelessFilter : public Http::StreamDecoderFilter {  // 不使用成员变量存储请求特定数据};
// 有状态过滤器：需要使用 TLS 或确保线程安全class StatefulFilter : public Http::StreamDecoderFilter {  // 使用 TLS 存储每线程数据  ThreadLocal::SlotPtr tls_slot_;};

3. 正确使用生命周期：

class MyFilter : public Http::StreamDecoderFilter {public:  // 在 onDestroy 中清理资源  void onDestroy() override {    cancelPendingOperations();    releaseResources();  }
private:  Cancellable* pending_operation_{nullptr};};

8.2 常见陷阱

陷阱	描述	解决方案
阻塞操作	在过滤器回调中执行阻塞 I/O	使用异步 API 和回调
锁竞争	在热路径中使用互斥锁	使用 TLS 或无锁数据结构
内存泄漏	未正确释放回调捕获的对象	使用智能指针和清理回调
线程安全	跨线程访问共享数据	通过 Dispatcher::post() 调度
生命周期	访问已销毁的对象	使用弱引用或依赖注入

---

附录

A. 相关源码文件索引

模式	主要源码位置
工厂注册	source/common/registry/
单例管理	source/common/singleton/
线程本地存储	source/common/thread_local/
事件调度	source/common/event/
过滤器	source/common/http/
集群管理	source/common/upstream/