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

फ़ैक्टरी क्या है?

फ़ैक्टरी ऑब्जेक्ट बनाने के लिए एक इंटरफ़ेस को परिभाषित करती है, लेकिन ठोस वर्ग को तत्काल बनाने की ज़िम्मेदारी उपवर्गों को सौंपती है। यह वियुग्मित और लचीले तरीके से वस्तुओं के निर्माण को बढ़ावा देता है, जिससे कोड अधिक मॉड्यूलर और बनाए रखने में आसान हो जाता है।

फ़ायदे

• डिकॉउलिंग: वस्तुओं के निर्माण को उनके कार्यान्वयन से अलग करता है, स्वच्छ और अधिक मॉड्यूलर कोड को बढ़ावा देता है।
• लचीलापन: मौजूदा कोड को संशोधित किए बिना नई कक्षाएं शुरू करना आसान बनाता है।
• रखरखाव: कोड को बनाए रखना और विकसित करना आसान बनाता है, क्योंकि निर्माण तर्क एक ही स्थान पर केंद्रीकृत है।

एक फैक्ट्री का कार्यान्वयन

आइए फ़ैक्टरी पैटर्न को स्पष्ट करने के लिए एक रोजमर्रा के उदाहरण का उपयोग करें: भोजन ऑर्डर करने के लिए एक प्रणाली, जहां कुछ अलग प्रकार के भोजन (पिज्जा और सलाद) बनाए जा सकते हैं।

1 - इंटरफ़ेस बनाना

सबसे पहले, हमें एक इंटरफ़ेस परिभाषित करने की आवश्यकता है जिसे भोजन के सभी "ठोस वर्गों" द्वारा कार्यान्वित किया जाएगा।

package main

type Food interface {
    Prepare()
}

2 - एक ENUM बनाना और इंटरफ़ेस लागू करना

विकास के दौरान हमारे जीवन को आसान बनाने और सत्यापन के दौरान कुछ गलत टाइप करने से बचने के लिए, एक अच्छा अभ्यास यह है कि एकरूपता बनाए रखने के लिए एक ENUM बनाया जाए और अगर हम भविष्य में नए खाद्य पदार्थ जोड़ना चाहते हैं तो इसे भी आसान बनाएं।

package main

type FoodType int

const (
    PizzaType FoodType = iota
    SaladType
)

type Food interface {
    Prepare()
}

और अब फ़ूड इंटरफ़ेस लागू करें। उदाहरण में हम केवल एक संदेश प्रदर्शित करेंगे, वास्तविक जीवन में यह वह जगह है जहां हम जिस वस्तु पर काम कर रहे हैं वह बनाई जाएगी

package main

type FoodType int

const (
    PizzaType FoodType = iota
    SaladType
)

type Food interface {
    Prepare()
}

type Pizza struct{}

func (p Pizza) Prepare() {
    fmt.Println("Preparing a Pizza...")
}

type Salad struct{}

func (s Salad) Prepare() {
    fmt.Println("Preparing a Salad...")
}

3 - फ़ैक्टरी बनाना

अब, आइए एक फैक्ट्री बनाएं जो यह तय करेगी कि पैरामीटर के रूप में प्राप्त एनम के आधार पर किस ठोस वर्ग को तुरंत चालू करना है।

package main

type FoodFactory struct{}

func (f FoodFactory) CreateFood(ft FoodType) Food {
    switch ft {
    case PizzaType:
        return &Pizza{}
    case SaladType:
        return &Salad{}
    default:
        return nil
    }
}

4 - फ़ैक्टरी का उपयोग करना

आखिरकार, हम अपना भोजन बनाने के लिए कारखाने का उपयोग करेंगे।

package main

func main() {
    kitchen := FoodFactory{}

    pizza := kitchen.CreateFood(PizzaType)
    if pizza != nil {
        pizza.Prepare()
    }

    salad := kitchen.CreateFood(SaladType)
    if salad != nil {
        salad.Prepare()
    }
}

हमारे एप्लिकेशन को चलाने के बाद यह परिणाम होगा:

Preparing a Pizza...
Preparing a Salad...

हमने जो किया उसका सारांश

1. खाद्य इंटरफ़ेस: उस अनुबंध को परिभाषित करता है जिसका पालन सभी ठोस भोजन को करना चाहिए, यह सुनिश्चित करते हुए कि वे सभी तैयारी विधि को लागू करते हैं।
2. एनम फूडटाइप: विभिन्न प्रकार के भोजन का प्रतिनिधित्व करने, कोड पठनीयता और सुरक्षा बढ़ाने के लिए टाइप किए गए स्थिरांक का उपयोग करता है।
3. कंक्रीट कक्षाएं (पिज्जा और सलाद): खाद्य इंटरफ़ेस लागू करें और तैयारी विधि का अपना कार्यान्वयन प्रदान करें।
4. फ़ूडफ़ैक्टरी: इसमें ऑब्जेक्ट निर्माण तर्क शामिल है। CreateFood विधि फ़ूडटाइप एनम के आधार पर यह तय करती है कि किस ठोस वर्ग को तुरंत चालू करना है।
5. मुख्य विधि: विभिन्न वस्तुओं को बनाने और उनके तरीकों को कॉल करने के लिए फैक्ट्री के उपयोग को प्रदर्शित करता है, फैक्ट्री पैटर्न द्वारा प्रदान किए गए लचीलेपन और डिकॉउलिंग को दर्शाता है।

निष्कर्ष

फ़ैक्टरी डिज़ाइन पैटर्न ऑब्जेक्ट निर्माण में डिकॉउलिंग और लचीलेपन को बढ़ावा देने के लिए एक शक्तिशाली उपकरण है। गोलांग में, इस पैटर्न का कार्यान्वयन प्रत्यक्ष और प्रभावी है, जिससे मॉड्यूलर और आसानी से बनाए रखने वाले सिस्टम के निर्माण की अनुमति मिलती है। इंटरफेस और फ़ैक्टरियों का उपयोग करके, हम निर्माण तर्क को केंद्रीकृत कर सकते हैं और नई आवश्यकताएं सामने आने पर कोड विकास को सरल बना सकते हैं।