如何使用具有泛型类型的静态属性并有意义？

Question

我有一个构造函数并调用静态方法来设置一个静态变量。

export abstract class AbstractRepository<T extends Typegoose> {
  private static conn: SessionDb<T>; // <-- Compile error here!
  protected model: Model<InstanceType<T>, {}>;

  constructor(entity: T, collectionName: string){
    if(AbstractRepository.conn == null) AbstractRepository.conn = SessionDb.connect(entity);
    this.model = AbstractRepository.conn.getModel(collectionName);
  }  
}

如何键入conn: SessionDb <T> 属性？
这个变量是一个猫鼬连接。
保存单例变量以供将来访问是否有意义？

Answer 1

问题

当您有一个泛型类时，泛型参数T 适用于该类的每个实例。当您创建泛型类的实例时，您可以像 const myObj = new GenericClass<MyType>(args); 一样指定类型 T 但通常您不需要，因为您的构造函数签名告诉 typescript 用于创建实例的参数与泛型 T 的关系.

通过您的构造函数constructor(entity: T, collectionName: string)，您告诉打字稿“获取变量entity 的类型并将其用作此实例的通用T”。所以当你调用const myObj = new ConcreteRepository(myEntity, myCollectionName);创建一个新实例时，typescript会判断myObj的类型为ConcreteRepository<typeof myEntity>。 （我使用名称ConcreteRepository 来描述扩展AbstractRepository 的类，因为抽象类无法实例化）。

同时，static 属性适用于类本身，因此适用于每个实例。

您可以有多个 AbstractRepository 实例，它们可以有许多不同的 T 值，但它们都将共享相同的 private static conn 值。该变量将具有首先构造的特定实例的 T 类型（因为它只设置一次），不是当前实例的 T 类型。

拥有一个依赖于通用 T 的静态变量根本没有意义。

解决方案 1

为了保证每个实例都有一个与其实体类型对应的SessionDb，我们将conn做成实例变量而不是静态变量。每个实例在构造函数中将其设置为this.conn。

export abstract class AbstractRepository<T extends Typegoose> {
  protected conn: SessionDb<T>;
  protected model: Model<InstanceType<T>, {}>;

  constructor(entity: T, collectionName: string){
    this.conn = SessionDb.connect(entity);
    this.model = this.conn.getModel(collectionName);
  }
}

通过这种设置，基类可以由本身是通用的类来实现：

export class ConcreteRepository<T extends Typegoose> extends AbstractRepository<T> {
}

或者通过绑定到特定值T的类：

export class SpecificRepository extends AbstractRepository<SpecificType> {
}

解决方案 2

AbstractRepository 是一个abstract 类，这意味着它不能直接实例化，只能通过扩展它的类实例化来创建。如果这些扩展类都只适用于特定类型的实体，例如上面的 SpecificRepository 示例，那么您可以为每个特定扩展类设置一个单独的 static conn 变量。

它看起来有点像这样（我不知道其中一些类型的细节）：

export abstract class AbstractRepository<T extends Typegoose> {
  protected model: Model<InstanceType<T>, {}>;

  constructor(entity: T, collectionName: string){
    this.model = this.getConnection().getModel(collectionName);
  }

  abstract getConnection(): SessionDb<T>;
}

export class SpecificRepository extends AbstractRepository<SpecificType> {
    private static conn: SessionDb<SpecificType>;

    getConnection(): SessionDb<SpecificType> {
        if( SpecificRepository.conn === undefined) {
            // would need to know about enity somehow, either by storing this.entity 
            // or by having a static entity property on the class
            SpecificRepository.conn = SessionDb.connect(entity);
        }
        return SpecificRepository.conn;
    }
}

在这里，基类声明每个实体必须有一个方法getConnection，它返回一个正确类型T的SessionDb。我们已将该实现留给子类来解决。但是既然我们知道这个方法一定存在，那么基类在做this.model = this.getConnection().getModel(collectionName);的时候调用它是安全的