java - 使用每个子类方法创建工厂对象

我有一个简单的Factory（GenericFudge），它可以根据外部环境创建不同类型的对象。目前，我的代码如下所示：

abstract class Fudge {
    Fudge() {
    }
    void make() {
        System.out.println("made.");
    }
}

class VanillaFudge extends Fudge {
    @Override
    void make() {
        System.out.print("Vanilla ");
        super.make();
    }
}

class ChocolateFudge extends Fudge {
    @Override
    void make() {
        System.out.print("Chocolate ");
        super.make();
    }
}

class InvalidFlavorException extends Exception {};

// factory / proxy
public class GenericFudge {
    Fudge mFudge = null;
    GenericFudge(String flavor) throws InvalidFlavorException {
        if (flavor.equals("Chocolate")) {
            mFudge = new ChocolateFudge();
        } else if (flavor.equals("Vanilla")) {
            mFudge = new VanillaFudge();
        }
    }
    void make() {
        mFudge.make();
    }

    public static void main(String args[]) {
        for (String flavor : new String[] {"Chocolate", "Vanilla"}) {
            GenericFudge fudge;
            try {
                fudge = new GenericFudge(flavor);
                fudge.make();
            } catch (InvalidFlavorException e) {
                System.out.println("Sorry, we don't make that flavor");
            }
        }
    }
}

我的目标是从GenericFudge中获取巧克力和香草的详细信息，以便在实施CaramelFudge时无需更改GenericFudge。例如，GenericFudge将为每个xxxFudge类迭代地调用“ createIfItsMyFlavor（）”方法。 （在我的实际应用中，我必须反复尝试它们，但是我对其他可能性很感兴趣。）

我的本能是对每个子类（每个xxxFudge）使用一个静态初始化器，该初始化器通过调用GenericFudge的registerFudge方法将“自身”添加到列表中，但这遇到了鸡与蛋的问题（该类从未使用过，因此它是静态的）初始化程序永远不会被调用）。

毫无疑问，还有我没有想到的更好的方法。谢谢！

最佳答案

如果您正在使用像Spring这样的任何类型的依赖项注入系统，那么使用@PostConstruct即可轻松实现。如果这可行，那么您可以从用PostConstruct注释的方法中调用GenericFudge中的register方法。在GenericFudge中，您有一个地图，每当调用addType时，便将其添加到地图中。这样，您的GenericFudge保持不变，新的调用者将使用PostConstruct注册。为了进一步简化操作，您可以在基类Fudge中定义它，并使用构造函数传递该软糖名称，这样就不必在每个子类中声明register方法。

private String fudge;
public Fudge(final String fudge) {
    this.fudge = fudge;
}

@Autowired
private GenericFudge fudge;

@PostConstruct
private void register() {
    fudge.addType(fudge, this);
}

在GenericFudge中

private Map<String, Fudge> fudgeTypes = Maps.newHashMap();
public void register(final String fudgeType, final Fudge fudgeInstance) {
    fudgeTypes.put(fudgeType, fudgeInstance);
}

如果您不使用任何依赖项注入系统：
另一种方法是在基类Fudge中有一个静态方法，您可以在其中声明所有类型的软糖，然后根据请求返回一个实例。这样，您无需修改​​GenericFudge类，而只需修改Fudge的基类。这不是理想的选择，但是它使您不必修改GenericFudge类，并且无需在PostConstruct之类的“对象”中进行注册，而是在Map中添加了一个条目。

示例（来自Guava的ImmutableMap，您可以随意声明地图，这仅用于示例）：

public abstract class Fudge {
    private static final Map<String, Fudge> FUDGE_TYPES = ImmutableMap.of(
        "Type1", new Type1Fudge(),
        "Type2", new Type2Fudge()
        // Add new entry when implemented
    );

    public static Fudge getFudge(final String fudge) {
        if (FUDGE_TYPES.containsKey(fudge)) {
            return FUDGE_TYPES.get(fudge);
        } else {
            // handle missing fudge depending on your preference
        }
    }
}