सिंपल फ़ैक्टरी क्या है?

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

सरल फ़ैक्टरी को अक्सर फ़ैक्टरी पैटर्न के साथ भ्रमित किया जाता है। हम उनके अंतर को स्पष्ट करने के लिए सरल कारखाने का अध्ययन करने जा रहे हैं। साथ ही, सिंपल फैक्ट्री सीखने से हमें फैक्ट्री पैटर्न को आसानी से समझने में मदद मिलती है।

सिंपल फ़ैक्टरी किस समस्या का समाधान कर सकती है?

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

संकट

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

हमारा पहला प्रयास इस प्रकार होगा:

// Client orders a burger
Burger orderBurger(String type) {
    Burger burger;

    if (type.equals("beef")) {
        burger = new BeefBurger();
    } else if (type.equals("chicken")) {
        burger = new ChickenBurger();
    } else if (type.equals("fish")) {
        burger = new FishBurger();
    }

    burger.prepareBun();
    burger.grillPatty();
    burger.addToppings();
    burger.wrap();

    return burger;
}

समस्या यह है कि हम कार्यान्वयन के लिए कोडिंग कर रहे हैं, इंटरफ़ेस के लिए नहीं। कहाँ? हम if स्टेटमेंट का उपयोग करते हैं और बर्गर प्रकार के आधार पर एक ठोस वर्ग को इंस्टेंट करते हैं।
यह समस्या क्यों है? हमारा क्लाइंट कोड ऑब्जेक्ट निर्माण के साथ मजबूती से जुड़ा हुआ है, जिससे लचीलापन कम हो गया है!! मान लीजिए कि हम अब मछली बर्गर नहीं बेचते हैं, और वेजी बर्गर बेचना शुरू कर देते हैं। हमें अपने क्लाइंट कोड पर जाकर उसे संशोधित करना होगा। कहने का तात्पर्य यह है कि यह संशोधन के लिए बंद नहीं है।

समाधान

समस्या को हल करने के लिए, हम अलग वर्ग बना सकते हैं जो केवल ऑब्जेक्ट निर्माण के लिए जिम्मेदार होगा। तब हमारे क्लाइंट कोड को ऑब्जेक्ट निर्माण के बारे में चिंता करने की आवश्यकता नहीं है और वह अमूर्तता पर निर्भर रहने में सक्षम है। इस तकनीक को "जो बदलता है उसे एनकैप्सुलेट करें" के रूप में जाना जाता है। हम उम्मीद करते हैं कि ठोस वस्तुओं को इंस्टेंट करने के बारे में कोड बार-बार बदला जाएगा, जबकि भविष्य में सभी बर्गर के बीच तैयारबुन(), ग्रिलपैटी(), ऐडटॉपिंग्स(), रैप() प्रक्रियाएं समान रहने की संभावना है।
सिंपल फ़ैक्टरी का लाभ यह है कि यह अन्य वर्गों द्वारा पुन: प्रयोज्य है। हमारे पास बर्गर रेस्तरां, बर्गर कैटरिंगशॉप जैसे अन्य क्लाइंट वर्ग हो सकते हैं जो SimpleBurgerFactory.createBurger() विधि का उपयोग करेंगे।

1. ग्राहक
   क्लाइंट SimpleBurgerFactory के माध्यम से विशिष्ट बर्गर ऑब्जेक्ट को इंस्टेंटिएट करता है। क्लाइंट के नजरिए से ध्यान दें, हम नहीं जानते कि कौन सा ठोस बर्गर बनाया जाएगा, यानी, ऑब्जेक्ट निर्माण तर्क अब क्लाइंट से अलग हो गया है।

2. सिंपलबर्गरफैक्ट्री
   यह वर्ग इस मामले में जो भिन्न होता है, उसे समाहित करता है, वस्तु निर्माण तर्क! createBurger() को स्थिर विधि के रूप में घोषित किया गया है क्योंकि क्लाइंट इस क्लास का उपयोग ऑब्जेक्ट को इंस्टेंट करने के लिए करना चाहता है (निश्चित रूप से इसे इंस्टेंट करने से पहले हमारे पास कोई इंस्टेंस नहीं हो सकता है!)। किस प्रकार का बर्गर बनाया जाना चाहिए यह निर्धारित करने के लिए createBurger() बर्गरटाइप एनम को स्वीकार करता है।

