Alexander Makarov
9 years ago
32 changed files with 741 additions and 331 deletions
@ -1,23 +1,20 @@
|
||||
Przegląd |
||||
Przegląd |
||||
======== |
||||
|
||||
Za każdym razem kiedy aplikacja Yii obsługuje żądanie, przetwarza je w podobny sposób. |
||||
|
||||
1. Użytkownik wykonuje żądanie do [skryptu wejściowego](structure-entry-scripts.md) `web/index.php`. |
||||
2. Skrypt wejściowy ładuje [konfigurację](concept-configurations.md) aplikacji i tworzy |
||||
[instancję aplikacji](structure-applications.md) aby obsłużyć zapytanie. |
||||
3. Aplikacja osiąga żądaną [ścieżkę](runtime-routing.md) za pomocą komponentu |
||||
[żądania](runtime-requests.md) aplikacji. |
||||
4. Aplikacja tworzy instancję [kontrolera](structure-controllers.md), który obsłuży żądanie. |
||||
5. Kontroler tworzy instancję [akcji](structure-controllers.md) i wykonuje filtry dla akcji. |
||||
6. Jeżeli jakikolwiek filtr się nie wykona, akcja zostanie anulowana. |
||||
7. Jeżeli wszystkie filtry przejdą, akcja zostaje wykonana. |
||||
8. Akcja wczytuje model danych, być może z bazy danych. |
||||
9. Akcja renderuje widok dostarczając go z modelem danych. |
||||
10. Wyrenderowana zawartość jest zwracana do komponentu [odpowiedzi](runtime-responses.md) aplikacji. |
||||
11. Komponent odpowiedzi wysyła wyrenderowaną zawartość do przeglądarki użytkownika. |
||||
Ten diagram pokazuje jak aplikacja obsługuje żądanie. |
||||
Za każdym razem kiedy aplikacja Yii obsługuje żądanie, przetwarza je w podobny sposób. |
||||
|
||||
![Request Lifecycle](images/request-lifecycle.png) |
||||
1. Użytkownik wykonuje żądanie do [skryptu wejściowego](structure-entry-scripts.md) `web/index.php`. |
||||
2. Skrypt wejściowy ładuje [konfigurację](concept-configurations.md) aplikacji i tworzy [instancję aplikacji](structure-applications.md), aby obsłużyć zapytanie. |
||||
3. Aplikacja osiąga żądaną [ścieżkę](runtime-routing.md) za pomocą komponentu [żądania](runtime-requests.md) aplikacji. |
||||
4. Aplikacja tworzy instancję [kontrolera](structure-controllers.md), który obsłuży żądanie. |
||||
5. Kontroler tworzy instancję [akcji](structure-controllers.md) i przetwarza filtry dla akcji. |
||||
6. Jeżeli jakikolwiek filtr się nie wykona, akcja zostanie anulowana. |
||||
7. Jeżeli wszystkie filtry przejdą, akcja zostaje wykonana. |
||||
8. Akcja wczytuje model danych, być może z bazy danych. |
||||
9. Akcja renderuje widok dostarczając go z modelem danych. |
||||
10. Wyrenderowana zawartość jest zwracana do komponentu [odpowiedzi](runtime-responses.md) aplikacji. |
||||
11. Komponent odpowiedzi wysyła wyrenderowaną zawartość do przeglądarki użytkownika. |
||||
|
||||
W tej sekcji opiszemy szczegóły dotyczące niektórych kroków przetwarzania żądania. |
||||
![Cykl życia żądania](../guide/images/request-lifecycle.png) |
||||
|
||||
W tej sekcji opiszemy szczegóły dotyczące niektórych kroków przetwarzania żądania. |
@ -0,0 +1,117 @@
|
||||
Komponenty aplikacji |
||||
====================== |
||||
|
||||
Aplikacje są [lokatorami usług](concept-service-locator.md). Posiadają one zestawy *komponentów aplikacji*, |
||||
które zajmują się dostarczaniem różnych serwisów do obsługi żądań. Dla przykładu, |
||||
komponent `urlManager` jest odpowiedzialny za przekierowania żądań do odpowiednich kontrolerów, |
||||
komponent `db` dostarcza serwisy powiązane z bazami danych, itp. |
||||
|
||||
|
||||
Każdy komponent aplikacji posiada unikalne ID identyfikujące go w całej aplikacji. |
||||
Możesz dostać się do tego komponentu przez wyrażenie: |
||||
|
||||
```php |
||||
\Yii::$app->componentID |
||||
``` |
||||
|
||||
Dla przykładu, możesz użyć `\Yii::$app->db` do uzyskania [[yii\db\Connection|połączenia z bazą danych]] lub `\Yii::$app->cache` do uzyskania |
||||
[[yii\caching\Cache|dostępu do pamięci podręcznej]] zarejestrowanej w aplikacji. |
||||
|
||||
Komponent jest tworzony przy pierwszym jego wywołaniu przez powyższe wyrażenie, każde kolejne wywołanie zwróci tą samą instancję tego komponentu. |
||||
|
||||
Komponentami aplikacji może być każdy objekt. Możesz je zarejestrować przez skonfigurowanie parametru [[yii\base\Application::components|components]] w |
||||
[konfiguracji aplikacji](structure-applications.md#application-configurations). |
||||
Dla przykładu: |
||||
|
||||
```php |
||||
[ |
||||
'components' => [ |
||||
// rejestracja komponentu "cache" przy użyciu nazwy klasy |
||||
'cache' => 'yii\caching\ApcCache', |
||||
|
||||
// rejestracja komponentu "db" przy użyciu tablicy konfiguracyjnej |
||||
'db' => [ |
||||
'class' => 'yii\db\Connection', |
||||
'dsn' => 'mysql:host=localhost;dbname=demo', |
||||
'username' => 'root', |
||||
'password' => '', |
||||
], |
||||
|
||||
// rejestracja komponentu "search" przy użyciu funkcji anonimowej |
||||
'search' => function () { |
||||
return new app\components\SolrService; |
||||
}, |
||||
], |
||||
] |
||||
``` |
||||
|
||||
> Info: Możesz zarejestrować tak wiele komponentów jak chcesz, jednak powinieneś robić to rozważnie. |
||||
> Komponenty aplikacji są podobne do zmiennych globalnych. |
||||
> Używanie zbyt wielu komponentów może potencjalnie uczynić Twój kod trudniejszym do testowania i utrzymania. |
||||
> W wielu przypadkach możesz po prostu utworzyć lokalny komponent i użyć go, kiedy jest to konieczne. |
||||
|
||||
|
||||
## Bootstrapping komponentów <span id="bootstrapping-components"></span> |
||||
|
||||
Tak, jak było wspomniane wcześniej, komponent aplikacji zostanie zinstancjowany tylko w momencie pierwszego wywołania. |
||||
Czasami jednak chcemy, aby komponent został zainstancjowany dla każdego żądania, nawet jeśli nie jest bezpośrednio wywoływany. |
||||
Aby to osiągnąć, możesz wylistować ID komponentów we właściwości [[yii\base\Application::bootstrap|bootstrap]] aplikacji. |
||||
|
||||
|
||||
Dla przykładu, następująca konfiguracja aplikacji zapewnia załadowanie komponentu `log` przy każdym żądaniu: |
||||
|
||||
```php |
||||
[ |
||||
'bootstrap' => [ |
||||
'log', |
||||
], |
||||
'components' => [ |
||||
'log' => [ |
||||
// konfiguracja komponentu `log` |
||||
], |
||||
], |
||||
] |
||||
``` |
||||
|
||||
|
||||
## Podstawowe komponenty aplikacji <span id="core-application-components"></span> |
||||
|
||||
Yii posiada podstawowe komponenty aplikacji ze stałymi ID oraz domyślną ich konfiguracją. Dla przykładu, |
||||
komponent [[yii\web\Application::request|request]] jest używany do zbierania informacji na temat żądania użytkownika |
||||
oraz przekazanie go do [route'a](runtime-routing.md); [[yii\base\Application::db|db]] reprezentuje |
||||
połączenie z bazą danych, dzięki któremu możesz wykonywać zapytania do bazy. |
||||
Z pomocą tych podstawowych komponentów aplikacja jest w stanie obsłużyć żądania użytkowników. |
||||
|
||||
Poniżej znajduje się lista predefiniowanych podstawowych komponentów aplikacji. Możesz je konfigurować lub zmieniać, |
||||
tak jak z normalnymi komponentami. Podczas konfigurowania podstawowych komponentów aplikacji, w przypadku nie podania klasy, |
||||
zostanie użyta klasa domyślna. |
||||
|
||||
* [[yii\web\AssetManager|assetManager]]: zarządzanie zasobami oraz ich publikacja. |
||||
Po więcej informacji zajrzyj do sekcji [Assets](structure-assets.md). |
||||
* [[yii\db\Connection|db]]: reprezentuje połączenie z bazą danych, dzięki której możliwe jest wykonywanie zapytań. |
||||
Konfigurując ten komponent musisz określić klasę komponentu, tak samo jak inne wymagane właściwości, np. [[yii\db\Connection::dsn|dsn]]. |
||||
Po więcej informacji zajrzyj do sekcji [Obiekty dostępu do danych (DAO)](db-dao.md). |
||||
* [[yii\base\Application::errorHandler|errorHandler]]: obsługuje błędy oraz wyjątki PHP. |
||||
Po więcej informacji zajrzyj do sekcji [Obsługa błędów](runtime-handling-errors.md). |
||||
* [[yii\i18n\Formatter|formatter]]: formatuje dane wyświetlane użytkownikom. Dla przykładu liczba może zostać wyświetlona z separatorem tysięcy. |
||||
Po więcej informacji zajrzyj do sekcji [Formatowanie danych](output-formatting.md). |
||||
* [[yii\i18n\I18N|i18n]]: wspiera tłumaczenie i formatowanie wiadomości. |
||||
Po więcej informacji zajrzyj do sekcji [Internacjonalizacja](tutorial-i18n.md). |
||||
* [[yii\log\Dispatcher|log]]: zarządza logowaniem informacji oraz błędów |
||||
Po więcej informacji zajrzyj do sekcji [Logowanie](runtime-logging.md). |
||||
* [[yii\swiftmailer\Mailer|mail]]: wspiera tworzenie oraz wysyłanie emaili. |
||||
Po więcej informacji zajrzyj do sekcji [Wysyłanie poczty](tutorial-mailing.md). |
||||
* [[yii\base\Application::response|response]]: reprezentuje odpowiedź wysyłaną do użytkowników. |
||||
Po więcej informacji zajrzyj do sekcji [Odpowiedzi](runtime-responses.md). |
||||
* [[yii\base\Application::request|request]]: reprezentuje żądanie otrzymane od użytkownika. |
||||
Po więcej informacji zajrzyj do sekcji [Żądania](runtime-requests.md). |
||||
* [[yii\web\Session|session]]: reprezentuje informacje przetrzymywane w sesji. Ten komponent jest dostępny |
||||
tylko w [[yii\web\Application|aplikacjach WEB]]. |
||||
Po więcej informacji zajrzyj do sekcji [Sesje i ciasteczka](runtime-sessions-cookies.md). |
||||
* [[yii\web\UrlManager|urlManager]]: wspiera przetwarzania oraz tworzenie adresów URL. |
||||
Po więcej informacji zajrzyj do sekcji [Przetwarzanie i tworzenie adresów URL](runtime-routing.md) |
||||
* [[yii\web\User|user]]: reprezentuje informacje dotyczące uwierzytelniania użytkownika. Ten komponent jest dostępny |
||||
tylko w [[yii\web\Application|aplikacjach WEB]]. |
||||
Po więcej informacji zajrzyj do sekcji [Uwierzytelnianie](security-authentication.md). |
||||
* [[yii\web\View|view]]: wspiera renderowanie widoków. |
||||
Po więcej informacji zajrzyj do sekcji [Widoki](structure-views.md). |
@ -0,0 +1,226 @@
|
||||
Wysyłanie poczty |
||||
======= |
||||
|
||||
> Note: Ta sekcja jest w trakcie tworzenia. |
||||
|
||||
Yii wspiera tworzenie oraz wysyłanie wiadomości email, jednakże silnik dostarcza jedynie funkcjonalność składania treści oraz prosty interfejs. |
||||
Mechanizm wysyłania wiadomości powinien być dostarczony przez rozszerzenie, |
||||
ponieważ projekty mogą wymagać różnych implementacji, przez co mechanizm jest zależny od zewnętrznych usług i bibliotek. |
||||
|
||||
Dla większości przypadków możesz używać oficjalnego rozszerzenia [yii2-swiftmailer](https://github.com/yiisoft/yii2-swiftmailer). |
||||
|
||||
|
||||
Konfiguracja |
||||
------------- |
||||
|
||||
Konfiguracja tego komponentu zależy od rozszerzenia jakie wybrałeś. |
||||
Generalnie, konfiguracja Twojego komponentu w aplikacji powinna wyglądać tak: |
||||
|
||||
```php |
||||
return [ |
||||
//.... |
||||
'components' => [ |
||||
'mailer' => [ |
||||
'class' => 'yii\swiftmailer\Mailer', |
||||
], |
||||
], |
||||
]; |
||||
``` |
||||
|
||||
|
||||
Podstawowe użycie |
||||
----------- |
||||
Kiedy komponent 'mailer' zostanie skonfigurowany, możesz użyć następującego kodu do wysłania wiadomości email: |
||||
|
||||
```php |
||||
Yii::$app->mailer->compose() |
||||
->setFrom('from@domain.com') |
||||
->setTo('to@domain.com') |
||||
->setSubject('Temat wiadomości') |
||||
->setTextBody('Zwykła treść wiadomości') |
||||
->setHtmlBody('<b>Treść HTML wiadomości</b>') |
||||
->send(); |
||||
``` |
||||
|
||||
W powyższym przykładzie metoda `compose()` tworzy instancję wiadomości email, która następnie jest wypełniana danymi i wysłana. |
||||
Możesz utworzyć tutaj więcej złożonej logiki jeśli jest to potrzebne: |
||||
|
||||
```php |
||||
$message = Yii::$app->mailer->compose(); |
||||
if (Yii::$app->user->isGuest) { |
||||
$message->setFrom('from@domain.com') |
||||
} else { |
||||
$message->setFrom(Yii::$app->user->identity->email) |
||||
} |
||||
$message->setTo(Yii::$app->params['adminEmail']) |
||||
->setSubject('Temat wiadomości') |
||||
->setTextBody('Zwykła treść wiadomości') |
||||
->send(); |
||||
``` |
||||
|
||||
> Note: każde rozszerzenie mailingowe posiada dwie główne klasy: 'Mailer' oraz 'Message'. Klasa 'Mailer' zawsze posiada nazwę klasy 'Message'. |
||||
> Nie próbuj instancjować obiektu 'Message' bezpośrednio - zawsze używaj do tego metody `compose()`. |
||||
|
||||
Możesz również wysłać wiele wiadomości na raz: |
||||
|
||||
```php |
||||
$messages = []; |
||||
foreach ($users as $user) { |
||||
$messages[] = Yii::$app->mailer->compose() |
||||
// ... |
||||
->setTo($user->email); |
||||
} |
||||
Yii::$app->mailer->sendMultiple($messages); |
||||
``` |
||||
|
||||
Niektóre rozszerzenia mailingowe mogą czerpać korzyści z tego sposobu, np. używając pojedyńczych wiadomości sieciowych. |
||||
|
||||
|
||||
Tworzenie treści maila |
||||
---------------------- |
||||
|
||||
Yii pozwala na tworzenie treści aktualnej wiadomości email przez specjalne pliki widoków. |
||||
Domyślnie, pliki te zlokalizowane są w ścieżce '@app/mail'. |
||||
|
||||
Przykładowy widok pliku treści wiadomości email: |
||||
|
||||
```php |
||||
<?php |
||||
use yii\helpers\Html; |
||||
use yii\helpers\Url; |
||||
|
||||
|
||||
/* @var $this \yii\web\View instancja komponentu View */ |
||||
/* @var $message \yii\mail\BaseMessage instancja nowo utworzonej wiadomości email */ |
||||
|
||||
?> |
||||
<h2>Ta wiadomość pozwala Ci odwiedzić stronę główną naszej witryny przez jedno kliknięcie</h2> |
||||
<?= Html::a('Idź do strony głównej', Url::home('http')) ?> |
||||
``` |
||||
|
||||
W celu wykorzystania tego pliku do utworzenia treści wiadomości, przekaż po prostu nazwę tego widoku do metody `compose()`: |
||||
|
||||
```php |
||||
Yii::$app->mailer->compose('home-link') // wynik renderingu widoku staje się treścią wiadomości |
||||
->setFrom('from@domain.com') |
||||
->setTo('to@domain.com') |
||||
->setSubject('Temat wiadomości') |
||||
->send(); |
||||
``` |
||||
|
||||
Możesz przekazać dodatkowe parametry do metody `compose()`, które będą dostępne w plikach widoków: |
||||
|
||||
```php |
||||
Yii::$app->mailer->compose('greetings', [ |
||||
'user' => Yii::$app->user->identity, |
||||
'advertisement' => $adContent, |
||||
]); |
||||
``` |
||||
|
||||
Możesz określić różne pliki do zwykłej treści oraz treści HTML: |
||||
|
||||
```php |
||||
Yii::$app->mailer->compose([ |
||||
'html' => 'contact-html', |
||||
'text' => 'contact-text', |
||||
]); |
||||
``` |
||||
|
||||
Jeśli określisz nazwę widoku jako ciąg skalarny, to wynik jego renderowania zostanie użyty jako ciało HTML wiadomości, |
||||
podczas gdy przy użyciu zwykłego teksu zostanie ono utworzone przez usunięcie wszystkich encji HTML z tego widoku. |
||||
|
||||
Wynik renderowania widoku może zostać opakowany w szablon. Szablon możesz ustawić przez właściwość [[yii\mail\BaseMailer::htmlLayout|htmlLayout]] lub |
||||
[[yii\mail\BaseMailer::textLayout|textLayout]]. |
||||
Zadziała to w identyczny sposób co w standardowej aplikacji web. |
||||
Szalony mogą zostać użyte do ustawienia styli CSS, lub innej wspólnej treści: |
||||
|
||||
```php |
||||
<?php |
||||
use yii\helpers\Html; |
||||
|
||||
/* @var $this \yii\web\View view component instance */ |
||||
/* @var $message \yii\mail\MessageInterface the message being composed */ |
||||
/* @var $content string main view render result */ |
||||
?> |
||||
<?php $this->beginPage() ?> |
||||
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> |
||||
<html xmlns="http://www.w3.org/1999/xhtml"> |
||||
<head> |
||||
<meta http-equiv="Content-Type" content="text/html; charset=<?= Yii::$app->charset ?>" /> |
||||
<style type="text/css"> |
||||
.heading {...} |
||||
.list {...} |
||||
.footer {...} |
||||
</style> |
||||
<?php $this->head() ?> |
||||
</head> |
||||
<body> |
||||
<?php $this->beginBody() ?> |
||||
<?= $content ?> |
||||
<div class="footer">Z pozdrowieniami, zespół <?= Yii::$app->name ?></div> |
||||
<?php $this->endBody() ?> |
||||
</body> |
||||
</html> |
||||
<?php $this->endPage() ?> |
||||
``` |
||||
|
||||
|
||||
Załączniki do wiadomości |
||||
--------------- |
||||
|
||||
Możesz dodać załączniki do wiadomości przez użycie metod `attach()` oraz `attachContent()`: |
||||
|
||||
```php |
||||
$message = Yii::$app->mailer->compose(); |
||||
|
||||
// Załącz plik z lokalnego systemu plików: |
||||
$message->attach('/path/to/source/file.pdf'); |
||||
|
||||
// Utwórz załącznik w locie: |
||||
$message->attachContent('Attachment content', ['fileName' => 'attach.txt', 'contentType' => 'text/plain']); |
||||
``` |
||||
|
||||
|
||||
Osadzanie obrazków |
||||
---------------- |
||||
|
||||
W treści wiadomości możesz osadzać również obrazki przy użyciu metody `embed()`. Metoda ta zwraca ID załącznika, |
||||
który powinien zostać później użyty w tagu 'img'. |
||||
Użycie tej metody jest proste podczas tworzenia treści wiadomości z pliku widoku: |
||||
|
||||
```php |
||||
Yii::$app->mailer->compose('embed-email', ['imageFileName' => '/path/to/image.jpg']) |
||||
// ... |
||||
->send(); |
||||
``` |
||||
|
||||
Następnie, w pliku widoku możesz użyć następującego kodu: |
||||
|
||||
```php |
||||
<img src="<?= $message->embed($imageFileName); ?>"> |
||||
``` |
||||
|
||||
|
||||
Testowanie i debugowanie |
||||
--------------------- |
||||
|
||||
Deweloperzy często muszą sprawdzić, czy emaile zostały wysłane przez aplikację lub jaka była ich treść. |
||||
Możesz tego dokonać w łatwy sposób, używając dostarczonej przez Yii funkcjonalności, którą aktywujesz przez parametr [[yii\mail\BaseMailer::useFileTransport|useFileTransport]]. |
||||
Jeśli zostanie aktywowana, każda wiadomość email będzie zapisywana do lokalnych plików zamiast zostać wysłana. Wszystkie pliki będą zapisane w ścieżce podanej w |
||||
[[yii\mail\BaseMailer::fileTransportPath|fileTransportPath]], która domyślnie ustawiona jest na '@runtime/mail'. |
||||
|
||||
> Note: możesz albo zapisywać wiadomości do plików, albo wysyłać je do odbiorców, nie można wykonać tych dwóch czynności na raz. |
||||
|
||||
Plik z wiadomością email może zostać otwarty przez standardowy edytor tekstu, dzięki czemu będziesz mógł przeglądać nagłówki oraz treść wiadomości. |
||||
|
||||
> Note: plik wiadomości jest tworzony przy użyciu metody [[yii\mail\MessageInterface::toString()|toString()]], więc jest zależny od aktualnie używanego rozszerzenia mailingowego w |
||||
> Twojej aplikacji. |
||||
|
||||
Tworzenie własnego rozwiązania mailingowego |
||||
------------------------------- |
||||
|
||||
Aby utworzyć swoje własne rozwiązanie mailingowe, musisz utworzyć dwie klasy: 'Mailer' oraz 'Message'. |
||||
Możesz rozszerzyć klasy [[yii\mail\BaseMailer|BaseMailer]] i [[yii\mail\BaseMessage|BaseMessage]] jako bazowe klasy do tego rozwiązania. |
||||
Zawierają one podstawową logikę mechanizmu mailingu, który został opisany w tej sekcji. |
||||
Oczywiście ich użycie nie jest obowiązkowe, wystarczy zaimplementowanie interfejsów [[yii\mail\MailerInterface|MailerInterface]] oraz [[yii\mail\MessageInterface|MessageInterface]]. |
||||
Następnie musisz zaimplementować wszystkie abstrakcyjne metody do swoich klas. |
Loading…
Reference in new issue