Question

我试图找到一种易于扩展的方法来在运行时基于静态String类属性（称为NAME）创建对象。

如何改进此代码，它使用简单的if构造？

public class FlowerFactory {

private final Garden g;

public FlowerFactory(Garden g) {
  this.g = g;
}

public Flower createFlower(final String name) {
    Flower result = null;

   if (Rose.NAME.equals(name)) {
       result = new Rose(g);
   } else if (Oleander.NAME.equals(name)) {
       result = new Oleander(g);
   } else if ... { ... } ...

   return result;
}

除非删除构造函数参数，否则不能在这些类上使用

newInstance（）。我应该构建所有支持的花类引用的映射（Map），并将contructor参数移动到属性setter方法，还是有其他简单的解决方案？

背景信息：我的目标是通过FlowerFactory.getInstance().register(this.NAME, this.class)实现某种新的Flower类的“自我注册”，这意味着从目前为止的非常好的答案来看，基于内省的解决方案最适合。

Answer 1

一种可能性是使用枚举。在最简单的层面上，您可以用枚举值替换Rose.NAME之类的常量，并维护枚举值和类之间的内部映射以实例化：

public enum Flowers {
    ROSE(Rose.class),
    OLEANDER(Oleander.class);

    private final Class<? extends Flower> flowerClass;

    Flowers(Class<? extends Flower> flowerClass) {
        this.flowerClass = flowerClass;
    }

    public Flower getFlower() {
        Flower flower = null;
        try {
            flower = flowerClass.newInstance();
        } catch (InstantiationException e) {
            // This should not happen
            assert false;
        } catch (IllegalAccessException e) {
            // This should not happen
            assert false;
        }
        return flower;
    }
}

由于花类类没有默认构造函数，因此无法使用Class.newInstance()，因此通过反射实例化类更麻烦（尽管可能）。另一种方法是使用Prototype来创建新的花卉实例。

这已经确保您始终保持可能的花名和实际花类之间的映射同步。添加新花类时，必须创建新的枚举值，其中包括用于创建新类实例的映射。但是，enum aproach的问题是您使用的Garden实例在启动时是固定的。（除非你将它作为参数传递给getFlower() - 但是这样就有可能失去连贯性，即确保在特定的花园中创建一组特定的鲜花更难。）

如果您想要更灵活，可以考虑使用Spring将名称和具体（bean）类之间的整个映射移动到配置文件中。然后，您的工厂只需在后台加载Spring ApplicationContext并使用其中定义的映射。每当你引入一个新的花子类时，你只需要在配置文件中添加一个新行。但是，这种方法最简单，需要您在配置时修复Garden bean实例。

如果您想在运行时在不同的花园之间切换，并确保花园和花卉组之间的一致性，工厂使用内部地图名称来花卉类可能是最佳选择。虽然映射本身可以再次存储在配置中，但您可以在运行时使用不同的Garden实例实例化不同的工厂实例。

Answer 2

尽管有一个构造函数参数，你仍然可以使用反射：

Rose.class.getConstructor(Garden.class).newInstance(g);

结合静态名称到类映射，可以这样实现：

// TODO handle unknown name
FLOWERS.get(name).getConstructor(Garden.class).newInstance(g);

可以在静态初始化程序块中填充花：

static {
  Map<String, Class<? extends Flower>> map = new HashMap<String, Class<? extends Flower>>();
  map.put(Rose.NAME, Rose.class);
  // add all flowers
  FLOWERS = Collections.unmodifieableMap(map);
}

Answer 3

您可以使用带有抽象工厂方法的枚举：

public enum FlowerType{
  ROSE("rose"){
    public Rose createFlower(Garden g){
      return new Rose(g);
    }
  },
  OLEANDER("oleander"){
    public Oleander createFlower(Garden g){
      return new Oleander(g);
    }
  };
  private final static Map<String, FlowerType> flowerTypes = new HashMap<String, FlowerType>();
  static {
    for (FlowerType flowerType : values()){
      flowerTypes.put(flowerType.getName(), flowerType); 
  }
  private final String name;
  protected FlowerType(String name){
    this.name = name;
  }
  public String getName(){
    return name;
  }  
  public abstract Flower createFlower(Garden g);
  public static FlowerType getFlower(String name){
    return flowerTypes.get(name);
  }
}

我不能说这是否是你个案中最好的方式，因为我的信息很少。

Answer 4

除了使用枚举或映射之外，如果存在名称到类的简单映射，则可以使用反射。

public Flower createFlower(final String name) {
   try {
      Class clazz = Class.forName("mypackage.flowers."+name);
      Constructor con = clazz.getConstructor(Garden.class);
      return (Flower) con.newInstance(g);
   } catch (many exceptions) {
      throw new cannot create flower exception.
   }
}

Answer 5

我建议从工厂对象中删除状态，并将 Garden 对象作为参数传递给静态工厂方法：

public class FlowerFactory {

private FlowerFactory() {}

public static Flower createFlower(final String name, Garden g) {
    Flower result = null;

   if (Rose.NAME.equals(name)) {
       result = new Rose(g);
   } else if (Oleander.NAME.equals(name)) {
       result = new Oleander(g);
   } else if ... { ... } ...

   return result;
}

Answer 6

您也可以通过将字符串名称存储在地图中来避免一系列if / elses。

Map<String, Class> map;
map.get(name).newInstance();

如果您可以完全控制类，则可以直接使用字符串名称中的反射执行实例化，例如，

Class.forName(name);

除此之外，您还可以尝试依赖注入框架。其中一些提供了从字符串名称检索对象实例的功能。

Answer 7

如果所有Flower具有相同的构造函数签名，则可以使用反射在构造函数上设置参数。

显然这是进入依赖注入的领域，但也许这就是你正在做的事情：）

如果你的构造函数中有很多不同的参数，如果这样做是安全的，你可以使用每个参数的类型来查找要传入的实例，就像Guice所做的那样。

使用一个通用工厂方法创建实例

7 个答案: