Za pomocą Zenda stworzyć można praktycznie każdą aplikację webową, zawiera on w sobie bardzo domyślnych komponentów, zaczynając od absolutnie podstawowych, na bardziej wyspecjalizowanych skończywszy. Obecnie rozwijana jest wersja 2 frameworka, a za niedługo światło dzienne ujrzy wersja trzecia. Tutaj zajmiemy się właśnie tą drugą wersją i w cyklu artykułów nauczymy się krok po kroku pisania aplikacji za pomocą frameworka Zend.
Na samym początku, podobnie jak w większości artykułów tutaj - cykl tutoriali zaczynamy od opisu instalacji, wstępu i podstawowej konfiguracji środowiska. Zaczynamy więc.
Instalacja
Oficjalną stronę frameworka i sam framework do pobrania znajdziemy pod adresem: http://framework.zend.com, znajduje się tam także obszerna dokumentacja wraz z całą masą przykładów, z którą warto się oczywiście zapoznać.Zainstalować można Zenda na kilka sposobów i z kilku źródeł, my pobierzemy sobie archiwum ze szkieletem aplikacji, ale możemy też pobrać "czystą" wersję w postaci archium .zip ze strony, lub z GitHUB-a: https://github.com/zendframework/zf2.
Instalując natomiast Zenda za pomocą Composera - http://framework.zend.com/downloads/composer - możemy wybrać sobie pakiety jakie chcemy wraz z Zendem zainstalować.
My pobierzemy sobie wersję z aplikacją testową z GitHUB-a, a następnie zainstalujemy ją za pomocą Composera. Pobierzmy więc teraz instalkę Zenda z GitHuba którymś z poniższych sposobów:
1) albo klonując repozytorium:
[code]$ cd C:/www/
$ git clone git://github.com/zendframework/ZendSkeletonApplication.git zend[/code]
2) albo jako archiwum zip: https://github.com/zendframework/ZendSkeletonApplication/archive/master.zip
W drugim przypadku rozpakujmy sobie pliki, np. do folderu:
[code]C:/www/zend[/code]
lub oczywiście gdziekolwiek indziej, na screenach będzie to u mnie "c:/wamp/www/zend", jednakże dla przykładu będę podawał tutaj c:/www/zend/.
Mając już pobrane lub rozpakiwane pliki, uruchomimy teraz Composera.
Wchodzimy z poziomu terminalu do katalogu z Zendem i wykonujemy polecenie:
[code]$ composer install[/code]
Zend doinstaluje sobie kilka bibliotek i będzie już gotowy do pracy.
V-host
Następnym krokiem będzie utworzenie v-hosta wskazującego na katalog:[code]/public[/code]
w katalogu z Zendem, czyli w naszym przykładzie:
[code]c:/www/zend/public[/code]
Jest to ważne, gdyż tylko folder /public będziemy udostępniać poprzez WWW. Cała reszta kodu i katalogów będzie z tego poziomu niedostępna.
Jak stworzyć v-hosta w Apache'u - opisałem krok po kroku w tym artykule.
Tworzymy zatem v-hosta wskazującego na katalog /public i nazywamy go np.:
[code]zend.localhost[/code]
Gdy mamy już v-hosta wchodzimy na niego, aby sprawdzić, czy Zend zainstalowany został poprawnie. Jeśli wszystko poszło zgodnie z planem, powinniśmy zobaczyć coś mniej więcej takiego:
[code]http://zend.localhost/[/code]
Struktura katalogów frameworka
Przyjrzyjmy się teraz strukturze katalogów z aplikacją Zenda:
- /config - zawiera globalne pliki konfiguracyjne
- /data - zawierać będzie inne pliki, takie jak cache, upload, logi
- /module - najważniejsza część naszej aplikacji, z definicjami naszych kontrolerów, modeli, widoków itd.
- /public - folder publiczny dostępny z poziomu WWW, css, pliki js itp.
- /vendor - zewnętrzne biblioteki, m.in. główne biblioteki frameworka Zend
Moduły, kontrolery, akcje
Najważniejszym dla nas katalogiem będzie /module. To właśnie w nim będziemy trzymać kod naszych kontrolerów, ustawienia, widoki i generalnie całą strukturę naszej aplikacji.Jak widzimy, w Zendzie każda aplikacja składa się z tzw. modułów. Moduły z koleji składają się z kontrolerów i ich akcji.
Naszym głównym modułem może być więc ta część aplikacji, która jest dostępna użytkownikom (front-end), a kolejnym modułem może być sekcja administracyjna dostępna tylko dla administratora (back-end).
Z koleji każdy z tych modułów może składać się z wielu kontrolerów, z czego każdy będzie oddzielną sekcją, np. jeden kontroler odpowiedzialny za obsługę użytkowników, inny za obsługę komentarzy na stronie, jeszcze inny za artykuły it. Kontrolery z koleji mogą być podzielone na akcje takie jak: dodaj, edytuj, wyświetl itd.
Na przykładzie tej szkieletowej aplikacji widzimy, że:
- aplikacja składa się z jednego modułu o nazwie Application:
/module/Application - moduł Application składa się z jednego domyślnego kontrolera o nazwie IndexController:
/module/Application/src/Application/Controller/IndexController.php - kontroler IndexController składa się z jednej domyślnej akcji: indexAction:
[code]
public function indexAction()
{
return new ViewModel();
}[/code]
Kontroler IndexController powinien być zawsze domyślnym kontrolerem w module, natomiast akcja indexAction domyślną akcją w kontrolerze.
Routing
Do poszczególnych kontrolerów i ich akcji dostajemy się w Zendzie na zasadzie:[code]http://nasza_aplikacja.com/moduł/kontroler/akcja[/code]
Przykładowo:
[code]http://zend.localhost/application/index/index[/code]
zwróci nam akcję index z kontrolera index z modułu application.
Identyczne działanie będzie mieć wpisanie adresu:
[code]http://zend.localhost/application/index[/code]
gdzie jak widać podaliśmy jedynie nazwę modułu i kontrolera bez podania akcji, a mimo to wyświetliła nam się akcja index. Stało się tak, ponieważ akcja index jest tutaj akcją domyślną i wywołuje się automatycznie, gdy nie podamy tutaj żadnej innej akcji w wywołaniu. Analogicznie ma się sprawa z kontrolerem:
[code]http://zend.localhost/application[/code]
wywoła kontroler index z akcją index, gdyż kontroler index jest tutaj kontrolerem domyślnym.
Konfiguracja modułu - module.config.php
Domyślny kontroler i domyślną akcję możemy zmienić w głównym pliku konfiguracyjnym naszego modułu:[code]/module/application/config/module.config.php[/code]
Otwórzmy sobie ten plik.
Jak widzimy główna konfiguracja modułu składa się z tablicy:
[code]
array(
"router" => opcje,
"service_manager" => opcje,
"translator" => opcje,
"controllers" => opcje,
"view_manager" => opcje,
"console" => opcje
)[/code]
Poszczególne sekcje konfiguracji omówimy sobie w kolejnych artykułach.
Zobaczmy teraz jak wygląda plik z definicją kontrolera:
[code]/module/Application/src/Application/Controller/IndexController.php[/code]
[code]
<?php
namespace Application\Controller;
use Zend\Mvc\Controller\AbstractActionController;
use Zend\View\Model\ViewModel;
class IndexController extends AbstractActionController
{
public function indexAction()
{
return new ViewModel();
}
}[/code]
Tworzymy własną akcję
Dodajmy do kontrolera Index nową akcję, np. o nazwie hello:[code]
<?php
namespace Application\Controller;
use Zend\Mvc\Controller\AbstractActionController;
use Zend\View\Model\ViewModel;
class IndexController extends AbstractActionController
{
public function indexAction()
{
return new ViewModel();
}
// nowa akcja
public function helloAction()
{
return new ViewModel();
}
}[/code]
Zapiszmy plik i zobaczmy co się stanie po wejściu w adres:
[code]http://zend.localhost/application/index/hello[/code]
Jak widać otrzymamy błąd i załadowany zostanie widok określony w pliku:
[code]/module/application/config/module.config.php[/code]
w sekcji:
[code]
'template_map' => array(
'layout/layout' => __DIR__ . '/../view/layout/layout.phtml',
'application/index/index' => __DIR__ . '/../view/application/index/index.phtml',
'error/404' => __DIR__ . '/../view/error/404.phtml', // <<<<<<<< nasz widok z błędem
'error/index' => __DIR__ . '/../view/error/index.phtml',
),[/code]
Warstwa widoku
Aby przejść dalej opowiedzmy sobie o widokach.Pliki naszego widoku przechowywane są w formie plików:
[code].phtml[/code]
w katalogu:
[code]/module/Application/view/[/code]
Głównym plikiem widoku jest layout.phtml.
To dopiero do layoutu dołączane są pozostałe widoki jakie określamy dla danych akcji.
Widoki dołączane są do layoutu w miejscu wystąpienia:
[code]<?php echo $this->content; ?>[/code]
Rozwiązanie takie pozwala nam na modularną budowę widoków dla naszej aplikacji.
Utwórzmy teraz widok dla akcji, którą dodaliśmy akapit wyżej.
Stwórzmy plik:
[code]/module/Application/view/application/index/hello.phtml[/code]
i wpiszmy w nim jako zawartość:
[code]<h1>Hello World!</h1>[/code]
Nastepnie ponownie spróbujmy wywołać akcję hello:
[code]http://zend.localhost/application/index/hello[/code]
Jak widzimy nasza akcja została wywołana z naszym nowym widokiem:
Tworzymy własny kontroler
Umiemy już dodawać akcję do kontrolera, w takim razie dodajmy teraz całkowicie nowy kontroler, np. o nazwie Users. Utwórzmy plik z definicją nowego kontrolera:[code]/module/Application/src/Application/Controller/UsersController.php[/code]
o treści:
[code]
<?php
namespace Application\Controller;
use Zend\Mvc\Controller\AbstractActionController;
use Zend\View\Model\ViewModel;
class UsersController extends AbstractActionController
{
public function indexAction()
{
return new ViewModel();
}
public function profileAction()
{
return new ViewModel();
}
}[/code]
Nasz nowy kontroler będzie posiadał dwie akcje:
- index - akcję domyślną wyświetlającą np. listę użytkowników
- profile - akcję wyświetlającą profil danego użytkownika
Następnie utwórzmy folder z widokami dla nowego kontrolera:
[code]/module/Application/view/application/users/[/code]
a w nim dwa pliki z widokami, po jednym dla każdej z akcji:
1) /module/Application/view/application/users/index.phtml o treści:
[code]<h1>Hello World!</h1>
<h2>index - lista userów</h2>[/code]
2) /module/Application/view/application/users/profile.phtml o treści:
[code]<h1>Hello World!</h1>
<h2>profile - profil usera</h2>[/code]
Mamy już plik z definicją klasy naszego kontrolera oraz 2 pliki z widokami dla jego akcji.
Czas sprawdzić, co nam się wyświetli po wywołaniu naszego nowego kontrolera:
[code]http://zend.localhost/application/users[/code]
Niestety, ale wyświetlił nam się błąd. Dlaczego?
Ponieważ pomimo, iż mamy gotowe pliki dla kontrolera i widoku, to taki kontroler nie został dodany w konfiguracji modułu. Musimy więc tego dokonać.
Otwórzmy więc plik z konfiguracją:
[code]/module/application/config/module.config.php[/code]
i w sekcji:
[code]
'controllers' => array(
'invokables' => array(
'Application\Controller\Index' => 'Application\Controller\IndexController'
),
),[/code]
dodajmy nasz nowy kontroler:
[code]
'controllers' => array(
'invokables' => array(
'Application\Controller\Index' => 'Application\Controller\IndexController',
'Application\Controller\Users' => 'Application\Controller\UsersController'
),
),[/code]
Zapiszmy plik z konfiguracją i sprawdźmy teraz:
[code]http://zend.localhost/application/users[/code]
Bingo! Nasz kontroler działa.
Sprawdźmy jeszcze akcję dla wyświetlania profilu:
[code]http://zend.localhost/application/users/profile[/code]
I znowu bingo! Nasza druga akcja również się wyświetliła.
Podsumowanie
Na chwilę obecną umiemy więc już dodać swój własny kontroler i akcję i myślę, że to powinno wystarczyć tytułem wprowadzenia. W kolejnych artykułach będziemy działać dalej.Mam nadzieję, że wszystko opisałem tutaj jasno i zrozumiale. Tak na marginesie - jak chyba widać Zend jest bardzo intuicyjny do opanowania i o wiele łatwiejszy w użyciu, niż np. również opisywany na tej stronie framework Symfony. Stąd też taka mała sugestia dla początkujących - jeśli dopiero zaczynamy przygodę z frameworkami, to najlepiej zacząć ją właśnie od Zenda, niż brać się od razu za wielkie i skomplikowane Symfony.
I to tyle na teraz, do następnego!
Mysle ze kazdy zrozumie tak opisaną instrukcje
OdpowiedzUsuń___________________________
https://www.aptusshop.pl/sklepy-internetowe-szczecin.php