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 dynamické a statické DI kontejnery
- jak na lazy loading služeb
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', array(
'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(array(
'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 = array();
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 dynamicky, kdy továrny přidáme jako closury nebo callbacky.
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(array(
'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 createArticle()
{
return new Article($this->getService('connection'));
}
}
$container = new MyContainer(...);
$article = $container->createArticle();
Z volání $container->createArticle()
je zřejmé, že se vytváří pokaždé nový objekt. Jde tedy
o konvenci na straně programátora.
Dynamický kontejner
Do kontejneru Nette\DI\Container
lze služby přidávat i za běhu pomocí metody addService
.
Továrny lze zapisovat jako PHP callback nebo closure. Všimněte si, že jako parametr je jim předáván samotný kontejner,
mohou tak snadno přistupovat k parametrům a jiným službám.
$container = new Nette\DI\Container;
$container->addService('connection', function($container) {
return new Nette\Database\Connection(
$container->parameters['dsn'],
$container->parameters['user'],
$container->parameters['password']
);
});
Pokud vytvoření služby spočívá v triviálním vytvoření instance, lze metodě addService
jako druhý
parametr předat rovnou název třídy. A pokud již objekt vytvořený máme, můžeme předat přímo jej.
Kromě metody addService
máme k dispozici ještě hasService
ověřující existenci služby a
removeService
sloužící k jejímu odstranění.
Související články na blogu
Dependency Injection: úvod (1/6)
Pamatujete si na svůj první program? Netuším sice, v jakém jazyce byl napsaný, ale kdyby to bylo PHP 7, nejspíš by vypadal nějak takto: function…
Ako automaticky zaregistrovať triedy do DIC
Veľa z vás to možno nevedelo, no Nette 3 má zabudované rozšírenie na automatické registrovanie tried do DI kontajnera. Takéto rozšírenie dokáže …
Nabušené DI srdce pro vaše aplikace
Jednou z nejzajímavějších částí Nette, kterou vychvalují i uživatelé jiných frameworků, je Dependency Injection Container (dále Nette DI). Podívejte…