Chiamate API multiple: Design Patterns

Question

Devo chiamare più servizi con più API. Pochi di loro sono fondamentalmente letti (mi restituiscono alcuni dati) e pochi cambiano lo stato di diversi oggetti (in pratica aggiornano lo stato dei vari oggetti).

Sto cercando un design pattern che può essere applicato allo scenario di cui sopra.

Esempio di codice

consente di dare un piccolo esempio di un servizio Una

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

...

ho pensato di avere una generica interfaccia

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

Ogni Chiamata API implementerebbe questa interfaccia e I c un modello di fabbrica utilizza per ottenere istanze delle API.

Vorrei sapere se esiste un modello migliore per lo stesso o può essere riscritta in modo diverso. Le API e i servizi aumenterebbero e dovrebbe essere più semplice impostare nuove API e i client non dovrebbero avere un overhead aggiuntivo per scrivere adattatori per le nuove API.

Answer 1

L'approccio migliore sarebbe iniziare con solido design agnostico da database, dettagli di infrastruttura, ecc. La strada da percorrere è con FactoryMethod e se si desidera creare una famiglia di oggetti utilizzare factory astratto in modo da poter disporre di oggetti SqlFamily, JsonFamily oggetti, ecc. Quindi è possibile creare regole aziendali figlio che è possibile utilizzare più servizi, fare qualcosa di più interessante. Agood disegno implica l'utilizzo di più modelli di desing, quindi un'opzione anche farebbe in aggiunta alle fabbriche, utilizzando il modello methos per il riutilizzo del codice, anche modello di strategia, ecc Qui è il codice in cui è possibile identificare diversi modelli desing discutono sopra al suo posto:

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(); 
    } 
} 

Spero che questo aiuti!