Dependency Injection

Podstatou Dependency Injection (DI) je odebrat třídám zodpovědnost za získávání objektů, které potřebují ke své činnosti (tzv. služeb) a místo toho jim služby předávat při vytváření. Řekneme si:

  • co je principem Dependency Injection?
  • jak vytvářet DI kontejnery

Co je to Dependency Injection?

Narovinu: Dependency Injection (DI) není nic tajemného nebo nepochopitelného. Celé se dá shrnout do jedné sobecké věty: „nic nesháněj, ať se postará někdo jiný.“ Nic víc, nic míň. Převeďme to do řeči programátorů. Máme třídu Article reprezentující článek na blogu:

class Article
{
    public $id;
    public $title;
    public $content;

    function save()
    {
        // uložíme do databáze
    }

}

a použití bude následující:

$article = new Article;
$article->title = '10 Things You Need to Know About Losing Weight';
$article->content = 'Every year millions of people in ...';
$article->save();

Metoda save() nám uloží článek do databázové tabulky articles. Implementovat ji za pomoci Nette Database bude hračka, nebýt jednoho zádrhelu: kde má Article vzít připojení k databázi, tj. objekt třídy Connection?

Nejspíš bychom si poradili, můžeme jej uložit někde do globální proměnné $GLOBALS['connection']. Říkali vám, že používání globálních proměnných je špatné a že máte raději používat statické proměnné tříd? No měli pravdu, globální proměnné jsou zlo, jenže statické proměnné tříd jsou zcela totéž. To je jako říci: „Nejezte hamburgery, tloustne se po nich, dejte si raději cheeseburger.“

Kde tedy seženeme připojení k databázi? DI má odpověď: „nic nesháněj, ať se postará někdo jiný.“ Jinými slovy, pokud potřebuji databázi, ať mi ji někdo dodá, já to řešit nehodlám. Cha, to je vychytralé, milé DI! Tak do toho:

class Article
{
    public $id;
    public $title;
    public $content;
    private $database;

    function __construct(Nette\Database\Connection $database)
    {
        $this->database = $database;
    }

    function save()
    {
        $this->database->query('INSERT INTO articles', [
            'title' => $this->title,
            'content' => $this->content,
        ]);
    }

}

Použití třídy Article se pochopitelně trošku změní:

$article = new Article($database);
$article->title = ...
$article->content = ...
$article->save();

Ptáte se, kde tento kód vezme $database? DI dává jasnou odpověď: „ať se postará někdo jiný“. Databázové spojení zkrátka dodá ten, kdo volá uvedený kód. A tak dále, a tak dále. Jistě si říkáte, že přece nelze delegovat zodpovědnost do nekonečna. Že musí být nějaký počátek všehomíra. A máte pravdu. Úplně na začátku je stvořitel, který už nic nedeleguje a objekty tvoří. Říká se mu systémový kontejner. A je mu věnovaná samostatná kapitola.

Proč jsou globální proměnné zlo?

Dobrá otázka. Zvídavému programátorovi nestačí si přečíst, že to či ono je zlo, chce znát důvod. Třída Article tak jako tak databázové připojení potřebuje. Jenže z prvního příkladu užití není vůbec patrné, odkud a jak ho získá. Uživatel takové kódu může být až překvapen, že se vůbec článek uloží, a ptá se „kam se vlastně uložil?“ Naopak v druhém příkladu používajícím DI je kód samovysvětlující.

Představte si, že zkoumáte nějakou knihovnu pro platební brány a napíšete si příklad:

$cc = new CreditCard('4461510140804839', 12, 2013);
$cc->pay(1000, CreditCard::DOLLARS);

Kód spustíte, s číslem své karty, a po nějaké době zjistíte, že vám to skutečně z účtu strhlo peníze! Šokovaný zíráte na výpis a lamentujete: „kde jsou mé peníze, jak je to mohlo strhnout, vždyť jsem to s žádnou platební bránou nepropojil!“ Třída CreditCard se s ní propojila nějak sama, získala ji odněkud z globální proměnné, podobně tajemně, jako si původní Article získal připojení k databázi. Takovou věc z kódu nejen že nevydedukujete, ale ani nevíte, jak změnit platební bránu na jinou, třeba testovací.

