Das Response-Objekt ist das logische Gegenstück zum Request-Objekt. Sein Zweck ist es, Inhalte und/oder Header zu vereinigen, um sie in einem Rutsch zu versenden. Zusätzlich übergibt der FrontController alle aufgefangenen Ausnahmen an das Response-Objekt, um dem Entwickler das Verarbeiten von Ausnahmen zu ermöglichen. Diese Funktionalität kann durch Setzen von Zend_Controller_Front::throwExceptions(true) überschrieben werden.

$front->throwExceptions(true);

Um die Ausgabe der Anwort inklusive der gesetzten Header zu senden, verwendet man sendResponse():

$response->sendResponse();

$front->returnResponse(true);
$response = $front->dispatch();

// ein bisschen mehr verarbeiten, wie z.B. loggen...
// und dann die Ausgabe senden:
$response->sendResponse();

Entwickler sollten das Response-Objekt in ihren Aktions-Controllern verwenden. Statt die Ausgabe direkt zu machen und Header zu versenden, sollten diese an das Response-Objekt übergeben werden:

// Innerhalb einer Controller Aktion:
// Setze einen Header
$this->getResponse()
    ->setHeader('Content-Type', 'text/html')
    ->appendBody($content);

Dadurch werden alle Header in einem Rutsch versendet, genau vor der Anzeige des Inhalts.

Sollte in der Anwendung eine Ausnahme auftreten, überprüft man den Schalter isException() des Response-Objekts und erhält die Ausnahme durch Verwendung von getException(). Zusätzlich kann man ein eigenes Response-Objekt erstellen, das zu einer Fehlerseite umleitet, die Nachricht der Ausnahme loggt, die Nachricht der Ausnahme schön formatiert ausgibt (für Entwicklungsumgebungen), usw.

Man kann das Response-Objekt im Anschluss an die Methode dispatch() des FrontControllers erhalten oder den FrontController auffordern, das Response-Objekt zurückzugeben statt den Inhalt auszugeben.

// Erhalten nach dem Dispatch:
$front->dispatch();
$response = $front->getResponse();
if ($response->isException()) {
    // log, mail, etc...
}

// Oder den FrontController-Dispatch-Prozess auffordern, es zurück zu geben
$front->returnResponse(true);
$response = $front->dispatch();

// mach irgend was...

// gib zum Schluß die Antwort aus
$response->sendResponse();

Standardmäßig werden Ausnahmenachrichten nicht ausgegeben. Dieses Verhalten kann durch den Aufruf von renderException() überschrieben werden oder indem der FrontController aufgefordert wird, die Exceptions durch throwExceptions() auszuwerfen, wie oben gezeigt:

$response->renderExceptions(true);
$front->dispatch($request, $response);

// oder:
$front->returnResponse(true);
$response = $front->dispatch();
$response->renderExceptions();
$response->sendResponse();

// oder:
$front->throwExceptions(true);
$front->dispatch();

Wie vorher besprochen, ist einer der Aspekte der Aufgaben des Response-Objekts das Sammeln und Abschicken der HTTP-Antwort-Header. Eine Vielzahl von Methoden existieren hierfür:

Zusätzlich zu den obigen Methoden, gibt es Zugriffsmethoden für das Setzen und Empfangen der HTTP-Antwort-Codes für die aktuellen Anfrage, setHttpResponseCode() und getHttpResponseCode().

Das Response-Objekt unterstützt "benannte Segmente". Das erlaubt es den Inhalt des Bodys in verschiedene Segmente zu isolieren und diese Segmente zu reihen, damit die Ausgabe in einer spezifizierten Reihenfolge zurückgegeben wird. Intern wird der Inhalt der Bodys in einem Array gespeichert und die verschiedenen Zugriffsmethoden können verwendet werden, um die Platzierung und Benennung innerhalb des Arrays zu indizieren.

Als Beispiel könnte ein preDispatch() Hook verwendet werden, um dem Response-Objekt einen Header hinzuzufügen, dann den Aktionscontroller einen Inhalt des Bodys hinzufügen zu lassen und einen postDispatch() Hook einen Footer hinzufügen zu lassen:

// Angenommen diese Plugin Klasse ist im Front Controller registriert
class MyPlugin extends Zend_Controller_Plugin_Abstract
{
    public function preDispatch(Zend_Controller_Request_Abstract $request)
    {
        $response = $this->getResponse();
        $view = new Zend_View();
        $view->setBasePath('../views/scripts');

        $response->prepend('header', $view->render('header.phtml'));
    }

    public function postDispatch(Zend_Controller_Request_Abstract $request)
    {
        $response = $this->getResponse();
        $view = new Zend_View();
        $view->setBasePath('../views/scripts');

        $response->append('footer', $view->render('footer.phtml'));
    }
}

// Ein Beispiel Aktion Controller
class MyController extends Zend_Controller_Action
{
    public function fooAction()
    {
        $this->render();
    }
}

Im obigen Beispiel wird ein Aufruf zu /my/foo den endgültigen Inhalt des Bodys des Antwortobjekts mit der folgenden Struktur verursachen:

array(
    'header'  => ..., // Header Inhalt
    'default' => ..., // Body Inhalt von MyController::fooAction()
    'footer'  => ...  // Footer Inhalt
);

Wenn das gerendert wird, wird es in der Reihenfolge gerendert, in der die Elements im Array angeordnet sind.

Eine Vielzahl von Methoden kann verwendet werden, um die benannten Segmente zu manipulieren:

Wie vorher beschrieben werden Ausnahmen standardmäßig während des Dispatchens gefangen und im Response-Objekt registriert. Ausnahmen werden in einem Stack registriert, der es erlaubt alle geworfen Ausnahmen zu speichern -- Anwendungsausnahmen, Dispatch-Ausnahmen, Plugin-Ausnahmen, usw. Wenn man auf bestimmte Ausnahmen prüfen oder Ausnahmen loggen will, muß man die Ausnahme-API des Response-Objekts verwenden:

Der Zweck des Response-Objekts ist es, Header und Inhalte von den verschiedenen Aktionen und Plugins zu sammeln und diese an den Client zurückzugeben; zweitens sammelt es in der Reihenfolge ihres Auftretens alle Fehler (Ausnahmen) und gibt diese zurück oder versteckt sie vor dem Endbenutzer.

Die Basis-Antwortklasse ist Zend_Controller_Response_Abstract, und jede erbende Klasse, die erstellt wird, sollte von dieser Klasse oder eine ihrer Derivate erben. Die verschiedenen vorhandenen Methoden wurden im vorhergehenden Abschnitt aufgezählt.

Die Gründe eine Subklasse des Response-Objekts zu erstellen beinhalten das Ändern wie eine Ausgabe zurückgegeben wird, basierend auf der Antwortumgebung (z.B., keine Header senden für CLI oder PHP-GTK-Anfragen), zusätzliche Funktionalitäten um eine endgültige Ansicht zurückzugeben, basierend auf Inhalt, der in benannten Segmenten gespeichert wurde, usw.