抽象工厂设计模式和泛型 - Java

Question

这是我第一次使用this design pattern，我遇到了一些困难。以此图为参考：

我有两个 AbstractProduct 我想为其创建一个工厂，因为它们属于不同的“家族”。一种产品是另一种产品的集合。

public abstract class Frame{
    ...
}

public abstract class FrameMap<F extends Frame>{
    protected TreeMap<Integer, F> map;

    public F readByKey(Integer key){
        return this.map.get(key);
    }

    public void put(Integer key, F frame){
        this.map.put(key,frame);
    }
    ...
}

注意FrameMap 是F 的集合（为简单起见，我省略了大部分其他方法），因此它需要能够获取和放置元素。 以一个家庭为例（App1 的那个）这些是具体的产品：

public class App1Frame extends Frame{
    ...
}

public class App1FrameMap extends FrameMap<App1Frame>{
    ...
}

然后我创建了AbstractFactory：

public abstract class ApplicationFactory{
    //Frame factory methods
    public abstract Frame makeFrame();

    //FrameMap factory methods
    public abstract FrameMap<? extends Frame> makeFrameMap();
}

以及 App1 的 ConcreteFactory：

public class App1Factory extends ApplicationFactory{
    //Frame factory methods
    public Frame makeFrame(){
        return new App1Frame();
    }

    //FrameMap factory methods
    public FrameMap<App1Frame> makeFrameMap(){
        return new App1FrameMap();
    }
}

所有这些都可以编译，但我不太喜欢它，因为我的客户无法执行以下操作：

ApplicationFactory factory = new App1Factory();
FrameMap<Frame> frameMap = factory.makeFrameMap(); //This doesn't compile!

至少在概念上，这是该模式的目标，即让客户端只使用抽象类。为了让它工作，我必须做这样的事情：

App1Factory factory = new App1Factory();
FrameMap<App1Frame> frameMap = factory.makeFrameMap(); //This compiles!

这似乎违背了使用设计模式的目的。

您是否知道在像我这样的情况下实现此模式的更好方法，即在 AbstractProduct 中使用泛型，以便让客户端只使用抽象类而不知道底层实现？

Answer 1

您可以将泛型类型添加到ApplicationFactory。

public class MainJava {
    interface Frame{}
    interface FrameMap<T extends Frame>{}

    static class App1Frame implements Frame{}
    static class App2Frame implements Frame{}
    static class App1FrameMap implements FrameMap<App1Frame>{}
    static class App2FrameMap implements FrameMap<App2Frame>{}

    interface ApplicationFactory<T extends Frame> {
        T makeFrame();
        FrameMap<T> makeFrameMap();
    }

    static class App1Factory implements ApplicationFactory<App1Frame> {
        @Override public App1Frame makeFrame() {
            return new App1Frame();
        }
        @Override public FrameMap<App1Frame> makeFrameMap() {
            return new App1FrameMap();
        }
    }

    public static void main(String... args) {
        ApplicationFactory<? extends Frame> factory = new App1Factory();
        Frame frame = factory.makeFrame();
        FrameMap<? extends Frame> map = factory.makeFrameMap();
    }
}

还要注意ApplicationFactory 对象应该是injected 进入客户端。如果客户端直接调用new App1Factory()，那么抽象是没有意义的。客户端还不如在创建后使用App1Factory。

Answer 2

除了@jaco0646 解决方案，还有一种简单的方法可以解决将新创建的框架添加到地图的问题，即使您在运行时不知道实际的子类型或“族”。只要您可以将 frame 和 frame-map 类型参数绑定为在这样的方法中具有相同的值：

public static <T extend Frame> FrameMap<T> makeAndAdd(final AbstractFactory<T> factory) {
    T frame = factory.makeFrame();
    FrameMap<T> map = factory.makeFrameMap();
    map.add(frame);
    return map;
}

当不可能将两个动作放在同一个方法中时（例如，在不同的服务器调用上异步发生）。您仍然可以通过使用另一个具有类型参数并且具有这些操作的不同方法的类来实现这种联系......这有点复杂，需要根据实际问题进行调整，但想法是相同的从某种意义上说，您使用类型参数来绑定在运行时赋予不同对象的类型参数值。