C++ डिपेंडेंसी इंजेक्शन कंटेनर: Fruit लाइब्रेरी

C++ के लिए डिपेंडेंसी इंजेक्शन कंटेनर: Fruit लाइब्रेरी का अवलोकन

आधुनिक C++ डेवलपमेंट में, क्लासेस के बीच डिपेंडेंसी का प्रबंधन लचीले, परीक्षण योग्य और रखरखाव योग्य एप्लिकेशन बनाने के लिए महत्वपूर्ण हो जाता है। डिपेंडेंसी इंजेक्शन (DI) पैटर्न ऑब्जेक्ट निर्माण को क्लासेस के बाहर ले जाने की अनुमति देता है, और DI-कंटेनर इस प्रक्रिया को स्वचालित करता है। C++ में डिपेंडेंसी इंजेक्शन को लागू करने के लिए सबसे अच्छी लाइब्रेरी में से एक Fruit है — एक हल्का, तेज़ और टाइप-सेफ कंटेनर जो कंपाइलेशन चरण पर काम करता है।

डिपेंडेंसी इंजेक्शन कंटेनर क्या है?

डिपेंडेंसी इंजेक्शन कंटेनर एक उपकरण है जो ऑब्जेक्ट (डिपेंडेंसी) बनाने और जोड़ने की जिम्मेदारी लेता है। क्लास द्वारा स्वयं new या फैक्ट्री के माध्यम से अपनी डिपेंडेंसी बनाने के बजाय, कंटेनर उन्हें बाहर से "इंजेक्ट" करता है। यह इन्वर्ज़न ऑफ़ कंट्रोल (IoC) सिद्धांत को लागू करता है और कोड को शिथिल रूप से युग्मित बनाता है।

Fruit क्यों?

Fruit लाइब्रेरी (https://github.com/google/fruit) Google में विकसित की गई है और यह अन्य विकल्पों (जैसे Boost.DI) से निम्नलिखित विशेषताओं में भिन्न है:

कंपाइलेशन-टाइम जाँच: सभी संबंध कंपाइलेशन चरण पर जाँचे जाते हैं, जो डिपेंडेंसी की कमी से संबंधित रनटाइम त्रुटियों को समाप्त करता है।
न्यूनतम ओवरहेड: Fruit RTTI और वर्चुअल कॉल का उपयोग नहीं करता है, जिससे कुशल कोड उत्पन्न होता है।
सरलता: केवल C++14 और हेडर फ़ाइलों की आवश्यकता है — कोई मैक्रो या कोड जनरेशन नहीं।
कम्पोनेंट्स के लिए समर्थन: पुन: प्रयोज्य मॉड्यूल से डिपेंडेंसी ग्राफ बनाया जा सकता है।

स्थापना

Fruit एक हेडर-ओनली लाइब्रेरी के रूप में वितरित की जाती है (केवल fruit.h की आवश्यकता है)। vcpkg के माध्यम से स्थापित करने के लिए:

vcpkg install fruit

या रिपॉजिटरी को क्लोन करें और include/fruit/fruit.h फ़ाइल को शामिल करें।

मुख्य अवधारणाएँ

Fruit में तीन प्रमुख तत्वों का उपयोग किया जाता है:

इंजेक्टर (Injector) — कंटेनर जो ऑब्जेक्ट बनाता है।
कम्पोनेंट (Component) — मॉड्यूल जो प्रकार और उनकी फैक्ट्री को पंजीकृत करता है।
एनोटेशन — एक ही इंटरफ़ेस के विभिन्न कार्यान्वयनों में अंतर करने के लिए।

उपयोग का उदाहरण

एक क्लासिक उदाहरण पर विचार करें: एक सेवा एक रिपॉजिटरी पर निर्भर करती है। एक इंटरफ़ेस और दो कार्यान्वयन बनाते हैं:

// interfaces.hpp#include <fruit/fruit.h>#include <string>

class ILogger {public:    virtual void log(const std::string& msg) = 0;    virtual ~ILogger() = default;};

class IUserRepository {public:    virtual std::string getUser(int id) = 0;    virtual ~IUserRepository() = default;};

कार्यान्वयन:

// implementations.cpp#include "interfaces.hpp"#include <iostream>

class ConsoleLogger : public ILogger {public:    INJECT(ConsoleLogger()) = default;  // कंस्ट्रक्टर के लिए Fruit-एनोटेशन    void log(const std::string& msg) override {        std::cout << "[LOG] " << msg << std::endl;    }};

class SqlRepository : public IUserRepository {public:    INJECT(SqlRepository()) = default;    std::string getUser(int id) override {        return "User_" + std::to_string(id);    }};

सेवा जो दोनों डिपेंडेंसी का उपयोग करती है:

// user_service.cpp#include "interfaces.hpp"

class UserService {private:    ILogger* logger;    IUserRepository* repo;public:    INJECT(UserService(ILogger* logger, IUserRepository* repo))        : logger(logger), repo(repo) {}        void processUser(int id) {        auto name = repo->getUser(id);        logger->log("Processing user: " + name);    }};

अब कम्पोनेंट बनाते हैं