DI znamená víc psaní

Můžete namítnout, že používání DI znamená víc psaní, že kvůli vytvoření instance Article musíte uchovávat a předávat databázové spojení a podobně. To je pravda, nicméně nezapomeňte, že posledně vás „méně psaní“ připravilo o $1000! Ne, nechceme to zlehčovat. Připomínka je zcela korektní a my ještě přidáme jednu závažnější: časem může ve třídě Article vzniknout potřeba nějaká data cachovat a v souladu s DI bude požadovat předání ještě objektu představujícího úložiště cache. To by znamenalo upravit aplikaci na mnoha místech: přinejmenším všude, kde se vytváří instance Article.

Co s tím? Věc má řešení. Místo ručního vytváření objektů Article si vytvoříme továrnu, tedy funkci, která bude objekty Article vyrábět. Když Article změní konstruktor, upraví se jen továrna, nic víc. A odkud onu továrnu v našem kódu získáme? Vždyť víte… o to ať se postará někdo jiný :-).

DI kontejner a služby

Termínem DI kontejner označujeme právě onu továrnu. Přesněji řečeno, jde o objekt obsahující libovolné množství továrniček, každou pro jinou službu. Co jsou to služby? Obyčejné objekty, jako třeba instance zmíněného Connection. Jen v souvislosti s DI kontejnery jim říkáme služby. Zřejmě to vymysleli konzultanti, kteří chtějí, aby DI vypadalo složitě a oni mohli konzultovat.

Příkladem může být kontejner, který vytvoří objekt Article, ale také jím požadované připojení k databázi:

class Container
{
    function createConnection()
    {
        return new Nette\Database\Connection('mysql:', 'root', '***');
    }

    function createArticle()
    {
        return new Article($this->createConnection());
    }

}

Použití by vypadalo následovně:

$container = new Container;
$article = $container->createArticle();

Výhoda je zřejmá, nemusíme se starat o to, jak Article instancovat, to je záležitostí továrny. Nicméně řešení má zatím dva nedostatky. Jednak jsou přihlašovací údaje natvrdo zadrátované do kódu, proto je vyčleníme do proměnné:

class Container
{
    private $parameters;

    function __construct(array $parameters)
    {
        $this->parameters = $parameters;
    }

    function createConnection()
    {
        return new Nette\Database\Connection(
            $this->parameters['dsn'],
            $this->parameters['user'],
            $this->parameters['password']
        );
    }

    function createArticle()
    {
        return new Article($this->createConnection());
    }

}

$container = new Container([
    'dsn' => 'mysql:',
    'user' => 'root',
    'password' => '***',
]);
$article = $container->createArticle();

Závažnějším nedostatkem je, že vždy, když požádáme o vytvoření Article, vytvoří se i nové připojení k databázi. Tomu je třeba zabránit. Přidáme proto metodu getConnection, která bude uchovávat jednou vytvořenou službu pro příští použití:

class Container
{
    private $parameters;

    private $services = [];

    function __construct(array $parameters)
    {
        $this->parameters = $parameters;
    }

    function createConnection()
    {
        return new Nette\Database\Connection(
            $this->parameters['dsn'],
            $this->parameters['user'],
            $this->parameters['password']
        );
    }

    function getConnection()
    {
        if (!isset($this->services['connection'])) {
            $this->services['connection'] = $this->createConnection();
        }
        return $this->services['connection'];
    }

    function createArticle()
    {
        return new Article($this->getConnection());
    }

}

A máme plně funkční DI kontejner. Jak vidíte, napsat jej není nic složitého. Za připomenutí stojí, že samotné služby neví, že je vytváří nějaký kontejner, tím pádem je možné takto vytvářet jakýkoliv objekt v PHP bez zásahu do zdrojového kódu.

Nette\DI\Container

Třída Nette\DI\Container je pružná implementace univerzálního DI kontejneru. Automaticky zajišťuje, že instance služeb se vytváří jen jednou.

Vlastní kontejnery můžeme vytvářet buď staticky, tj. poděděním této třídy, nebo si je nechat automaticky generovat, což je velmi elegantní řešení.

