Fetching Zend Framework URL parameters

Question

I'm building my first Zend Framework application and I want to find out the best way to fetch user parameters from the URL.

I have some controllers which have index, add, edit and delete action methods. The index action can take a page parameter and the edit and delete actions can take an id parameter.

Examples
    http://example.com/somecontroller/index/page/1
    http://example.com/someController/edit/id/1
    http://example.com/otherController/delete/id/1

Until now I fetched these parameters in the action methods as so:

class somecontroller extends Zend_Controller_Action
{
    public function indexAction()
    {
        $page = $this->getRequest->getParam('page');
    }
}

However, a colleague told me of a more elegant solution using Zend_Controller_Router_Rewrite as follows:

$router = Zend_Controller_Front::getInstance()->getRouter();

$route = new Zend_Controller_Router_Route(
                        'somecontroller/index/:page',
                        array(
                            'controller' => 'somecontroller',
                            'action'    => 'index'
                        ),
                        array(
                            'page' => '\d+'
                        )
);

$router->addRoute($route);

This would mean that for every controller I would need to add at least three routes:

• one for the "index" action with a :page parameter
• one for the "edit" action with an :id parameter
• one for the "delete" action with an :id parameter

See the code below as an example. These are the routes for only 3 basic action methods of one controller, imagine having 10 or more controllers... I can't imagine this to be the best solution. The only benefit that i see is that the parameter keys are named and can therefore be omitted from the URL (somecontroller/index/page/1 becomes somecontroller/index/1)

// Route for somecontroller::indexAction()
$route = new Zend_Controller_Router_Route(
                        'somecontroller/index/:page',
                        array(
                            'controller' => 'somecontroller',
                            'action'     => 'index'
                        ),
                        array(
                            'page' => '\d+'
                        )
);

$router->addRoute($route);

// Route for somecontroller::editAction()
$route = new Zend_Controller_Router_Route(
                        'somecontroller/edit/:id',
                        array(
                            'controller' => 'somecontroller',
                            'action'     => 'edit'
                        ),
                        array(
                            'id' => '\d+'
                        )

$router->addRoute($route);

// Route for somecontroller::deleteAction()
$route = new Zend_Controller_Router_Route(
                        'somecontroller/delete/:id',
                        array(
                            'controller' => 'somecontroller',
                            'action'     => 'delete'
                        ),
                        array(
                            'id' => '\d+'
                        )

$router->addRoute($route);

Answer 1

I tend to look at it this way:

1. Determine processing requirements.

   What does each "action" need? An edit action and a delete action probably require an :id param. An add action and a list action probably do not. These controllers/actions then consume the params and do the processing.

   Note: You can write these comtrollers/actions without any reference to the urls that bring visitors there. The actions simply expect that their params will be delivered to them.

2. Decide (!) what url's you want.

   In general, I find the the (/:module/):controller/:action part of the url largely works fine (except for top-level relatively-static pages like /about, where I often put the actions on an IndexController (or a StaticController) and resent having to include the /index prefix in the url.

   So, to handle posts, you might want urls like:

   • /post - list all posts, probably with some paging
   • /post/:id - display a specific post
   • /post/:id/edit - edit a specific post
   • /post/:id/delete - delete a specific post
   • /post/add - add a post

   Alternatively, you might want:

   • /post/list - list all posts, probably with some paging
   • /post/display/:id - display a specific post
   • /post/edit/:id - edit a specific post
   • /post/delete/:id - delete a specific post
   • /post/add - add a post

   Or any other url scheme. The point is, you decide the url's you want to expose.

3. Create routes...

   ...that map those urls to controllers/actions. [And make sure that whenever you render them, you use the url() view-helper with the route-name, so that a routing change requires no changes to your downstream code in your actions or views.

Do you end up writing more routes this way? Yeah, I find that I do. But, for me, the benefit is that I get to decide on my urls. I'm not stuck with the Zend defaults.

But, as with most things, YMMV.

Answer 2

In a previous answer @janenz00 mentioned "long urls" as one of the reasons for using routes:

Long urls - If the parameter list for a particular action is very long, you might want to define a route so that you can omit the keys from the request and hence shorten the url.

Let's say we have an employee controller with an index action that shows a table of employees with some additional data (such as age, department...) for each employee. The index action can take the following parameters:

• a page parameter (required)
• a sortby parameter (optional) which takes one column name to sort by (eg age)
• a dept parameter (optional) which takes a name of a department and only shows the employees that are working in that department

We add the following route. Notice that when using this route, we cannot specify a dept parameter without specifying a sortby parameter first.

$route = new Zend_Controller_Router_Route(
                    'employee/index/:page/:sortby/:dept',
                    array(
                        'controller' => 'employee',
                        'action'    => 'index')
);

If we would fetch these parameters in our action methods instead, we could avoid this problem (because the parameter keys are specified in the url):

http://example.com/employee/index/page/1/dept/staff

I might be looking at it the wrong way (or might not see the full potential of routing), but to me the only two reasons for using routes are:

• If your urls don't conform to the traditional /module/controller/action pattern
• If you want to make your urls more SEO-friendly

If your sole reason for using routes is to make use of the named parameters, then I think it's better to fetch these parameters in your action methods because of two reasons:

• Keeping the number of routes at a minimum will reduce the amount of time and resources spent by the router
• Passing in the parameter keys in the url allows us to make use of more complex urls with optional parameters.

Any thoughts or advice on this topic are more than welcome!

Answer 3

It all depends on your exact requirements. If you simply want to pass one or two params, the first method will be the easiest. It is not practical to define route for every action. A few scenarios where you would want to define routes would be:

1. Long urls - If the parameter list for a particular action is very long, you might want to define a route so that you can omit the keys from the request and hence shorten the url.
2. Fancy urls - If you want to deviate from the normal controller/action url pattern of the Zend Framework, and define a different url pattern for your application (eg, ends with ".html")
3. Slugs / SEO friendly URLs

To take the example of a blog, you might want to define routes for blog posts urls so that the url is SEO friendly. At the same time, you may want to retain the edit / delete / post comment etc urls to remain the ZF default and use $this->getRequest->getParam() to access the request parameters in that context.

To sum up, an elegant solution will be a combination of routes and the default url patterns.