java - 具有泛型和反射的可扩展工厂类

Question

有一个类MyFactory，它创建一个MyObject。 实例化是使用反射完成的，接下来的 setter 被调用。 按照我们的约定，MyObject 类需要有一个公共(public)默认构造函数(即不带参数)。

我们的 MyFactory 看起来像这样:

public class MyFactory extends AbstractFactory<MyObject>
{
  public MyFactory()
  {
    super(MyObject.class);    
  }

  @Override
  public MyObject createObject()
  {
    MyObject objt = super.createObject();
    objt.setStuff(stuff);
    return objt;
  }
}

它使用一个简单的抽象工厂:

public abstract class AbstractFactory <T>
{
  private Class<? extends T> clazz;

  public AbstractFactory(Class<? extends T> clazz)
  {
    this.clazz = clazz;
  }

  public T createObject()
  {
    return clazz.newInstance();
  }
}

当人们想要重写工厂来创建扩展 MyObject 的对象(例如 MyExtendedObject)时，问题就开始了。 我们添加了一个构造函数来促进这一点。

protected MyFactory(Class<? extends MyObject> clazz)
{
  super(clazz);
}

首先，这足以创建扩展工厂，例如:

public class MyExtendedFactory extends MyFactory
{
  public MyExtendedFactory()
  {
    super(MyExtendedObject.class);
  }

  @Override
  public MyObject createObject()
  {  
    // and this is a bit uggly
    MyExtendedObject objt = (MyExtendedObject) super.createObject();
    objt.setExtendedStuffToo(extendedStuff);
    return objt;
  }
}

所以，一切正常，但很明显人们想使用泛型。因此，我们尝试提供泛型。然后事情开始变得复杂。

public class MyFactory <O extends MyObject> extends AbstractFactory<O>
{
  public MyFactory()
  {
    // but now this is uggly and not really correct.
    super(Class<O> extends MyObject.class);    
  }

  protected MyFactory(Class<O> clazz)
  {
    super(clazz);
  }

  @Override
  public O createObject()
  {
    O objt = super.createObject();
    objt.setStuff(stuff);
    return objt;
  }
}

问题是，人们实际上可以重写这个类，但是有一个隐藏的陷阱。他们不应该调用默认构造函数。事实上，整个构造函数设计在这里看起来很糟糕。

知道如何改进吗？ 我感觉必须有一个最佳实践或模式来解决这个问题。

Answer 1

不允许使用无参数构造函数。这没有任何用处。

只需删除它:

public class MyFactory <O extends MyObject> extends AbstractFactory<O>
{    
  protected MyFactory(Class<O> clazz)
  {
    super(clazz);
  }

  @Override
  public O createObject()
  {
    O objt = super.createObject();
    objt.setStuff(stuff);
    return objt;
  }
}

但说实话，为什么会有这样一个类存在呢？只需为每个子类创建一个工厂类即可:

public class MyFactorySub <MyObjectSubclass> extends AbstractFactory<MyObjectSubclass>
{    
  public MyFactorySub()
  {
    super(MyObjectSubclass.class);
  }

  @Override
  public MyObjectSubclass createObject()
  {
    MyObjectSubclass objt = super.createObject();
    objt.setStuff(stuff);
    return objt;
  }
}