如何安全处理失效对象并实现可靠的对象失效机制

你当前用建造者模式实现的连接构造逻辑，已经解决了对象初始化阶段的状态合法性问题——即拿到实例时必然处于「连接已建立」的合法初始状态。要解决对象生命周期中「失效后被误调用」的问题，可以根据所用语言的特性，从编译期校验、运行时拦截两个维度落地方案：

1. 泛型状态标记（静态类型语言首选，编译期拦截误用） #

给连接类绑定状态类型标签，不同状态下仅暴露对应可用的方法，让类型系统在编译阶段就阻止非法调用。以TypeScript为例：

type ConnState = 'active' | 'closed';

class WebSocketConnection<S extends ConnState = ConnState> {
  private ws: WebSocket;
  // 私有构造，禁止外部随意修改实例状态
  private constructor(ws: WebSocket) {
    this.ws = ws;
    // 监听底层连接关闭事件，自动流转状态
    ws.addEventListener('close', () => {
      (this as WebSocketConnection<any>).state = 'closed';
    });
  }

  state: S = 'active' as S;

  // 仅active状态下可调用发送方法
  send(data: string | ArrayBuffer): S extends 'active' ? void : never {
    if (this.state !== 'active') throw new Error('Connection is already closed');
    return this.ws.send(data) as any;
  }

  // 调用close后返回closed状态的实例，类型上不再暴露send等活跃方法
  close(): WebSocketConnection<'closed'> {
    if (this.state === 'closed') return this as WebSocketConnection<'closed'>;
    this.ws.close();
    this.state = 'closed' as S;
    return this as WebSocketConnection<'closed'>;
  }

  // 工厂方法保证创建出的实例一定是active状态
  static async connect(url: string): Promise<WebSocketConnection<'active'>> {
    const ws = new WebSocket(url);
    await new Promise<void>((resolve, reject) => {
      ws.onopen = () => resolve();
      ws.onerror = (err) => reject(err);
    });
    return new WebSocketConnection<'active'>(ws);
  }
}

这种实现下，如果你持有WebSocketConnection<'closed'>类型的实例，调用send方法会直接在TS类型检查阶段报错，根本无法通过编译，从根源上避免失效对象的误用。状态流转是单向的，活跃状态只能转为关闭状态，不存在反向篡改的可能。

2. 代理句柄拦截（动态类型语言通用，运行时强制校验） #

如果使用的语言没有强泛型能力，可以采用「真实对象+代理句柄」分离的设计：业务代码永远不直接持有真实连接实例，只持有代理对象；代理对象内部维护有效性标记，一旦连接关闭就自动标记为失效，拦截所有后续调用。以JavaScript为例：

function createConnectionProxy(realWs) {
  let isValid = true;
  const proxy = Object.freeze({
    send(data) {
      if (!isValid) throw new Error('Cannot invoke send on closed connection');
      realWs.send(data);
    },
    close() {
      if (!isValid) return;
      realWs.close();
      isValid = false;
      realWs = null; // 释放真实对象引用，帮助垃圾回收
    },
    get isValid() {
      return isValid;
    }
  });

  // 监听底层连接的异常关闭事件，自动标记失效
  realWs.addEventListener('close', () => {
    isValid = false;
    realWs = null;
  });

  return proxy;
}

该方案不依赖语言的高级类型特性，几乎所有编程语言都可以实现。开发环境下还可以在拦截逻辑中加告警日志，快速定位到误调用失效对象的代码位置。

3. 所有权/线性类型（最强校验，零运行时开销） #

如果使用Rust这类带所有权模型、线性类型的语言，可以直接通过所有权消费机制实现100%的静态校验：连接方法按值获取实例所有权，连接关闭后原实例被消费，作用域中不再存在该实例，编译器会直接阻止任何后续调用。示例：

struct ActiveConn { /* 内部websocket实例 */ }
struct ClosedConn;

impl ActiveConn {
    pub async fn connect(url: &str) -> Result<Self, ConnError> {
        // 建立连接逻辑，成功则返回ActiveConn实例
    }

    // 调用send后获取self所有权，正常则返回新的ActiveConn，异常则返回ClosedConn
    pub fn send(self, data: &[u8]) -> Result<Self, ClosedConn> {
        // 发送逻辑
    }

    // 调用close后消费self，返回无操作方法的ClosedConn
    pub fn close(self) -> ClosedConn {
        // 关闭连接逻辑
        ClosedConn
    }
}

// ClosedConn没有定义任何连接操作方法，拿到该实例后根本无法发起调用

这种方案不需要任何运行时检查，编译阶段就能完全杜绝失效对象被调用的问题，是安全性最高的实现方式。

实践选型参考 #

• 静态类型语言（TS/Java/C#等）优先选泛型状态标记方案，开发阶段就能拦截绝大多数误用
• 动态类型语言（JS/Python等）选代理句柄方案，运行时做强制校验，配合开发环境告警定位问题
• 对安全性要求极高的场景，如果条件允许可以选用带所有权模型的语言，从语言层面彻底规避问题

内容的提问来源于stack exchange，提问作者Lunuy