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.
As translated segments were introduced into the new standard route, the '@' character is now a special character in the beginning of a route segment. To be able to use it in a static segment, you must escape it by prefixing it with second '@' character. The same rule now applies for the ':' character.
Users brought to our attention the fact that
Zend_Controller_Action_Helper_ViewRenderer
were
using a method of the dispatcher abstract class that was not in
the dispatcher interface. We have now added the following method to
ensure that custom dispatchers will continue to work with the
shipped implementations:
formatModuleName()
: should be used to take a raw
controller name, such as one that would be packaged inside a request
object, and reformat it to a proper class name that a class extending
Zend_Controller_Action
would use
Users brought to our attention the fact that
Zend_Controller_Front
and
Zend_Controller_Router_Route_Module
were each
using methods of the dispatcher that were not in the dispatcher
interface. We have now added the following three methods to
ensure that custom dispatchers will continue to work with the
shipped implementations:
getDefaultModule()
: should return the name of
the default module.
getDefaultControllerName()
: should return the
name of the default controller.
getDefaultAction()
: should return the
name of the default action.
Though most basic functionality remains the same, and all documented functionality remains the same, there is one particular undocumented "feature" that has changed.
When writing URLs, the documented way to write camelCased action names is to use a word separator; these are '.' or '-' by default, but may be configured in the dispatcher. The dispatcher internally lowercases the action name, and uses these word separators to re-assemble the action method using camelCasing. However, because PHP functions are not case sensitive, you could still write URLs using camelCasing, and the dispatcher would resolve these to the same location. For example, 'camel-cased' would become 'camelCasedAction' by the dispatcher, whereas 'camelCased' would become 'camelcasedAction'; however, due to the case insensitivity of PHP, both will execute the same method.
This causes issues with the ViewRenderer when resolving view
scripts. The canonical, documented way is that all word separators
are converted to dashes, and the words lowercased. This creates
a semantic tie between the actions and view scripts, and the
normalization ensures that the scripts can be found. However, if the
action 'camelCased' is called and actually resolves, the word
separator is no longer present, and the ViewRenderer attempts to
resolve to a different location -- camelcased.phtml
instead of
camel-cased.phtml
.
Some developers relied on this "feature", which was never intended. Several changes in the 1.5.0 tree, however, made it so that the ViewRenderer no longer resolves these paths; the semantic tie is now enforced. First among these, the dispatcher now enforces case sensitivity in action names. What this means is that referring to your actions on the url using camelCasing will no longer resolve to the same method as using word separators (i.e., 'camel-casing'). This leads to the ViewRenderer now only honoring the word-separated actions when resolving view scripts.
If you find that you were relying on this "feature", you have several options:
Best option: rename your view scripts. Pros: forward compatibility. Cons: if you have many view scripts that relied on the former, unintended behavior, you will have a lot of renaming to do.
Second best option: The ViewRenderer now delegates view
script resolution to Zend_Filter_Inflector
; you
can modify the rules of the inflector to no longer separate
the words of an action with a dash:
$viewRenderer = Zend_Controller_Action_HelperBroker::getStaticHelper('viewRenderer'); $inflector = $viewRenderer->getInflector(); $inflector->setFilterRule(':action', array( new Zend_Filter_PregReplace( '#[^a-z0-9' . preg_quote(DIRECTORY_SEPARATOR, '#') . ']+#i', '' ), 'StringToLower' ));
The above code will modify the inflector to no longer separate the words with dash; you may also want to remove the 'StringToLower' filter if you do want the actual view script names camelCased as well.
If renaming your view scripts would be too tedious or time consuming, this is your best option until you can find the time to do so.
Least desirable option: You can force the dispatcher to dispatch camelCased action names with a new front controller flag, useCaseSensitiveActions:
$front->setParam('useCaseSensitiveActions', true);
This will allow you to use camelCasing on the url and still have it resolve to the same action as when you use word separators. However, this will mean that the original issues will cascade on through; you will likely need to use the second option above in addition to this for things to work at all reliably.
Note, also, that usage of this flag will raise a notice that this usage is deprecated.
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:
$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:
// 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 dispatching a front controller instance:
// Assuming $view has already been defined $viewRenderer = new Zend_Controller_Action_Helper_ViewRenderer($view); Zend_Controller_Action_HelperBroker::addHelper($viewRenderer);
Any time during the bootstrap process:
$viewRenderer = Zend_Controller_Action_HelperBroker::getStaticHelper('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:
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:
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 The
Request Object instead of a dispatcher token.
Zend_Controller_Router_Interface::route()
now accepts and returns a The
Request 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; its 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(); // request 'foo' parameter, using 'default' as default value if not found $foo = $this->_getParam('foo', 'default');
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 The Request
Object instead of a dispatcher token.