Bootstrapping
*************
<div class=perex>
Bootstrapping je proces inicializace prostředí aplikace, vytvoření kontejneru pro dependency injection (DI) a spuštění aplikace. Budeme probírat:
- jak třída Bootstrap inicializuje prostředí
- jak jsou aplikace konfigurovány pomocí NEON souborů
- jak rozlišovat mezi produkčním a vývojářským režimem
- jak vytvořit a nakonfigurovat DI kontejner
</div>
Aplikace, ať už jde o ty webové nebo skripty spouštěné z příkazové řádky, začínají svůj běh nějakou formou inicializace prostředí. V dávných dobách to míval na starosti soubor s názvem třeba `include.inc.php`, který prvotní soubor inkludoval. V moderních Nette aplikacích jej nahradila třída `Bootstrap`, kterou jakožto součást aplikace najdete v souboru `app/Bootstrap.php`. Může vypadat kupříkladu takto:
```php
namespace App;
use Nette;
use Nette\Bootstrap\Configurator;
class Bootstrap
{
private Configurator $configurator;
private string $rootDir;
public function __construct()
{
$this->rootDir = dirname(__DIR__);
// Konfigurátor je zodpovědný za nastavení prostředí aplikace a služeb.
$this->configurator = new Configurator;
// Nastaví adresář pro dočasné soubory generované Nette (např. zkompilované šablony)
$this->configurator->setTempDirectory($this->rootDir . '/temp');
}
public function bootWebApplication(): Nette\DI\Container
{
$this->initializeEnvironment();
$this->setupContainer();
return $this->configurator->createContainer();
}
private function initializeEnvironment(): void
{
// Nette je chytré a vývojový režim se zapíná automaticky,
// nebo jej můžete povolit pro konkrétní IP adresu odkomentováním následujícího řádku:
// $this->configurator->setDebugMode('secret@23.75.345.200');
// Aktivuje Tracy: ultimátní "švýcarský nůž" pro ladění.
$this->configurator->enableTracy($this->rootDir . '/log');
// RobotLoader: automaticky načítá všechny třídy ve zvoleném adresáři
$this->configurator->createRobotLoader()
->addDirectory(__DIR__)
->register();
}
private function setupContainer(): void
{
// Načte konfigurační soubory
$this->configurator->addConfig($this->rootDir . '/config/common.neon');
}
}
```
index.php
=========
Prvotní soubor je v případě webových aplikací `index.php`, který se nachází ve [veřejném adresáři |directory-structure#Veřejný adresář www] `www/`. Ten si nechá od třídy Bootstrap inicializovat prostředí a vyrobit DI kontejner. Poté z něj získá službu `Application`, která spustí webovou aplikaci:
```php
$bootstrap = new App\Bootstrap;
// Inicializace prostředí + vytvoření DI kontejneru
$container = $bootstrap->bootWebApplication();
// DI kontejner vytvoří objekt Nette\Application\Application
$application = $container->getByType(Nette\Application\Application::class);
// Spuštění aplikace Nette a zpracování příchozího požadavku
$application->run();
```
.[note]
Objekt `$application` během zpracování požadavku vyvolává [události |nette:glossary#události] - `onStartup`, `onRequest`, `onPresenter`, `onResponse`, `onShutdown` a `onError` (při nezachycené výjimce). Můžete k nim připojit handlery, což se hodí pro logování nebo monitoring napříč aplikací.
Jak vidno, s nastavením prostředí a vytvořením dependency injection (DI) kontejneru pomáhá třída [api:Nette\Bootstrap\Configurator], kterou si nyní blíže představíme.
Vývojářský vs produkční režim
=============================
Nette se chová různě podle toho, zda běží na vývojářském nebo produkčním serveru:
🛠️ Vývojářský režim (Development):
- Zobrazuje Tracy debugbar s užitečnými informacemi (SQL dotazy, čas vykonání, použitá paměť)
- Při chybě zobrazí detailní chybovou stránku s voláním funkcí a obsahem proměnných
- Automaticky obnovuje cache při změně Latte šablon, úpravě konfiguračních souborů atd.
🚀 Produkční režim (Production):
- Nezobrazuje žádné ladicí informace, všechny chyby zapisuje do logu
- Při chybě zobrazí ErrorPresenter nebo obecnou stránku "Server Error"
- Cache se nikdy automaticky neobnovuje!
- Optimalizovaný pro rychlost a bezpečnost
Volba režimu se provádí autodetekcí, takže obvykle není potřeba nic konfigurovat nebo ručně přepínat:
- vývojářský režim: na localhostu (IP adresa `127.0.0.1` nebo `::1`), pokud není přítomná proxy (tj. její HTTP hlavička)
- produkční režim: všude jinde
Pokud chceme vývojářský režim povolit i v dalších případech, například programátorům přistupujícím z konkrétní IP adresy, použijeme `setDebugMode()`:
```php
$this->configurator->setDebugMode('23.75.345.200'); // lze uvést i pole IP adres
```
Rozhodně doporučujeme kombinovat IP adresu s cookie. Do cookie `nette-debug` uložíme tajný token, např. `secret1234`, a tímto způsobem aktivujeme vývojářský režim pro programátory přistupující z konkrétní IP adresy a zároveň mající v cookie zmíněný token:
```php
$this->configurator->setDebugMode('secret1234@23.75.345.200');
```
Vývojářský režim můžeme také vypnout úplně, i pro localhost:
```php
$this->configurator->setDebugMode(false);
```
Pozor, hodnota `true` zapne vývojářský režim natvrdo, což se nikdy nesmí stát na produkčním serveru.
Autodetekci uvnitř zajišťuje statická metoda `Configurator::detectDebugMode()`, kterou můžete zavolat i sami, například pro detekci vývojářského režimu mimo konfigurátor. Přijímá volitelný whitelist IP adres nebo názvů počítačů a vrací, zda má aktuální požadavek běžet ve vývojářském režimu:
```php
$debug = Nette\Bootstrap\Configurator::detectDebugMode('23.75.345.200');
```
Debugovací nástroj Tracy
========================
Pro snadné debugování ještě zapneme skvělý nástroj [Tracy |tracy:]. Ve vývojářském režimu chyby vizualizuje a v produkčním režimu chyby loguje do uvedeného adresáře:
```php
$this->configurator->enableTracy($this->rootDir . '/log');
```
Dočasné soubory
===============
Nette využívá cache pro DI kontejner, RobotLoader, šablony atd. Proto je nutné nastavit cestu k adresáři, kam se bude cache ukládat:
```php
$this->configurator->setTempDirectory($this->rootDir . '/temp');
```
Na Linuxu nebo macOS nastavte adresářům `log/` a `temp/` [práva pro zápis |nette:troubleshooting#Nastavení práv adresářů].
RobotLoader
===========
Zpravidla budeme chtít automaticky načítat třídy pomocí [RobotLoaderu |robot-loader:], musíme ho tedy nastartovat a necháme jej načítat třídy z adresáře, kde je umístěný `Bootstrap.php` (tj. `__DIR__`), a všech podadresářů:
```php
$this->configurator->createRobotLoader()
->addDirectory(__DIR__)
->register();
```
Alternativní přístup je nechat třídy načítat pouze přes [Composer |best-practices:composer] při dodržení PSR-4.
Timezone
========
Přes konfigurátor můžete nastavit výchozí časovou zónu.
```php
$this->configurator->setTimeZone('Europe/Prague');
```
Konfigurace DI kontejneru
=========================
Součástí bootovacího procesu je vytvoření DI kontejneru neboli továrny na objekty, což je srdce celé aplikace. Jde vlastně o PHP třídu, kterou vygeneruje Nette a uloží do adresáře s cache. Továrna vyrábí klíčové objekty aplikace a pomocí konfiguračních souborů jí instruujeme, jak je má vytvářet a nastavovat, čímž ovlivňujeme chování celé aplikace.
Konfigurační soubory se obvykle zapisují ve formátu [NEON |neon:format]. V samostatné kapitole se dočtete, [co vše lze konfigurovat |nette:configuring].
.[tip]
Ve vývojářském režimu se kontejner automaticky aktualizuje při každé změně kódu nebo konfiguračních souborů. V produkčním režimu se vygeneruje jen jednou a změny se kvůli maximalizaci výkonu nekontrolují.
Zatímco `createContainer()` kontejner vytvoří a vrátí jeho instanci, metoda `loadContainer()` vrátí jen název vygenerované třídy kontejneru, kterou si pak můžete vytvořit sami. To se hodí v pokročilých scénářích.
Konfigurační soubory načteme pomocí `addConfig()`:
```php
$this->configurator->addConfig($this->rootDir . '/config/common.neon');
```
Pokud chceme přidat více konfiguračních souborů, můžeme funkci `addConfig()` zavolat vícekrát.
```php
$configDir = $this->rootDir . '/config';
$this->configurator->addConfig($configDir . '/common.neon');
$this->configurator->addConfig($configDir . '/services.neon');
if (PHP_SAPI === 'cli') {
$this->configurator->addConfig($configDir . '/cli.php');
}
```
Název `cli.php` není překlep, konfigurace může být zapsaná také v PHP souboru, který ji vrátí jako pole.
Také můžeme přidat další konfigurační soubory v [sekci `includes` |dependency-injection:configuration#Vkládání souborů].
Pokud se v konfiguračních souborech objeví prvky se stejnými klíči, budou přepsány, nebo v případě [polí sloučeny |dependency-injection:configuration#Slučování]. Později vkládaný soubor má vyšší prioritu než předchozí. Soubor, ve kterém je sekce `includes` uvedena, má vyšší prioritu než v něm inkludované soubory.
Parametry
---------
Parametry používané v konfiguračních souborech můžeme definovat [v sekci `parameters` |dependency-injection:configuration#Parametry] a také je předávat (či přepisovat) metodou `addParameters()`:
```php
$this->configurator->addParameters([
'projectId' => 23,
]);
```
Na parametr `projectId` se lze v konfiguraci odkázat obvyklým zápisem `%projectId%`. Jeho hodnota se zkompiluje do DI kontejneru, takže jiná hodnota vygeneruje další kontejner, tedy další třídu.
Dynamické parametry
-------------------
Některé hodnoty by se do kontejneru kompilovat neměly: IP adresa návštěvníka je při každém požadavku jiná a heslo by se nemělo ocitnout ve vygenerovaných souborech v adresáři `temp`. Takovou hodnotu označíte jako dynamickou tak, že ji obalíte do `Nette\DI\DynamicValue`. Předá se pak až při vytvoření kontejneru, takže její různé hodnoty negenerují nové kontejnery:
```php
$this->configurator->addParameters([
'remoteIp' => new Nette\DI\DynamicValue($_SERVER['REMOTE_ADDR']),
'env' => new Nette\DI\DynamicValue(getenv()),
]);
```
V konfiguraci se na ně odkazujete obvyklým způsobem, třeba `%remoteIp%`, a na proměnné prostředí zápisem `%env.variable%`.
Dynamická hodnota může být i hluboko uvnitř parametru. Tady je dynamické jen heslo, kdežto ostatní klíče parametru `database` z vašeho konfiguračního souboru, třeba `dsn` nebo `user`, zůstanou zkompilované v kontejneru:
```php
$this->configurator->addParameters([
'database' => [
'password' => new Nette\DI\DynamicValue(getenv('DB_PASSWORD')),
],
]);
```
Na heslo se odkážete zápisem `%database.password%`.
Označování dynamických hodnot pomocí `DynamicValue` funguje od nette/bootstrap 3.3.2 s nette/di 3.3. Statické a dynamické parametry už nemusíte rozlišovat podle toho, kterou metodu zavoláte: `addParameters()` opět přijímá oboje. Starší metody `addStaticParameters()` a `addDynamicParameters()` fungují dál.
Výchozí parametry
-----------------
V konfiguračních souborech můžete využít tyto parametry:
- `%appDir%` je absolutní cesta k adresáři se souborem `Bootstrap.php`
- `%wwwDir%` je absolutní cesta k adresáři se vstupním souborem `index.php`
- `%tempDir%` je absolutní cesta k adresáři pro dočasné soubory
- `%vendorDir%` je absolutní cesta k adresáři, kam Composer instaluje knihovny
- `%rootDir%` je absolutní cesta ke kořenovému adresáři projektu
- `%baseUrl%` je absolutní URL ke kořenovému adresáři (dynamický parametr vyhodnocovaný za běhu; mimo HTTP požadavek se odvozuje z [http: baseUrl |http:configuration#Základní URL aplikace])
- `%debugMode%` udává, zda je aplikace v debugovacím režimu
- `%consoleMode%` udává, zda request přišel přes příkazovou řádku
Importované služby
------------------
Nyní už jdeme hlouběji. Ačkoliv je smyslem DI kontejneru objekty vyrábět, výjimečně může vzniknout potřeba do kontejneru existující objekt vložit. Uděláme to tak, že službu definujeme s příznakem `imported: true`.
```neon
services:
myservice:
type: App\Model\MyCustomService
imported: true
```
A v bootstrapu do kontejneru vložíme objekt:
```php
$this->configurator->addServices([
'myservice' => new App\Model\MyCustomService('foobar'),
]);
```
Odlišné prostředí
=================
Nebojte se upravit třídu Bootstrap podle svých potřeb. Metodě `bootWebApplication()` můžete přidat parametry pro rozlišení webových projektů. Nebo můžeme doplnit další metody, například `bootTestEnvironment()`, která inicializuje prostředí pro jednotkové testy, `bootConsoleApplication()` pro skripty volané z příkazové řádky atd.
```php
public function bootTestEnvironment(): Nette\DI\Container
{
Tester\Environment::setup(); // inicializace Nette Testeru
$this->setupContainer();
return $this->configurator->createContainer();
}
public function bootConsoleApplication(): Nette\DI\Container
{
$this->configurator->setDebugMode(false);
$this->initializeEnvironment();
$this->setupContainer();
return $this->configurator->createContainer();
}
```
{{maintitle: Bootstrapping aplikace v Nette: od index.php po DI kontejner}}
{{description: Jak se aplikace v Nette spouští: od index.php a třídy Configurator přes vývojářský režim, Tracy a dočasné soubory až po konfiguraci v NEON.}}
Bootstrapping
Bootstrapping je proces inicializace prostředí aplikace, vytvoření kontejneru pro dependency injection (DI) a spuštění
aplikace. Budeme probírat:
- jak třída Bootstrap inicializuje prostředí
- jak jsou aplikace konfigurovány pomocí NEON souborů
- jak rozlišovat mezi produkčním a vývojářským režimem
- jak vytvořit a nakonfigurovat DI kontejner
Aplikace, ať už jde o ty webové nebo skripty spouštěné z příkazové řádky, začínají svůj běh nějakou formou
inicializace prostředí. V dávných dobách to míval na starosti soubor s názvem třeba include.inc.php, který
prvotní soubor inkludoval. V moderních Nette aplikacích jej nahradila třída Bootstrap, kterou jakožto
součást aplikace najdete v souboru app/Bootstrap.php. Může vypadat kupříkladu takto:
namespace App;
use Nette;
use Nette\Bootstrap\Configurator;
class Bootstrap
{
private Configurator $configurator;
private string $rootDir;
public function __construct()
{
$this->rootDir = dirname(__DIR__);
// Konfigurátor je zodpovědný za nastavení prostředí aplikace a služeb.
$this->configurator = new Configurator;
// Nastaví adresář pro dočasné soubory generované Nette (např. zkompilované šablony)
$this->configurator->setTempDirectory($this->rootDir . '/temp');
}
public function bootWebApplication(): Nette\DI\Container
{
$this->initializeEnvironment();
$this->setupContainer();
return $this->configurator->createContainer();
}
private function initializeEnvironment(): void
{
// Nette je chytré a vývojový režim se zapíná automaticky,
// nebo jej můžete povolit pro konkrétní IP adresu odkomentováním následujícího řádku:
// $this->configurator->setDebugMode('secret@23.75.345.200');
// Aktivuje Tracy: ultimátní "švýcarský nůž" pro ladění.
$this->configurator->enableTracy($this->rootDir . '/log');
// RobotLoader: automaticky načítá všechny třídy ve zvoleném adresáři
$this->configurator->createRobotLoader()
->addDirectory(__DIR__)
->register();
}
private function setupContainer(): void
{
// Načte konfigurační soubory
$this->configurator->addConfig($this->rootDir . '/config/common.neon');
}
}
index.php
Prvotní soubor je v případě webových aplikací index.php, který se nachází ve veřejném adresáři
www/. Ten si nechá od třídy Bootstrap inicializovat prostředí a vyrobit DI kontejner. Poté z něj získá
službu Application, která spustí webovou aplikaci:
$bootstrap = new App\Bootstrap;
// Inicializace prostředí + vytvoření DI kontejneru
$container = $bootstrap->bootWebApplication();
// DI kontejner vytvoří objekt Nette\Application\Application
$application = $container->getByType(Nette\Application\Application::class);
// Spuštění aplikace Nette a zpracování příchozího požadavku
$application->run();
Objekt $application během zpracování požadavku vyvolává události – onStartup, onRequest,
onPresenter, onResponse, onShutdown a onError (při nezachycené výjimce).
Můžete k nim připojit handlery, což se hodí pro logování nebo monitoring napříč aplikací.
Jak vidno, s nastavením prostředí a vytvořením dependency injection (DI) kontejneru pomáhá třída Nette\Bootstrap\Configurator, kterou si nyní
blíže představíme.
Vývojářský vs produkční režim
Nette se chová různě podle toho, zda běží na vývojářském nebo produkčním serveru:
- 🛠️ Vývojářský režim (Development)
- Zobrazuje Tracy debugbar s užitečnými informacemi (SQL dotazy, čas vykonání, použitá paměť)
- Při chybě zobrazí detailní chybovou stránku s voláním funkcí a obsahem proměnných
- Automaticky obnovuje cache při změně Latte šablon, úpravě konfiguračních souborů atd.
- 🚀 Produkční režim (Production)
- Nezobrazuje žádné ladicí informace, všechny chyby zapisuje do logu
- Při chybě zobrazí ErrorPresenter nebo obecnou stránku „Server Error“
- Cache se nikdy automaticky neobnovuje!
- Optimalizovaný pro rychlost a bezpečnost
Volba režimu se provádí autodetekcí, takže obvykle není potřeba nic konfigurovat nebo ručně přepínat:
- vývojářský režim: na localhostu (IP adresa
127.0.0.1 nebo ::1), pokud není přítomná proxy
(tj. její HTTP hlavička)
- produkční režim: všude jinde
Pokud chceme vývojářský režim povolit i v dalších případech, například programátorům přistupujícím
z konkrétní IP adresy, použijeme setDebugMode():
$this->configurator->setDebugMode('23.75.345.200'); // lze uvést i pole IP adres
Rozhodně doporučujeme kombinovat IP adresu s cookie. Do cookie nette-debug uložíme tajný token, např.
secret1234, a tímto způsobem aktivujeme vývojářský režim pro programátory přistupující z konkrétní IP
adresy a zároveň mající v cookie zmíněný token:
$this->configurator->setDebugMode('secret1234@23.75.345.200');
Vývojářský režim můžeme také vypnout úplně, i pro localhost:
$this->configurator->setDebugMode(false);
Pozor, hodnota true zapne vývojářský režim natvrdo, což se nikdy nesmí stát na produkčním serveru.
Autodetekci uvnitř zajišťuje statická metoda Configurator::detectDebugMode(), kterou můžete zavolat i sami,
například pro detekci vývojářského režimu mimo konfigurátor. Přijímá volitelný whitelist IP adres nebo názvů
počítačů a vrací, zda má aktuální požadavek běžet ve vývojářském režimu:
$debug = Nette\Bootstrap\Configurator::detectDebugMode('23.75.345.200');
Debugovací nástroj Tracy
Pro snadné debugování ještě zapneme skvělý nástroj Tracy. Ve vývojářském
režimu chyby vizualizuje a v produkčním režimu chyby loguje do uvedeného adresáře:
$this->configurator->enableTracy($this->rootDir . '/log');
Dočasné soubory
Nette využívá cache pro DI kontejner, RobotLoader, šablony atd. Proto je nutné nastavit cestu k adresáři, kam se bude
cache ukládat:
$this->configurator->setTempDirectory($this->rootDir . '/temp');
Na Linuxu nebo macOS nastavte adresářům log/ a temp/ práva pro zápis.
RobotLoader
Zpravidla budeme chtít automaticky načítat třídy pomocí RobotLoaderu,
musíme ho tedy nastartovat a necháme jej načítat třídy z adresáře, kde je umístěný Bootstrap.php (tj.
__DIR__), a všech podadresářů:
$this->configurator->createRobotLoader()
->addDirectory(__DIR__)
->register();
Alternativní přístup je nechat třídy načítat pouze přes Composer při dodržení PSR-4.
Timezone
Přes konfigurátor můžete nastavit výchozí časovou zónu.
$this->configurator->setTimeZone('Europe/Prague');
Konfigurace DI kontejneru
Součástí bootovacího procesu je vytvoření DI kontejneru neboli továrny na objekty, což je srdce celé aplikace. Jde
vlastně o PHP třídu, kterou vygeneruje Nette a uloží do adresáře s cache. Továrna vyrábí klíčové objekty aplikace a
pomocí konfiguračních souborů jí instruujeme, jak je má vytvářet a nastavovat, čímž ovlivňujeme chování celé
aplikace.
Konfigurační soubory se obvykle zapisují ve formátu NEON. V samostatné
kapitole se dočtete, co vše lze konfigurovat.
Ve vývojářském režimu se kontejner automaticky aktualizuje při každé změně kódu nebo konfiguračních
souborů. V produkčním režimu se vygeneruje jen jednou a změny se kvůli maximalizaci výkonu nekontrolují.
Zatímco createContainer() kontejner vytvoří a vrátí jeho instanci, metoda loadContainer()
vrátí jen název vygenerované třídy kontejneru, kterou si pak můžete vytvořit sami. To se hodí v pokročilých
scénářích.
Konfigurační soubory načteme pomocí addConfig():
$this->configurator->addConfig($this->rootDir . '/config/common.neon');
Pokud chceme přidat více konfiguračních souborů, můžeme funkci addConfig() zavolat vícekrát.
$configDir = $this->rootDir . '/config';
$this->configurator->addConfig($configDir . '/common.neon');
$this->configurator->addConfig($configDir . '/services.neon');
if (PHP_SAPI === 'cli') {
$this->configurator->addConfig($configDir . '/cli.php');
}
Název cli.php není překlep, konfigurace může být zapsaná také v PHP souboru, který ji vrátí
jako pole.
Také můžeme přidat další konfigurační soubory v sekci includes.
Pokud se v konfiguračních souborech objeví prvky se stejnými klíči, budou přepsány, nebo v případě polí sloučeny. Později vkládaný soubor
má vyšší prioritu než předchozí. Soubor, ve kterém je sekce includes uvedena, má vyšší prioritu než
v něm inkludované soubory.
Parametry
Parametry používané v konfiguračních souborech můžeme definovat v sekci parameters a také je
předávat (či přepisovat) metodou addParameters():
$this->configurator->addParameters([
'projectId' => 23,
]);
Na parametr projectId se lze v konfiguraci odkázat obvyklým zápisem %projectId%. Jeho hodnota se
zkompiluje do DI kontejneru, takže jiná hodnota vygeneruje další kontejner, tedy další třídu.
Dynamické parametry
Některé hodnoty by se do kontejneru kompilovat neměly: IP adresa návštěvníka je při každém požadavku jiná a heslo
by se nemělo ocitnout ve vygenerovaných souborech v adresáři temp. Takovou hodnotu označíte jako dynamickou
tak, že ji obalíte do Nette\DI\DynamicValue. Předá se pak až při vytvoření kontejneru, takže její různé
hodnoty negenerují nové kontejnery:
$this->configurator->addParameters([
'remoteIp' => new Nette\DI\DynamicValue($_SERVER['REMOTE_ADDR']),
'env' => new Nette\DI\DynamicValue(getenv()),
]);
V konfiguraci se na ně odkazujete obvyklým způsobem, třeba %remoteIp%, a na proměnné prostředí zápisem
%env.variable%.
Dynamická hodnota může být i hluboko uvnitř parametru. Tady je dynamické jen heslo, kdežto ostatní klíče parametru
database z vašeho konfiguračního souboru, třeba dsn nebo user, zůstanou zkompilované
v kontejneru:
$this->configurator->addParameters([
'database' => [
'password' => new Nette\DI\DynamicValue(getenv('DB_PASSWORD')),
],
]);
Na heslo se odkážete zápisem %database.password%.
Označování dynamických hodnot pomocí DynamicValue funguje od nette/bootstrap 3.3.2 s nette/di
3.3. Statické a dynamické parametry už nemusíte rozlišovat podle toho, kterou metodu zavoláte: addParameters()
opět přijímá oboje. Starší metody addStaticParameters() a addDynamicParameters()
fungují dál.
Výchozí parametry
V konfiguračních souborech můžete využít tyto parametry:
%appDir% je absolutní cesta k adresáři se souborem Bootstrap.php
%wwwDir% je absolutní cesta k adresáři se vstupním souborem index.php
%tempDir% je absolutní cesta k adresáři pro dočasné soubory
%vendorDir% je absolutní cesta k adresáři, kam Composer instaluje knihovny
%rootDir% je absolutní cesta ke kořenovému adresáři projektu
%baseUrl% je absolutní URL ke kořenovému adresáři (dynamický parametr vyhodnocovaný za běhu; mimo HTTP
požadavek se odvozuje z http: baseUrl)
%debugMode% udává, zda je aplikace v debugovacím režimu
%consoleMode% udává, zda request přišel přes příkazovou řádku
Importované služby
Nyní už jdeme hlouběji. Ačkoliv je smyslem DI kontejneru objekty vyrábět, výjimečně může vzniknout potřeba do
kontejneru existující objekt vložit. Uděláme to tak, že službu definujeme s příznakem imported: true.
services:
myservice:
type: App\Model\MyCustomService
imported: true
A v bootstrapu do kontejneru vložíme objekt:
$this->configurator->addServices([
'myservice' => new App\Model\MyCustomService('foobar'),
]);
Odlišné prostředí
Nebojte se upravit třídu Bootstrap podle svých potřeb. Metodě bootWebApplication() můžete přidat parametry
pro rozlišení webových projektů. Nebo můžeme doplnit další metody, například bootTestEnvironment(), která
inicializuje prostředí pro jednotkové testy, bootConsoleApplication() pro skripty volané z příkazové
řádky atd.
public function bootTestEnvironment(): Nette\DI\Container
{
Tester\Environment::setup(); // inicializace Nette Testeru
$this->setupContainer();
return $this->configurator->createContainer();
}
public function bootConsoleApplication(): Nette\DI\Container
{
$this->configurator->setDebugMode(false);
$this->initializeEnvironment();
$this->setupContainer();
return $this->configurator->createContainer();
}