我必须调用多个具有多个 API 的服务。他们中很少有人基本上被读取(他们返回一些数据)，他们中很少有人改变几个对象的状态(他们基本上更新了几个对象的状态)。

我正在寻找可以应用于上述场景的设计模式。

代码示例

让我们举一个服务A的小例子

AccountInfo A.getAccountInfo() 
void A.setAccountData(AccountInfo) 
AccountStatus A.getStatusForAccount 

...

我想到了一个通用接口(interface)

interface CallAPI<Input , Output> {
   public Output execute(Input)
}

每个 API 调用都会实现这个接口(interface)，我可以使用工厂模式来获取 API 的实例。

我想知道是否有更好的模式或者可以用不同的方式重构。 API 和服务只会增加，设置新的 API 应该会更容易，客户不应该有额外的开销来为新的 API 编写适配器。

最佳答案

最好的方法是从数据库、基础结构细节等不可知的可靠设计开始。方法是使用 FactoryMethod，如果想创建一个对象系列，请使用抽象工厂，这样您就可以拥有 SqlFamily 对象、JsonFamily 对象等等 然后你可以创建业务规则，你可以使用多个服务，做一些更有趣的事情。好的设计意味着使用多种设计模式，因此除了工厂之外，还可以选择使用模板方法进行代码重用，以及策略模式等。这是您可以在其中识别上面讨论的不同设计模式的代码:

public interface IRead<T>
{
    T Fetch();
}

public abstract class ServiceA
{
    public abstract void OperationA();
    public abstract void OperationB();
}

public abstract class ServiceB
{
    public abstract void OperationD();
    public abstract void OperationE();
}

public abstract class JsonServiceAReaderTemplate : IRead<ServiceA>
{
    public abstract ServiceA Fetch();
}

public sealed class JsonServiceAFetcher : JsonServiceAReaderTemplate
{
    /// <summary>
    /// Get parameters needded to load from json
    /// </summary>
    public JsonServiceAFetcher()
    {

    }
    public override ServiceA Fetch()
    {
        //Load from Json store
        throw new NotImplementedException();
    }
}

public abstract class JsonServiceBReaderTemplate : IRead<ServiceB>
{
    public abstract ServiceB Fetch();
}

public sealed class JsonServiceBFetcher : JsonServiceBReaderTemplate
{
    /// <summary>
    /// Get parameters needded to load from json
    /// </summary>
    public JsonServiceBFetcher()
    {

    }
    public override ServiceB Fetch()
    {
        //Load from Json store
        throw new NotImplementedException();
    }
}

public sealed class ServicesGateway
{
    public ServiceA ServiceA { get; }
    public ServiceB ServiceB { get; }

    public ServicesGateway(IRead<ServiceA> serviceA, IRead<ServiceB> serviceB)
    {
        ServiceA = serviceA.Fetch();
        ServiceB = serviceB.Fetch();
    }
}

public interface IBusinessRule
{
    void Execute();
}

public sealed class BusinessRuleServiceAServiceB : IBusinessRule
{
    private readonly ServicesGateway servicesGateway;

    public BusinessRuleServiceAServiceB(ServicesGateway servicesGateway)
    {
        this.servicesGateway = servicesGateway;
    }

    public void Execute()
    {
        var serviceA = servicesGateway.ServiceA;
        var serviceB = servicesGateway.ServiceB;
        serviceA.OperationA();
        serviceA.OperationB();
        serviceB.OperationD();
        serviceB.OperationE();
    }
}

public sealed class ClientCode
{
    public void Run()
    {
        //Inject from IoC
        ServicesGateway gateway = new ServicesGateway(new JsonServiceAFetcher(), new JsonServiceBFetcher());
        var businessRule = new BusinessRuleServiceAServiceB(gateway);
        businessRule.Execute();
    }
}

希望这对您有所帮助!

关于java - 多个 API 调用 : Design Patterns，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/37755525/