最好的方法是这样的：

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 FactoryProducer<T> getFactory(String key) {
    return producers.get(key);
  }
}

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

使用Java SPI。

在模型C中定义接口com.modelc.ThirdPartyCallsStrategy。

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

字符串

在模型A和模型B中实现ThirdPartyCallsStrategy。

public class AStrategy implements ThirdPartyCallsStrategy {
    public void apply(String orderId) {
        // Do something here.
    }
    public String type() {
        return "A";
    }
}
public class BStrategy implements ThirdPartyCallsStrategy {
    public void apply(String orderId) {
        // Do something different here.
    }
    public String type() {
        return "B";
    }
}

型

在META-INF中注册实现。

在模型A resources/META-INF/services/com.modelc.ThirdPartyCallsStrategy的文件中：

com.modela.AStrategy

型
在型号B resources/META-INF/services/com.modelc.ThirdPartyCallsStrategy的文件中：

com.modelb.BStrategy

型

在模型C中创建工厂。

public class CoreCallsFactory {
    private final Map<String, ThirdPartyCallsStrategy> strategyMap;
    public CoreCallsFactory() {
        strategyMap = new HashMap<>();
        ServiceLoader<ThirdPartyCallsStrategy> strategies = ServiceLoader.load(ThirdPartyCallsStrategy.class);
        for (ThirdPartyCallsStrategy strategy : strategies) {
            strategyMap.put(strategy.type(), strategy);
        }
    }
    public ThirdPartyCallsStrategy createThirdPartyCallsStrategy(String type) {
        ThirdPartyCallsStrategy strategy = strategyMap.get(type);
        if (strategy == null) {
            throw new IllegalArgumentException("There is no strategy for this type: " + type);
        }
        return strategy;
    }
}

型
模型A和B依赖于模型C中的接口，但模型C不知道模型A或B。