Dependency Injection Container in C++: Die Bibliothek Fruit für die Abhängigkeitsinjektion

Dependency Injection Container für C++: Überblick über die Bibliothek Fruit

In der modernen C++-Entwicklung wird die Verwaltung von Abhängigkeiten zwischen Klassen entscheidend für die Erstellung flexibler, testbarer und wartbarer Anwendungen. Das Dependency Injection (DI)-Muster ermöglicht es, die Objekterstellung aus den Klassen auszulagern, und ein DI-Container automatisiert diesen Prozess. Eine der besten Bibliotheken zur Implementierung der Abhängigkeitsinjektion in C++ ist Fruit – ein leichter, schneller und typsicherer Container, der zur Kompilierzeit arbeitet.

Was ist ein Dependency Injection Container?

Ein Dependency Injection Container ist ein Werkzeug, das die Verantwortung für die Erstellung und Verknüpfung von Objekten (Abhängigkeiten) übernimmt. Anstatt dass eine Klasse ihre Abhängigkeiten selbst über new oder Fabriken erstellt, „injiziert“ der Container sie von außen. Dies realisiert das Prinzip der Inversion of Control (IoC) und macht den Code lose gekoppelt.

Warum Fruit?

Die Bibliothek Fruit (https://github.com/google/fruit) wurde bei Google entwickelt und zeichnet sich durch folgende Besonderheiten gegenüber Alternativen (z. B. Boost.DI) aus:

• Kompilierzeitprüfung: Alle Verbindungen werden zur Kompilierzeit geprüft, was Laufzeitfehler durch fehlende Abhängigkeiten ausschließt.
• Minimaler Overhead: Fruit verwendet kein RTTI und keine virtuellen Aufrufe und generiert effizienten Code.
• Einfachheit: Es werden nur C++14 und Header-Dateien benötigt – keine Makros oder Codegenerierung.
• Unterstützung von Komponenten: Der Abhängigkeitsgraph kann aus wiederverwendbaren Modulen zusammengesetzt werden.

Installation

Fruit wird als Header-Only-Bibliothek verbreitet (es wird nur fruit.h benötigt). Zur Installation über vcpkg:

vcpkg install fruit

Oder klonen Sie das Repository und binden Sie die Datei include/fruit/fruit.h ein.

Grundlegende Konzepte

In Fruit werden drei Schlüsselelemente verwendet:

• Injector – der Container, der Objekte erstellt.
• Component – ein Modul, das Typen und deren Fabriken registriert.
• Annotationen – zur Unterscheidung verschiedener Implementierungen derselben Schnittstelle.

Anwendungsbeispiel

Betrachten wir ein klassisches Beispiel: Ein Dienst ist von einem Repository abhängig. Wir erstellen eine Schnittstelle und zwei Implementierungen:

// 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;};

Implementierungen:

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

class ConsoleLogger : public ILogger {public:    INJECT(ConsoleLogger()) = default;  // Fruit-Annotation für den Konstruktor    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);    }};

Dienst, der beide Abhängigkeiten verwendet:

// 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);    }};

Jetzt erstellen wir die Komponente