3. बर्गर
   यह अमूर्त वर्ग सभी बर्गरों के बीच सामान्य इंटरफ़ेस प्रदान करता है और डिफ़ॉल्ट व्यवहार को परिभाषित करता है।

4. बर्गर उपवर्ग
   यहां हमारे ठोस उत्पाद हैं। जब तक वे बर्गर वर्ग का विस्तार करते हैं, तब तक वे ओवरराइडिंग विधियों द्वारा विशिष्ट व्यवहार लागू कर सकते हैं।

संरचना

कोड

public enum BurgerType {
    BEEF,
    CHICKEN,
    FISH,
    VEGGIE
}

// Abstract Product
public abstract class Burger {

    public BurgerType burgerType;
    public List toppings = new ArrayList();

    public void prepareBun() {
        System.out.println("Preparing a bun");
    }

    public void grillPatty() {
        if (burgerType == null) {
            throw new IllegalStateException("pattyType is undefined");
        }
        System.out.println("Grill a "   burgerType   " patty");
    }

    public void addToppings() {
        for (String item : toppings) {
            System.out.println("Add "   item);
        }
    }

    public void wrap() {
        System.out.println("Wrap a burger up");
    }
}

// Concrete product
public class BeefBurger extends Burger {

    public BeefBurger() {
        burgerType = BurgerType.BEEF;
        List items = List.of("lettuce", "pickle slices", "tomato slice", "BBQ sauce");
        toppings.addAll(items);
    }
}

// Concrete product
public class VeggieBurger extends Burger {

    public VeggieBurger() {
        burgerType = BurgerType.VEGGIE;
        List items = List.of("smoked paprika", "garlic chips", "crushed walnuts", "veggie sauce");
        toppings.addAll(items);
    }

    // Concrete product can implement specific behavior that differs from other products
    @Override
    public void wrap() {
        System.out.println("Wrapping paper shouldn't print any meats but vegetables");
    }
}

// Simple factory, responsible for instantiating an object
public class SimpleBurgerFactory {

    public static Burger createBurger(BurgerType type) {
        return switch (type) {
            case BEEF -> new BeefBurger();
            case CHICKEN -> new ChickenBurger();
            case FISH -> new FishBurger();
            case VEGGIE -> new VeggieBurger();
            default -> throw new IllegalArgumentException("unknown burger type");
        };
    }
}

public class Client {

    public static void main(String[] args) {
        Burger burger = orderBurger(BurgerType.VEGGIE);
        System.out.println(burger); // Check if the object is actually veggie burger
    }

    public static Burger orderBurger(BurgerType type) {
        // Factory is responsible for object creation
        Burger burger = SimpleBurgerFactory.createBurger(type);

        burger.prepareBun();
        burger.grillPatty();
        burger.addToppings();
        burger.wrap();

        return burger;
    }
}

आउटपुट:

Preparing a bun
Grill a VEGGIE patty
Add smoked paprika
Add garlic chips
Add crushed walnuts
Add veggie sauce
Wrapping paper shouldn't print any meats but vegetables
com.factories.simpleFactory.VeggieBurger@9807454

नुकसान

• ऑब्जेक्ट इंस्टेंशियेशन के लिए निर्णय लेने वाला कोड कभी-कभी अधिक जटिल हो सकता है। ऐसे मामले में, हम इसके बजाय फ़ैक्टरी पद्धति का उपयोग करने पर भी विचार कर सकते हैं।

फ़ैक्टरी पैटर्न के साथ तुलना

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

आप यहां सभी डिज़ाइन पैटर्न कार्यान्वयन की जांच कर सकते हैं।
GitHub रिपोजिटरी

पी.एस.
मैं तकनीकी ब्लॉग लिखने में नया हूँ, यदि मेरे लेखन को बेहतर बनाने के लिए आपके पास कोई सलाह हो, या कोई भ्रमित करने वाली बात हो, तो कृपया एक टिप्पणी छोड़ें!
पढ़ने के लिए आपका शुक्रिया :)