Zend_Controller_Action jest klasą abstrakcyjną, której możesz użyć do implementacji kontrolerów akcji, których wraz z kontrolerem frontowym użyjesz do budowania aplikacji opartej na wzorcu Model-View-Controller (MVC).

Aby użyć klasy Zend_Controller_Action, powinieneś ją rozszerzyć w swoich klasach kontrolerów akcji (lub rozszerzyć ją aby utworzyć swoją własną bazową klasę dla kontrolerów akcji). Najbardziej podstawową operacją jest rozszerzenie tej klasy oraz utworzenie metod akcji, które odpowiadają różnym akcjom jakie ma obsługiwać kontroler na twojej stronie. Obsługa routingu i uruchamiania w Zend_Controller automatycznie przeszuka wszystkie metody twojej klasy, których nazwa zakończona jest wyrazem 'Action', aby znaleźć odpowiednią akcję kontrolera.

Na przykład, załóżmy, że twoja klasa jest zdefiniowana w ten sposób:

class FooController extends Zend_Controller_Action
{
    public function barAction()
    {
        // zrób coś
    }

    public function bazAction()
    {
        // zrób coś
    }
}

        

Powyższa klasa FooController (kontroler foo) definiuje dwie akcje, bar oraz baz.

Można tu osiągnąć dużo więcej, na przykład: utworzyć własne akcje inicjalizacyjne, utworzyć domyślne akcje do wywołania gdy nie ma określonej akcji (lub określona jest nieprawidłowa), użyć metod pre- oraz post-dispatch oraz użyć wielu różnych metod pomocników. Ten rozdział jest rozeznaniem w funkcjonalnościach kontrolera akcji.

class FooController extends Zend_Controller_Action
{
    public function init()
    {
        // Lokalnie, tylko dla tego kontrolera; affects all actions, as loaded in init:
        $this->_helper->viewRenderer->setNoRender(true);

        // Globalnie:
        $this->_helper->removeHelper('viewRenderer');

        // Także globalnie, but would need to be in conjunction with the local
        // version in order to propagate for this controller:
        Zend_Controller_Front::getInstance()->setParam('noViewRenderer', true);
    }
}

            

class FooController extends Zend_Controller_Action
{
    public function barAction()
    {
        // wyłączamy automatyczne renderowanie tylko dla tej akcji:
        $this->_helper->viewRenderer->setNoRender();
    }
}

            

O ile zawsze możesz nadpisać konstruktor kontrolera akcji, nie zalecamy tego. Zend_Controller_Action::__construct() przeprowadza kilka ważnych zadań, takich jak zarejestrowanie obiektów żądania i odpowiedzi, oraz przekazanie argumentów wywołania przez kontroler frontowy. Jeśli musisz nadpisać konstruktor, upewnij się że wywołasz metodę parent::__construct($request, $response, $invokeArgs).

Bardziej odpowiednim sposobem skonfigurowania instancji jest użycie metody init(), która jest wywoływana jako ostatnie zadanie konstruktora __construct(). Na przykład jeśli chcesz połączyć się z bazą danych:

class FooController extends Zend_Controller_Action
{
    public function init()
    {
        $this->db = Zend_Db::factory('Pdo_Mysql', array(
            'host'     => 'myhost',
            'username' => 'user',
            'password' => 'XXXXXXX',
            'dbname'   => 'website'
        ));
    }
}

        

Klasa Zend_Controller_Action definiuje dwie metody, preDispatch() oraz postDispatch(), które mogą być wywołane przed i po wywołaniu akcji. Mogą one być użyteczne w wielu sytuacjach: weryfikowanie autentykacji oraz kontroli dostępu ACL odnośnie uruchamianej akcji, (przez wywołanie metody _forward() w metodzie preDispatch(), dzięki czemu akcja może być pominięta), lub na przykład umieszczenie wygenerowanej zawartości w głównym szablonie (postDispatch()).

W obiekcie zarejestrowanych jest wiele obiektów oraz zmiennych i wszystkie mają metody dostępowe..

Zend_Controller_Action provides a rudimentary and flexible mechanism for view integration. Odpowiadają za to dwie metody, initView() oraz render(); the former method lazy-loads the $view public property, and the latter renders a view based on the current requested action, using the directory hierarchy to determine the script path.

applicationOrModule/
    controllers/
        IndexController.php
    views/
        scripts/
            index/
                index.phtml
        helpers/
        filters/

            

string render(string $action = null, string $name = null, bool $noController = false);

            

class MyController extends Zend_Controller_Action
{
    public function fooAction()
    {
        // Renderuje my/foo.phtml
        $this->render();

        // Renderuje my/bar.phtml
        $this->render('bar');

        // Renderuje baz.phtml
        $this->render('baz', null, true);

        // Renderuje my/login.phtml w segmencie 'form' obiektu odpowiedzi
        $this->render('login', 'form');

        // Renderuje site.phtml w segmencie 'page' obiektu odpowiedzi;
        // nie używa podkatalogu 'my/'
        $this->render('site', 'page', true);
    }

    public function bazBatAction()
    {
        // Renderuje my/baz-bat.phtml
        $this->render();
    }
}

            

Oprócz metod dostępowych i metod integracji z widokiem, klasa Zend_Controller_Action posiada kilka metod narzędziowych używanych do przeprowadzania ważnych zadań wewnątrz twoich metod akcji (lub wewnątrz metod pre-/post-dispatch).

By design, Zend_Controller_Action must be subclassed in order to create an action controller. At the minimum, you will need to define action methods that the controller may call.

Besides creating useful functionality for your web applications, you may also find that you're repeating much of the same setup or utility methods in your various controllers; if so, creating a common base controller class that extends Zend_Controller_Action could solve such redundancy.

class MyController extends Zend_Controller_Action
{
    public function __call($method, $args)
    {
        if ('Action' == substr($method, -6)) {
            // Jeśli metoda akcji nie została znaleziona, renderuje szablon informujący o błędzie
            return $this->render('error');
        }

        // wszystkie inne metody wyrzucają wyjątek
        throw new Exception('Invalid method "' . $method . '" called', 500);
    }
}

            

class MyController extends Zend_Controller_Action
{
    public function indexAction()
    {
        $this->render();
    }

    public function __call($method, $args)
    {
        if ('Action' == substr($method, -6)) {
            // Jeśli metoda akcji nie została znaleziona, przenieś do akcji index
            return $this->_forward('index');
        }

        // wszystkie inne metody wyrzucają wyjątek
        throw new Exception('Invalid method "' . $method . '" called', 500);
    }
}

            

Besides overriding __call(), each of the initialization, utility, accessor, view, and dispatch hook methods mentioned previously in this chapter may be overridden in order to customize your controllers. As an example, if you are storing your view object in a registry, you may want to modify your initView() method with code resembling the following:

abstract class My_Base_Controller extends Zend_Controller_Action
{
    public function initView()
    {
        if (null === $this->view) {
            if (Zend_Registry::isRegistered('view')) {
                $this->view = Zend_Registry::get('view');
            } else {
                $this->view = new Zend_View();
                $this->view->setBasePath(dirname(__FILE__) . '/../views');
            }
        }

        return $this->view;
    }
}

        

Hopefully, from the information in this chapter, you can see the flexibility of this particular component and how you can shape it to your application's or site's needs.