Zend_Controller_Action ist eine abstrakte Klasse die verwendet werden kann um Aktion Controller zu implementieren die mit dem Front Controller verwendet werden können um eine WebSeite zu erstellen die auf dem Model-View-Controller (MVC) Pattern basiert.

Um Zend_Controller_Action zu verwenden, muß von dieser in der eigenen aktuellen Aktions Controller Klasse ererbt werden (oder von dieser erben um eine eigene Basisklasse für Aktion Controller zu erstellen). Die grundsätzlichste Operation ist es von Ihr zu erben und Aktions Methoden zu erstellen die den verschiedenen Aktionen entsprechen die der Controller der eigenen Seite handhaben soll. Das Handhaben von Routen und Dispatchen des Zend_Controller's wird automatisch jegliche Methode die in der eigenen Klasse auf 'Action' endet, als potentielle Controller Aktion herausfinden.

Soll unsere Klasse, zum Beispiel, wie folgt definiert sein:

class FooController extends Zend_Controller_Action
{
    public function barAction()
    {
        // mach irgendwas
    }

    public function bazAction()
    {
        // mach irgendwas
    }
}

Die obige FooController Klasse (Controller foo)´definiert zwei Aktionen, bar und baz.

Da gibt es viel mehr das damit getan werden kann als das, wie eigene Initialisierungs Aktionen, Standardaktionen die aufgerufen werden wenn keine Aktion (oder eine ungültige Aktion) spezifiziert wird, pre- und post Dispatch Hooks, und eine Vielzahl von Helfer Methoden. Dieses Kapitel arbeitet als eine Übersicht der Aktion Controller Funktionalitäten.

class FooController extends Zend_Controller_Action
{
    public function init()
    {
        // Lokal nur bei diesem Controller; beeinflußt alle Aktionen die mit
        // init geladen wurden:
        $this->_helper->viewRenderer->setNoRender(true);

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

        // Auch global, muß aber in Verbindung mit der Lokalen Version sein um
        // für diesen Controller zu gelten:
        Zend_Controller_Front::getInstance()
            ->setParam('noViewRenderer', true);
    }
}

class FooController extends Zend_Controller_Action
{
    public function barAction()
    {
        // Nur für diese Aktion das automatische Rendern ausschalten:
        $this->_helper->viewRenderer->setNoRender();
    }
}

Wärend man immer den Konstruktor des Aktion Controller's überschreiben kann ist das nicht notwendig. Zend_Controller_Action::__construct() führt einige wichtige Aufgabe aus, wie das registrieren der Anfrage und Antwort Objekte, sowie alle eigene einleitenden Argumente die von Front Controller übergeben wurden. Wenn der Konstruktor überschrieben werden muß, muß sichergestellt sein das parent::__construct($request, $response, $invokeArgs) aufgerufen wird.

Der bessere Weg als die Instanzierung zu ändern ist die Verwendung der init() Methode, welche nach der letzten Aufgabe von __construct() aufgerufen wird. Zum Beispiel wenn man sich zu einer Datenbank bei der Instanzierung verbinden will:

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'
        ));
    }
}

Zend_Controller_Action spezifiziert zwei Methoden die aufgerufen werden können um eine angefragte Aktion fertigzustellen, preDispatch() und postDispatch(). Diese können auf viele Wege nützlich sein: zum Beispiel um Authentifizierungen und ACL's prüfen bevor eine Aktion ausgeführt wird (durch Aufruf von _forward() in preDispatch() wird die Aktion übersprungen), oder erzeugte Inhalte in einem seitenweiten Template zu plazieren (postDispatch()).

Eine Anzahl von Objekten und Variablen werden im Objekt registriert, und jede hat Zugriffsmethoden.

Zend_Controller_Action bietet einen rudimentären und flexiblen Mechanismus für View Integration. Zwei Methoden machen das möglich, initView() und render(); die erste Methode lädt die öffentliche Eigenschaft $view träge, und die zweite rendert eine View basierend auf der aktuell angefragen Aktion, wobei die Verzeichnis Hirarchie verwendet wird um den Pfad des Skripts zu ermitteln.

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()
    {
        // Rendert my/foo.phtml
        $this->render();

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

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

        // Rendert my/login.phtml in das 'form' Segment des Antwort Objektes
        $this->render('login', 'form');

        // Rendert site.phtml in das 'page' Segmetn des Antwort Objektes;
        // verwendet nicht das 'my/' Unterverzeichnis
        $this->render('site', 'page', true);
    }

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

Neben den Zugriffs- und View Integrationsmethoden, hat Zend_Controller_Action verschiedene nützliche Methoden für die Durchführung üblicher Aufgaben von innerhalb der Aktionsmethoden (oder vom Pre- und Post-Dispatch).

Vom Design her muß Zend_Controller_Action erweitert werden um einen Aktion Controller zu erstellen. Als Minimum, muß eine Aktions Methode definiert werden die der Controller aufrufen kann.

Neben dem erstellen von nützlichen Funktionalitäten für Web Anwendungen, wird auch die Notwendigkeit bestehen das vom gleichen Setup oder von den nützlichen Funktionen vieles in verschiedenen Controllern wiederholt wird; wenn dem so ist, löst die Erstellung einer gemeinsamen Basis Controller Klasse die Zend_Controller_Action erweitert zu einer Lösung dieser Redundanz.

class MyController extends Zend_Controller_Action
{
    public function __call($method, $args)
    {
        if ('Action' == substr($method, -6)) {
            // Wenn die Aktionsmethode nicht gefunden wurde,
            // das error Template darstellen
            return $this->render('error');
        }

        // Alle anderen Methoden werfen eine Ausnahme
        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)) {
            // Wenn die Aktionsmethode nicht gefunden wurde,
            // leite zur Index Aktion weiter
            return $this->_forward('index');
        }

        // Alle anderen Methoden werden eine Ausnahme
        throw new Exception('Invalid method "'
                            . $method
                            . '" called',
                            500);
    }
}

Neben dem überschreiben von __call(), kann jede der Initialisierungs-, Utility-, Zugriffs-, View- und Dispatch-Hook Methoden die vorher in diesem Kapitel beschrieben wurden, überschrieben werden um eigene Controller anzupassen. Wenn man, als Beispiel, die View Objekte in der Registry speichert, kann es gewünscht sein die initView() Methode mit Code zu Ändern der das folgende zusammensetzt:

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;
    }
}

Hoffentlich kann man anhand der Informationen in diesem Kapitel ersehen wie flexibel diese spezielle Komponente ist und wie Sie in eigene Anwendungen oder den Notwendigkeiten von Seiten damit erfüllt werden kann.