[PHP][Zend2] Instalacja i podstawy frameworka Zend2

Zend to jeden z najpopularniejszych i najprzyjemniejszych w użyciu frameworków do PHP. Jest bardzo rozbudowanym środowiskiem, a mimo tego jego nauka nie stwarza większych problemów (jak to czasem może mieć miejsce w przypadku Symfony). Posiada bardzo obszerną dokumentację oraz niesamowicie rozbudowaną społeczność swoich użytkowników, jest więc prawie pewne, że napotykając na dany problem zawsze znajdziemy jakieś rozwiązanie, czy wskazówkę.

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:

$ cd C:/www/
 
$ git clone git://github.com/zendframework/ZendSkeletonApplication.git zend

2) albo jako archiwum zip: https://github.com/zendframework/ZendSkeletonApplication/archive/master.zip

W drugim przypadku rozpakujmy sobie pliki, np. do folderu:

C:/www/zend

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:

$ composer install

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:

/public

w katalogu z Zendem, czyli w naszym przykładzie:

c:/www/zend/public

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.:

zend.localhost

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:

http://zend.localhost/

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:

public function indexAction()
 
{
 
    return new ViewModel();
 
}

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:

http://nasza_aplikacja.com/moduł/kontroler/akcja

Przykładowo:

http://zend.localhost/application/index/index

zwróci nam akcję index z kontrolera index z modułu application.
Identyczne działanie będzie mieć wpisanie adresu:

http://zend.localhost/application/index

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:

http://zend.localhost/application

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:

/module/application/config/module.config.php

Otwórzmy sobie ten plik.
Jak widzimy główna konfiguracja modułu składa się z tablicy:

array(
 
"router" => opcje,
 
"service_manager" => opcje,
 
"translator" => opcje,
 
"controllers" => opcje,
 
"view_manager" => opcje,
 
"console" => opcje
 
)

Poszczególne sekcje konfiguracji omówimy sobie w kolejnych artykułach.

Zobaczmy teraz jak wygląda plik z definicją kontrolera:

/module/Application/src/Application/Controller/IndexController.php

<?php
 
namespace Application\Controller;
 
 
 
use Zend\Mvc\Controller\AbstractActionController;
 
use Zend\View\Model\ViewModel;
 
 
 
class IndexController extends AbstractActionController
 
{
 
    public function indexAction()
 
    {
 
        return new ViewModel();
 
    }
 
}

Tworzymy własną akcję

Dodajmy do kontrolera Index nową akcję, np. o nazwie hello:

<?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();
 
    }   
 
}

Zapiszmy plik i zobaczmy co się stanie po wejściu w adres:

http://zend.localhost/application/index/hello

Jak widać otrzymamy błąd i załadowany zostanie widok określony w pliku:

/module/application/config/module.config.php

w sekcji:

 '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',
 
        ),

Warstwa widoku

Aby przejść dalej opowiedzmy sobie o widokach.
Pliki naszego widoku przechowywane są w formie plików:

.phtml

w katalogu:

/module/Application/view/

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:

<?php echo $this->content; ?>

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:

/module/Application/view/application/index/hello.phtml

i wpiszmy w nim jako zawartość:

<h1>Hello World!</h1>

Nastepnie ponownie spróbujmy wywołać akcję hello:

http://zend.localhost/application/index/hello

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:

/module/Application/src/Application/Controller/UsersController.php

o treści:

<?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();
 
    }   
 
  
 
}

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:

/module/Application/view/application/users/

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:

<h1>Hello World!</h1>
 
<h2>index - lista userów</h2>

2) /module/Application/view/application/users/profile.phtml o treści:

<h1>Hello World!</h1>
 
<h2>profile - profil usera</h2>

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:

http://zend.localhost/application/users

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ą:

/module/application/config/module.config.php

i w sekcji:

'controllers' => array(
 
        'invokables' => array(
 
            'Application\Controller\Index' => 'Application\Controller\IndexController'         
 
        ),
 
    ),

dodajmy nasz nowy kontroler:

'controllers' => array(
 
        'invokables' => array(
 
            'Application\Controller\Index' => 'Application\Controller\IndexController',
 
            'Application\Controller\Users' => 'Application\Controller\UsersController'           
 
        ),
 
    ),

Zapiszmy plik z konfiguracją i sprawdźmy teraz:

http://zend.localhost/application/users

Bingo! Nasz kontroler działa.
Sprawdźmy jeszcze akcję dla wyświetlania profilu:

http://zend.localhost/application/users/profile

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!