Migrating from Previous Versions
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.
Migrating from 1.7.x to 1.8.0 or newer
Standard Route Changes
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.
Migrating from 1.6.x to 1.7.0 or newer
Dispatcher Interface Changes
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
Migrating from 1.5.x to 1.6.0 or Newer
Dispatcher Interface Changes
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.
Migrating from 1.0.x to 1.5.0 or Newer
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.
Migrating from 0.9.3 to 1.0.0RC1 or Newer
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.
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.
Migrating from 0.9.2 to 0.9.3 or Newer
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).
Migrating from 0.6.0 to 0.8.0 or Newer
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,
$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.
Migrating from 0.2.0 or before to 0.6.0
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:
-
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.
|
|