एकाधिक एपीआई कॉल: डिज़ाइन पैटर्न

Question

मुझे एकाधिक एपीआई वाले कई सेवाओं को कॉल करना होगा। उनमें से कुछ मूल रूप से पढ़े जाते हैं (वे मुझे कुछ डेटा लौटाते हैं) और उनमें से कुछ कई वस्तुओं की स्थिति बदलते हैं (वे मूल रूप से कई वस्तुओं की स्थिति को अद्यतन करते हैं)।

मैं design pattern की तलाश में हूं जो उपरोक्त परिदृश्य पर लागू किया जा सकता है।

कोड उदाहरण

चलें एक सेवा का एक छोटा सा उदाहरण लेते एक

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

...

मैं एक जेनेरिक इंटरफ़ेस

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

प्रत्येक होने के बारे में सोचा एपीआई कॉल इस इंटरफेस को लागू करेगा और मैं सी एपीआई के उदाहरण प्राप्त करने के लिए फैक्टरी पैटर्न का उपयोग करें।

मैं जानना चाहता हूं कि इसके लिए एक बेहतर पैटर्न है या इसे अलग तरीके से दोबारा किया जा सकता है। एपीआई और सेवाएं केवल बढ़ेगी और नए एपीआई स्थापित करना आसान होना चाहिए और ग्राहकों को नए एपीआई के लिए एडेप्टर लिखने के लिए अतिरिक्त ओवरहेड नहीं होना चाहिए।

Answer 1

सबसे अच्छा तरीका डाटाबेस, इन्फ्रास्ट्रक्चर विवरण इत्यादि से ठोस डिजाइन अज्ञेयवादी के साथ शुरू करना होगा। जाने का तरीका फैक्टरी मोड के साथ है और यदि वस्तुओं का एक परिवार बनाना चाहते हैं तो अमूर्त फैक्ट्री का उपयोग करें ताकि आप एसक्लफैमिली ऑब्जेक्ट्स, जेसनफैमिली ऑब्जेक्ट्स इत्यादि। फिर आप व्यवसाय नियमों का बेटा बना सकते हैं, आप कई सेवाओं का उपयोग कर सकते हैं, कुछ और दिलचस्प बना सकते हैं। एगूड डिज़ाइन का मतलब कई desing पैटर्न का उपयोग करना है, इसलिए एक विकल्प भी कोड पुन: उपयोग करने के लिए टेम्पलेट मेथोस का उपयोग करके कारखानों के अतिरिक्त होगा, रणनीति पैटर्न इत्यादि। यहां वह कोड है जहां आप अलग-अलग desing पैटर्न की पहचान कर सकते हैं:

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

आशा है कि इससे मदद मिलती है!