Rust में Dependency Injection: डेवलपर्स के लिए संपूर्ण गाइड

Rust में Dependency Injection का परिचय

Dependency Injection (DI) एक डिज़ाइन पैटर्न है जिसमें कोई ऑब्जेक्ट अपनी निर्भरताएँ स्वयं बनाने के बजाय बाहर से प्राप्त करता है। Rust इकोसिस्टम में, सख्त टाइप सिस्टम और स्वामित्व के कारण यह दृष्टिकोण विशेष महत्व रखता है। DI कोड को अधिक मॉड्यूलर, परीक्षण योग्य और रखरखाव योग्य बनाता है, जो बड़े प्रोजेक्ट्स के लिए विशेष रूप से महत्वपूर्ण है।

डायनामिक टाइपिंग या गार्बेज कलेक्शन वाली भाषाओं के विपरीत, Rust में निर्भरताओं को इंजेक्ट करने के लिए एक विशेष दृष्टिकोण की आवश्यकता होती है। यहाँ क्लासिकल अर्थों में कोई रिफ्लेक्शन या runtime-कंटेनर नहीं हैं। इसके बजाय, डेवलपर्स स्थिर तंत्रों का उपयोग करते हैं: trait-ऑब्जेक्ट, generics और स्ट्रक्चर के माध्यम से कंपोज़िशन।

इस लेख में, हम Rust में Dependency Injection को लागू करने के तीन मुख्य दृष्टिकोणों पर विचार करेंगे, सबसे सरल मैन्युअल इंजेक्शन से शुरू करके लाइब्रेरीज़ के उपयोग तक। प्रत्येक दृष्टिकोण को व्यावहारिक कोड उदाहरणों के साथ चित्रित किया जाएगा।

1. मैन्युअल निर्भरता इंजेक्शन (Manual DI)

सबसे सरल और पारदर्शी तरीका है स्ट्रक्चर के कंस्ट्रक्टर के माध्यम से निर्भरताएँ पास करना। इस दृष्टिकोण के लिए किसी अतिरिक्त लाइब्रेरी की आवश्यकता नहीं है और यह पूरी तरह से Rust कंपाइलर द्वारा नियंत्रित होता है।

उदाहरण: लॉगर और सर्विस

// लॉगिंग के लिए trait परिभाषित करेंtrait Logger {    fn log(&self, message: &str);}

// प्रोडक्शन के लिए लॉगर का कार्यान्वयनstruct ConsoleLogger;

impl Logger for ConsoleLogger {    fn log(&self, message: &str) {        println!("[LOG]: {}", message);    }}

// परीक्षणों के लिए कार्यान्वयनstruct MockLogger {    pub messages: Vec<String>,}

impl Logger for MockLogger {    fn log(&self, message: &str) {        self.messages.push(message.to_string());    }}

// सर्विस, जो Logger पर निर्भर हैstruct UserService<T: Logger> {    logger: T,}

impl<T: Logger> UserService<T> {    fn new(logger: T) -> Self {        Self { logger }    }

    fn create_user(&self, name: &str) {        self.logger.log(&format!("उपयोगकर्ता बनाया गया: {}", name));    }}

fn main() {    let logger = ConsoleLogger;    let service = UserService::new(logger);    service.create_user("अलेक्से");}

लाभ:

• कंपाइलेशन चरण पर पूर्ण टाइप सुरक्षा
• अधिकतम प्रदर्शन (zero-cost abstraction)
• समझने और डीबग करने में सरलता

कमियाँ:

• निर्भरताओं की संख्या बढ़ने पर कोड बोझिल हो जाता है
• runtime में कार्यान्वयन बदलना कठिन है
• कॉल चेन के माध्यम से सभी निर्भरताओं को स्पष्ट रूप से पास करना आवश्यक है

2. trait-ऑब्जेक्ट के माध्यम से इंजेक्शन (Dynamic Dispatch)

यदि आपको runtime में कार्यान्वयन बदलने या विशिष्ट प्रकार को छिपाने की आवश्यकता है, तो trait-ऑब्जेक्ट (Box<dyn Trait>) का उपयोग करें। यह DI के लिए एक क्लासिकल दृष्टिकोण है, जो अन्य भाषाओं से जाना जाता है।

उदाहरण: अमूर्त रिपॉजिटरी

use std::sync::Mutex;

trait UserRepository {    fn find_by_id(&self, id: u32) -> Option<String>;    fn save(&self, user: String);}

struct InMemoryRepository {    users: Mutex<Vec<String>>,}

impl UserRepository for InMemoryRepository {    fn find_by_id(&self, id: u32) -> Option<String> {        let users = self.users.lock().unwrap();        users.get(id as usize).cloned()    }

    fn save(&self, user: String) {        let mut users = self.users.lock().unwrap();        users.push(user);    }}

struct UserController {    repository: Box<dyn UserRepository>,}

impl UserController {    fn new(repository: Box<dyn UserRepository>) -> Self {        Self { repository }    }

    fn get_user(&self, id: u32) -> Option<String>
```