The API of the MVC components has changed over time. If you started using Zend Framework in an early version, follow the guidelines below to migrate your scripts to use the new architecture.
The principal changes introduced in 1.0.0RC1 are the introduction of and default enabling of the ErrorHandler plugin and the ViewRenderer action helper. Please read the documentation to each thoroughly to see how they work and what effect they may have on your applications.
The ErrorHandler plugin runs during
postDispatch() checking for exceptions, and forwarding
to a specified error handler controller. You should include such a
controller in your application. You may disable it by setting the
front controller parameter noErrorHandler:
<?php
$front->setParam('noErrorHandler', true);
The ViewRenderer action helper automates view injection
into action controllers as well as autorendering of view scripts
based on the current action. The primary issue you may encounter is
if you have actions that do not render view scripts and neither
forward or redirect, as the ViewRenderer will attempt
to render a view script based on the action name.
There are several strategies you can take to update your code. In
the short term, you can globally disable the
ViewRenderer in your front controller bootstrap prior
to dispatching:
<?php
// Assuming $front is an instance of Zend_Controller_Front
$front->setParam('noViewRenderer', true);
However, this is not a good long term strategy, as it means most likely you'll be writing more code.
When you're ready to start using the ViewRenderer functionality, there are several things to look for in your controller code. First, look at your action methods (the methods ending in 'Action'), and determine what each is doing. If none of the following is happening, you'll need to make changes:
Calls to $this->render()
Calls to $this->_forward()
Calls to $this->_redirect()
Calls to the Redirector action helper
The easiest change is to disable auto rendering for that method:
$this->_helper->viewRenderer->setNoRender();
If you find that none of your action methods are rendering,
forwarding, or redirecting, you will likely want to put the above
line in your preDispatch() or init()
methods:
public function preDispatch()
{
// disable view script autorendering
$this->_helper->viewRenderer->setNoRender()
// .. do other things...
}
If you are calling render(), and you're using the Conventional Modular
directory structure, you'll want to change your code to
make use of autorendering:
If you're rendering multiple view scripts in a single action, you don't need to change a thing.
If you're simply calling render() with no
arguments, you can remove such lines.
If you're calling render() with arguments, and
not doing any processing afterwards or rendering multiple
view scripts, you can change these calls to read
$this->_helper->viewRenderer().
If you're not using the conventional modular directory structure,
there are a variety of methods for setting the view base path and
script path specifications so that you can make use of the
ViewRenderer. Please read the ViewRenderer
documentation for information on these methods.
If you're using a view object from the registry, or customizing your
view object, or using a different view implementation, you'll want
to inject the ViewRenderer with this object. This can
be done easily at any time.
Prior to first instantiating a front controller instance:
<?php // Assuming $view has already been defined $viewRenderer = new Zend_Controller_Action_Helper_ViewRenderer($view); Zend_Controller_Action_HelperBroker::addHelper($viewRenderer);
After retrieving a front controller instance:
<?php
$viewRenderer = Zend_Controller_Action_HelperBroker::getExistingHelper('viewRenderer');
$viewRenderer->setView($view);
There are many ways to modify the ViewRenderer, including setting a different view script to render, specifying replacements for all replaceable elements of a view script path (including the suffix), choosing a response named segment to utilize, and more. If you aren't using the conventional modular directory structure, you can even associate different path specifications with the ViewRenderer.
We encourage you to adapt your code to use the
ErrorHandler and ViewRenderer as they are
now core functionality.
0.9.3 introduces action helpers. As part of this change, the following methods have been removed as they are now encapsulated in the redirector action helper:
setRedirectCode(); use
Zend_Controller_Action_Helper_Redirector::setCode().
setRedirectPrependBase(); use
Zend_Controller_Action_Helper_Redirector::setPrependBase().
setRedirectExit(); use
Zend_Controller_Action_Helper_Redirector::setExit().
Read the action helpers documentation for more information on how to retrieve and manipulate helper objects, and the redirector helper documentation for more information on setting redirect options (as well as alternate methods for redirecting).
Per previous changes, the most basic usage of the MVC components remains the same:
require_once 'Zend/Controller/Front.php';
Zend_Controller_Front::run('/path/to/controllers');
However, the directory structure underwent an overhaul, several components were removed, and several others either renamed or added. Changes include:
Zend_Controller_Router was removed in favor of
the rewrite router.
Zend_Controller_RewriteRouter was renamed to
Zend_Controller_Router_Rewrite, and promoted to
the standard router shipped with the framework;
Zend_Controller_Front will use it by default if
no other router is supplied.
A new route class for use with the rewrite router was
introduced,
Zend_Controller_Router_Route_Module; it covers
the default route used by the MVC, and has support for controller
modules.
Zend_Controller_Router_StaticRoute was renamed
to Zend_Controller_Router_Route_Static.
Zend_Controller_Dispatcher was renamed
Zend_Controller_Dispatcher_Standard.
Zend_Controller_Action::_forward()'s arguments
have changed. The signature is now:
final protected function _forward($action, $controller = null, $module = null, array $params = null);
$action is always required; if no controller is
specified, an action in the current controller is assumed.
$module is always ignored unless
$controller is specified. Finally, any
$params provided will be appended to the
request object. If you do not require the controller or
module, but still need to pass parameters, simply specify
null for those values.
The most basic usage of the MVC components has not changed; you can still do each of the following:
require_once 'Zend/Controller/Front.php';
Zend_Controller_Front::run('/path/to/controllers');
/* -- create a router -- */
$router = new Zend_Controller_RewriteRouter();
$router->addRoute('user', 'user/:username', array('controller' => 'user',
'action' => 'info'));
/* -- set it in a controller -- */
$ctrl = Zend_Controller_Front::getInstance();
$ctrl->setRouter($router);
/* -- set controller directory and dispatch -- */
$ctrl->setControllerDirectory('/path/to/controllers');
$ctrl->dispatch();
We encourage use of the Response object to aggregate content and
headers. This will allow for more flexible output format switching
(for instance, JSON or XML instead of XHTML) in your applications.
By default, dispatch() will render the response, sending both
headers and rendering any content. You may also have the front
controller return the response using returnResponse(),
and then render the response using your own logic. A future version
of the front controller may enforce use of the response object via
output buffering.
There are many additional features that extend the existing API, and these are noted in the documentation.
The main changes you will need to be aware of will be found when subclassing the various components. Key amongst these are:
Zend_Controller_Front::dispatch() by default
traps exceptions in the response object, and does not render
them, in order to prevent sensitive system information from
being rendered. You can override this in several ways:
Set throwExceptions() in the front
controller:
$front->throwExceptions(true);
Set renderExceptions() in the response
object:
$response->renderExceptions(true); $front->setResponse($response); $front->dispatch(); // or: $front->returnResponse(true); $response = $front->dispatch(); $response->renderExceptions(true); echo $response;
Zend_Controller_Dispatcher_Interface::dispatch()
now accepts and returns a Section 7.4, “The Request Object”
object instead of a dispatcher token.
Zend_Controller_Router_Interface::route()
now accepts and returns a Section 7.4, “The Request Object”
object instead of a dispatcher token.
Zend_Controller_Action changes include:
The constructor now accepts exactly three arguments,
Zend_Controller_Request_Abstract $request,
Zend_Controller_Response_Abstract $response,
and array $params (optional).
Zend_Controller_Action::__construct() uses
these to set the request, response, and invokeArgs
properties of the object, and if overriding the
constructor, you should do so as well. Better yet, use
the init() method to do any instance
configuration, as this method is called as the final
action of the constructor.
run() is no longer defined as final, but is
also no longer used by the front controller; it's sole
purpose is for using the class as a page controller. It
now takes two optional arguments, a
Zend_Controller_Request_Abstract $request
and a Zend_Controller_Response_Abstract $response.
indexAction() no longer needs to be
defined, but is encouraged as the default action. This
allows using the RewriteRouter and action controllers to
specify different default action methods.
__call() should be overridden to handle any
undefined actions automatically.
_redirect() now takes an optional second
argument, the HTTP code to return with the redirect, and
an optional third argument, $prependBase,
that can indicate that the base URL registered with the
request object should be prepended to the url specified.
The _action property is no longer set.
This property was a Zend_Controller_Dispatcher_Token,
which no longer exists in the current incarnation.
The sole purpose of the token was to provide
information about the requested controller, action,
and URL parameters. This information is now
available in the request object, and can be accessed
as follows:
// Retrieve the requested controller name
// Access used to be via: $this->_action->getControllerName().
// The example below uses getRequest(), though you may also directly access the
// $_request property; using getRequest() is recommended as a parent class may
// override access to the request object.
$controller = $this->getRequest()->getControllerName();
// Retrieve the requested action name
// Access used to be via: $this->_action->getActionName().
$action = $this->getRequest()->getActionName();
// Retrieve the request parameters
// This hasn't changed; the _getParams() and _getParam() methods simply proxy to
// the request object now.
$params = $this->_getParams();
$foo = $this->_getParam('foo', 'default'); // request 'foo' parameter, using
// 'default' as default value if not found
noRouteAction() has been removed. The
appropriate way to handle non-existent action
methods should you wish to route them to a default
action is using __call():
public function __call($method, $args)
{
// If an unmatched 'Action' method was requested, pass on to the default
// action method:
if ('Action' == substr($method, -6)) {
return $this->defaultAction();
}
throw new Zend_Controller_Exception('Invalid method called');
}
Zend_Controller_RewriteRouter::setRewriteBase() has
been removed. Use Zend_Controller_Front::setBaseUrl()
instead (or Zend_Controller_Request_Http::setBaseUrl(), if using
that request class).
Zend_Controller_Plugin_Interface was replaced
by Zend_Controller_Plugin_Abstract. All methods now
accept and return a Section 7.4, “The Request Object”
object instead of a dispatcher token.