जावा में डिपेंडेंसी इंजेक्शन (Dependency Injection): पूर्ण गाइड

परिचय: Dependency Injection क्या है और Java में इसकी आवश्यकता क्यों है

आधुनिक Java-डेवलपमेंट में, कोड की स्वच्छता और उसकी परीक्षण क्षमता (testability) एक पेशेवर के लिए प्रमुख आवश्यकताओं में से हैं। Dependency Injection (DI), या निर्भरता इंजेक्शन, एक डिज़ाइन पैटर्न है जो आपके कोड को ढीला-युग्मित (loosely coupled), लचीला और आसानी से रखरखाव योग्य बनाता है। ऑब्जेक्ट द्वारा स्वयं अपनी निर्भरताएँ बनाने (जैसे new के माध्यम से) के बजाय, DI उन्हें बाहर से "इंजेक्ट" करता है। यह इनवर्जन ऑफ कंट्रोल (IoC) सिद्धांत का एक मूलभूत हिस्सा है।

इस लेख में, हम Java में Dependency Injection कैसे काम करता है, इसके कार्यान्वयन के तीन मुख्य तरीकों (कंस्ट्रक्टर, सेटर्स और इंटरफ़ेस के माध्यम से) का विश्लेषण करेंगे, और दिखाएंगे कि वास्तविक प्रोजेक्ट्स में DI का उपयोग कैसे किया जाता है, जिसमें लोकप्रिय Spring फ्रेमवर्क भी शामिल है।

DI के बिना आपका कोड नाजुक क्यों हो जाता है?

एक Car क्लास की कल्पना करें, जो अपने अंदर एक इंजन बनाती है:

public class Car {
    private Engine engine;

    public Car() {
        this.engine = new PetrolEngine(); // कठोर संबंध (Tight coupling)
    }

    public void start() {
        engine.run();
    }
}

इस दृष्टिकोण की समस्याएँ स्पष्ट हैं:

• पुन: उपयोग की असंभवता: आप आसानी से PetrolEngine को ElectricEngine से नहीं बदल सकते।
• परीक्षण में कठिनाई: यूनिट टेस्ट के लिए, आपको एक वास्तविक इंजन बनाना होगा, न कि उसका नकली (mock) संस्करण।
• SRP का उल्लंघन: Car क्लास न केवल कार को नियंत्रित करने में, बल्कि इंजन बनाने में भी व्यस्त है।

Dependency Injection निर्भरताओं के निर्माण को बाहरी कोड (कंटेनर या किसी अन्य क्लास) को सौंपकर इन समस्याओं का समाधान करता है।

Java में निर्भरता इंजेक्शन के तीन तरीके

Java में DI को लागू करने के तीन मुख्य दृष्टिकोण हैं। आइए प्रत्येक को एक नोटिफिकेशन सिस्टम के उदाहरण पर देखें।

1. कंस्ट्रक्टर के माध्यम से इंजेक्शन (Constructor Injection)

यह सबसे पसंदीदा तरीका है। निर्भरताएँ कंस्ट्रक्टर के पैरामीटर के माध्यम से पास की जाती हैं। यह सुनिश्चित करता है कि ऑब्जेक्ट हमेशा एक वैध स्थिति में बनाया जाए और निर्भरताएँ बनने के बाद बदली न जा सकें (immutability)।

public interface MessageService {
    void sendMessage(String message, String recipient);
}

public class EmailService implements MessageService {
    @Override
    public void sendMessage(String message, String recipient) {
        System.out.println("Email sent to " + recipient + ": " + message);
    }
}

public class NotificationSender {
    private final MessageService messageService;

    // कंस्ट्रक्टर के माध्यम से निर्भरता इंजेक्शन
    public NotificationSender(MessageService messageService) {
        this.messageService = messageService;
    }

    public void notifyUser(String userEmail, String msg) {
        messageService.sendMessage(msg, userEmail);
    }
}

// उपयोग
public class Main {
    public static void main(String[] args) {
        MessageService emailService = new EmailService();
        NotificationSender sender = new NotificationSender(emailService); // DI
        sender.notifyUser("user@example.com", "Hello!");
    }
}

2. सेटर्स के माध्यम से इंजेक्शन (Setter Injection)

यह वैकल्पिक निर्भरताओं या जब ऑब्जेक्ट के जीवनकाल के दौरान निर्भरता बदली जा सकती है, के लिए उपयुक्त है। हालाँकि, यदि सेटर को कॉल करना भूल जाएँ तो ऑब्जेक्ट अधूरी अवस्था में बन सकता है।

public class NotificationSender {
    private MessageService messageService;

    // निर्भरता इंजेक्शन के लिए सेटर
    public void setMessageService(MessageService messageService) {
        this.messageService = messageService;
    }

    public void notifyUser(String userEmail, String msg) {
        if (messageService != null) {
            messageService.sendMessage(msg, userEmail);
        } else {
            System.o
```