Statický kontejner

Názvy továrních funkcí dodržují jednotnou konvenci, jsou tvořeny předponou createService + názvem služby začínajícím velkým písmenem. Pokud nemají být dostupné zvenčí, lze jim viditelnost snížit na protected. Všimněte si, že kontejner už má definované pole $parameters pro uživatelské parametry.

class MyContainer extends Nette\DI\Container
{

    protected function createServiceConnection()
    {
        return new Nette\Database\Connection(
            $this->parameters['dsn'],
            $this->parameters['user'],
            $this->parameters['password']
        );
    }

    protected function createServiceArticle()
    {
        return new Article($this->getService('connection'));
    }

}

Vytvoříme instanci kontejneru a předáme parametry:

$container = new MyContainer([
    'dsn' => 'mysql:',
    'user' => 'root',
    'password' => '***',
]);

Službu získáme metodu getService:

$article = $container->getService('article');

Jak bylo řečeno, všechny služby v rámci kontejneru se vytváří jen jednou, nám by se ale spíš hodilo, kdyby kontejner pokaždé vygeneroval novou instanci Article. Toho lze dosáhnout snadno: namísto továrny pro službu article vytvoříme obyčejnou metodu createArticle:

class MyContainer extends Nette\DI\Container
{

    function createServiceConnection()
    {
        return new Nette\Database\Connection(
            $this->parameters['dsn'],
            $this->parameters['user'],
            $this->parameters['password']
        );
    }

    function createServiceArticle()
    {
        return new Article($this->getService('connection'));
    }

}

$container = new MyContainer(...);

$article = $container->createServiceArticle();

Z volání $container->createServiceArticle() je zřejmé, že se vytváří pokaždé nový objekt. Jde tedy o konvenci na straně programátora.

Generovaný kontejner

Nette DI je generátor kontejnerů. Instruujeme ho (zpravidla) pomocí konfiguračních souborů a třeba tato konfigurace vygeneruje cca totéž, jako byla třída MyContainer:

parameters:
    dsn: 'mysql:'
    user: root
    password: '***'

services:
    connection: Nette\Database\Connection( %dsn%, %user%, %password% )
    article: Article

Zásadní výhodou je stručnost zápisu. Navíc jednotlivým třídám můžeme přidávat další a další závislosti často bez nutnosti do konfigurace zasahovat.

Nette DI vygeneruje skutečně PHP kód kontejneru. Ten je proto extrémně rychlý, programátor přesně ví, co dělá, a může ho třeba i krokovat.

Kontejner může mít v případě velkých aplikací desetitisíce řádků a udržovat něco takového ručně by už nejspíš ani nebylo možné.

Výše uvedenou konfiguraci uložíme do souboru config.neon a pomocí třídy Nette\DI\ContainerLoader vytvoříme kontejner:

$loader = new Nette\DI\ContainerLoader(__DIR__ . '/temp');
$class = $loader->load(function($compiler) {
    $compiler->loadConfig(__DIR__ . '/config.neon');
});
$container = new $class;

a pak jej opět necháme vytvořit objekt Nette\Database\Connection:

$db = $container->getByType(Nette\Database\Connection::class);
$db->query('...');

Nebo vyrobit nový Article:

$article = $container->createServiceArticle();

Ale ještě na chvíli zpět ke ContainerLoader. Uvedený zápis je podřízen jediné věci: rychlosti. Kontejner se vygeneruje jednou, jeho kód se zapíše do cache (adresář __DIR__ . '/temp') a při dalších požadavcích se už jen odsud načítá. Proto je načítání konfigurace umístěno do closure v metodě $loader->load().

Během vývoje je užitečné aktivovat auto-refresh mód, kdy se kontejner automaticky přegeneruje, pokud dojde ke změně jakékoliv třídy nebo konfiguračního souboru. Stačí v konstruktoru ContainerLoader uvést jako druhý argument true.

Jak vidíte, použití Nette DI rozhodně není limitované na aplikace psané v Nette, můžete jej pomocí pouhých 3 řádků kódu nasadit kdekoliv.