Question

假设我有工厂类FactoryA和FactoryB的接口，分别用于生成类型为A和B的对象的方法，并假设我有这些接口的实现。现在假设我需要一个实现两个接口的工厂类FactoryAB，即产生A和B。是否有一种简单的方法可以将接口FactoryA和FactoryB的实现结合起来以获得FactoryAB？

修改这是由于一个类需要大量工厂来生产大量不同对象的情况。在这种情况下，在我看来只有一个大型工厂可以更方便地生成所有需要的组件，而不必跟踪许多小型工厂。

主要目标是不必编写太多代码来实现这一目标。也许，其他一些模式更适合这种情况？

EDIT2： 基本上我想从像以下那样臃肿的代码开始：

public class Consumer {
 FactoryA factoryAImpl;
 FactoryB factoryBImpl;
 // ...
 FactoryY factoryYImpl;
 FactoryZ factoryZImpl;

 public Consumer(FactoryA factoryA, FactoryB factoryB, ..., FactoryZ factoryZ) {
   // ...
 }
 //...
}

拥有紧凑/简单的代码，如：

public class Consumer {
 FactoryAtoZ factoryAtoZImpl;

 public Consumer(FactoryAtoZ factoryAtoZ) {
   // ...
 }
 //...
}

Answer 1

你可以用Composition：

来做

public class FactoryAB implements FactoryA, FactoryB
{
   FactoryA factoryAImpl = new FactoryAImplementor();
   FactoryB factoryBImpl = new FactoryBImplementor();

   public ObjectA getObjectA()  {
        return factoryAImpl.getObjectA();
   }

   public ObjectB getObjectB()  {
        return factoryBImpl.getObjectB();
   }
}

Answer 2

你可以通过动态生成代理并将方法调用委托给具体对象来做到这一点，当且仅当你有一个可靠的方法来确定哪个委托手这个到了。

首先，您需要一个结合现有工厂的界面

public interface FactoryAB extends FactoryA, FactoryB {
}

（注意缺少方法）

然后你需要创建代理

    DelegatingHandler handler = new DelegatingHandler(new ConcreteFactoryA(), new ConcreteFactoryB());
    FactoryAB factoryAb = (FactoryAB)Proxy.newProxyInstance(handler.getClass().getClassLoader(), new Class[]{FactoryAB.class}, handler);

最后InvocationHandler为你做实际的方法拦截

public class DelegatingHandler implements InvocationHandler {
    private final List<Object> factoryDelegates;

    public DelegatingHandler(Object ... factories) {
        factoryDelegates = Arrays.asList(factories);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        for (Object factory : factoryDelegates) {
            Method[] declaredMethods = factory.getClass().getDeclaredMethods();
            for (Method declaredMethod : declaredMethods) {
                if (declaredMethod.getReturnType().equals(method.getReturnType())) {
                    return method.invoke(factory, args);
                }
            }
        };
        return null;
    }
}

这通过提供要委托的具体工厂的列表来工作，并且在每个方法调用中查看这些工厂以找到具有与返回类型匹配的方法的工厂。当它找到一个它将调用你在委托工厂调用的方法并返回它返回的任何内容。

我怀疑你可能需要更多的参与检查以找到合适的代表，但只有你知道。

使用此功能，您只需添加到FactoryAB界面并将所需的委托注入DelegatingHandler，即可向您的代理添加新工厂，无需进一步的工作。

您应该注意，使用此方法，您的所有通话现在都通过反射路由而不是直接方法调用

Answer 3

您可以使用复合概念和工厂方法模式来合并FactoryA和FactoryB接口。假设您有一个公共接口AB和public A getA() FactoryA的工厂方法和public B getB() FactoryB的工厂方法：

public class ABFactory implements FactoryA, FactoryB {
    public AB GetAB(InterfaceType type) {
        AB implementation = null;
        switch (type)
        {
            case InterfaceType.AType:
                implementation = getA();
                break;
            case InterfaceType.BType:
                implementation = getB();
                break;
            default:
                break;
        }
        return implementation;
    }
   public A getA() {
      return new FactoryAImpl().getA();
   }

   public B getB() {
      return new FactoryBImpl().getB();
   }

}

假设

public enum InterfaceType {
    AType,
    BType
}

是否有一种简单的方法将工厂与Java结合起来？

3 个答案: