Java 工厂模式

Question

我有模块 A 和模块 B，每个模块都有一些特定的服务，我有一个模块 C，它对 A 和 B 没有任何依赖关系，所以我想要的是从模块 A 和 B 调用服务，我想实现这一目标使用工厂模式。

在模块C中我创建了这个接口，它将成为模块A和B中实现的通用接口

public interface ThirdPartyCallsStrategy {
    void apply(String orderId);
}

这是工厂类的示例，将根据类型参数提供所需的适当实例

@Component
@AllArgsConstructor
public class CoreCallsFactory {

    private static final String A_PACKAGE = "com.testA.service";
    private static final String A_CLASS = "TestClassA";


    private static final String B_PACKAGE = "com.testB.service";
    private static final String B_CLASS = "TestClassA";


    @SneakyThrows
    public ThirdPartyCallsStrategy createThirdPartyCallsStrategy(String type) {

        Class<?> clazz;
        if (type.equals("A")) {
            clazz = Class.forName(String.format("%s.%s", A_PACKAGE , A_CLASS ));
            return (ThirdPartyCallsStrategy) clazz.getDeclaredConstructor().newInstance();
        }

        if (type.equals("B")) {
            clazz = Class.forName(String.format("%s.%s", B_PACKAGE , B_CLASS ));
            return (ThirdPartyCallsStrategy) clazz.getDeclaredConstructor().newInstance();
        }
        return null;
    }
}

ThirdPartyCallsStrategy在不同模块的不同服务中实现

最后在模块 C 中，我通过 java 反射进行实例化，但这将在运行时进行，并且可以稍后在运行时而不是在编译时通过异常

public String checkStatusAndRedirect(String orderId, String type) {
        boolean status = checkStatus(orderId);
        StringBuilder paymentResultUrl = new StringBuilder(frontUrl + "/public/payment/status?success=");

        if (status) {
            coreCallsFactory.createThirdPartyCallsStrategy(type).apply(orderId);
            paymentResultUrl.append(Boolean.TRUE);
        } else {
            paymentResultUrl.append(Boolean.FALSE);
        }
        return paymentResultUrl.toString();
    }

所以我需要的是一种更干净的方法来改变这个实现

Answer 1

最好的方法是：

public interface FactoryProducer<T> {
  public T create(String param);
}

public class Factory<T> {
  Map producers = new HashMap<string, FactoryProducer<T>>();
  public void registerFactory(String key, FactoryProducer<T> producer) {
    producers.put(key, producer);
  }
  public Factory<T> getFactory(String key) {
    return producers.get(key);
  }
}

通过这种方式，您可以构建 FactoryProducers 和 Factory 并保持一切解耦。