Federico Cargnelutti

Part 1 – An Alternative to Zend_Controller: Introduction
Part 2 – An Alternative to Zend_Controller: The Router

Domain Layer

The domain layer is separated from the other layers and has no dependencies on Zf_Controller.

app/
domain/
    Model/
        User.php
        UserDao.php
lib/
    Zend/
    Zf/

Adding the domain directory to your include path allows you to load and access Model classes from anywhere within your project:

Bootstrap file

set_include_path(APPLICATION_PATH . '/../lib'
    . PATH_SEPARATOR . APPLICATION_PATH . '/../domain);

Index Controller

class IndexController extends Zf_Controller_Action
{
    public function indexAction()
    {
        // DAO pattern
        $dao = new Model_UserDao();
        ...
    }
}

The getInstance() method can be used to set or retrieve a singleton instance of a Model class:

class IndexController extends Zf_Controller_Action
{
    public function indexAction()
    {
        $dao = $this->getInstance('Model_UserDao');

        // or...
        $dao = new Model_UserDao();
        $this->setInstance($dao);

        $this->userAction();
    }

    public function userAction()
    {
        $dao = $this->getInstance('Model_UserDao');
        ...
    }
}

Below is an example of the UserDao class that contains methods to insert, update, and retrieve data:

class Model_UserDao extends Zf_Persistence_Db_Adapter
{
    public function find($id)
    {
        $db = $this->getAdapter();
        ...
    }
}

abstract class Zf_Persistence_Db_Adapter
{
    protected $_db = null;

    public function setAdapter(Zend_Db_Adapter_Abstract $db)
    {
        $this->_db = $db;
    }

    public function getAdapter()
    {
        if (null === $this->_db) {
            if (!Zend_Registry::isRegistered('Zend_Db')) {
                throw new Zf_Persistence_Exception('...');
            }
            $this->setAdapter(Zend_Registry::get('Zend_Db'));
        }

        return $this->_db;
    }
}

More Info

• Domain-Driven Design with Zend Framework
• Model Infrastructure

Part 1 – An Alternative to Zend_Controller: Introduction

Here’s the good news: Zf_Controller doesn’t have a Router. It uses a very simple mapping to determine the name of the controller and action. Optionally, you may define parameters in the URI, for example:

http://domain.com/controller/action/value1/value2

An example of how routes are matched:

URI: http://domain.com/news/tag/zend-framework

Controller

class NewsController extends Zf_Controller_Action
{
  public function tagAction()
  {
    print_r($this->_getAllParams());
  }
}

Outputs

Array
(
    [controller] => News
    [action] => tag
)

Variable Defaults

It is often helpful to be able to assign default values to parameters that aren’t passed, that way we don’t have to check if the parameter has been set or not. The $_params property is an array with keys representing variable names and default values.

URI: http://domain.com/news/tag/zend-framework

Controller

class NewsController extends Zf_Controller_Action
{
  protected $_params = array(
    'name' => null,
    'show' => 10
  );

  ...
}

Outputs

Array
(
    [controller] => News
    [action] => tag
    [name] => zend-framework
    [show] => 10
)

A parameter sent via the URI will always overwrite a default parameter. That’s the whole point of using default values.

Variable Requirements

The $_paramsMatch property is used to set variable requirements. These are defined as parts of a regular expression:

URI: http://domain.com/news/tag/zend-framework/50

Controller

class NewsController extends Zf_Controller_Action
{
  protected $_params = array(
    'name' => null,
    'show' => 10
  );

  protected $_paramsMatch = array('show' => '\d+');

  ...
}

In the example above, Zf_Controller will assign the value to the “show” variable only if the value is a number. If not, it will assign the default value, in this case “10″.

If you think that you need more flexibility than this, I suggest extending Zend_Controller_Action instead.

Part 3 – An Alternative to Zend_Controller: The Model

Zend Framework is very flexible and one of its strengths is that it allows developers to implement their own components. The Zend_Controller component, for example, is very powerful. Of course, it’s not my intention to replace it, but to offer an alternative that decreases the number of decisions a developer needs to make when developing an application.

Meet Zf_Controller. The Zf_Controller component has the following goals:

• Abstract complexity: Try to reduce the level of details so the developer can focus on a few concepts at a time.
• Emphasize Convention over Configuration: Emphasize CoC, meaning that the user only needs to specify unconventional aspects of the application.
• Maintain backwards compatibility: Allow the developer to replace Zf_Controller with Zend_Controller in case the application grows in size or complexity.
• Improve performance: Load less classes, execute less code.
• Remove circular references: Avoid circular references.
• Remove Singleton classes: Avoid implementing the Singleton pattern.
• Research: Learn more about the framework, what it does, how it works.

Project Structure

Zend_Controller allows you to use the project structure that best suits your needs. On the other hand, Zf_Controller is more rigid, it only allows you to use the standard project structure:

project/
  app/
    config/
    controllers/
      ErrorController.php
      IndexController.php
    views/
      layouts/
      scripts/
        error/
        index/
          index.phtml
  domain/
    Model/
      Example.php
  lib/
    Zend/
    Zf/

Zf_Controller classes:

Zf/
  Controller/
    Action/
      Helper/
        Layout.php
    Action.php
    Front.php

Bootstrap File

Zend_Controller:

define('APPLICATION_PATH', realpath(dirname(__FILE__) . '/../app'));
set_include_path(APPLICATION_PATH . '/../lib'
    . PATH_SEPARATOR . get_include_path());

require_once "Zend/Loader.php";
Zend_Loader::registerAutoload();

$frontController = Zend_Controller_Front::getInstance();
$router = $frontController->getRouter();
$routes = include_once APPLICATION_PATH . '/config/routes.php';
$router->addRoutes($routes);

$layout = Zend_Layout::startMvc();
$layout->setLayoutPath(APPLICATION_PATH . '/views/layouts');

$frontController->dispatch();

Zf_Controller (no Router):

define('APPLICATION_PATH', realpath(dirname(__FILE__) . '/../app'));
set_include_path(APPLICATION_PATH . '/../lib'
    . PATH_SEPARATOR . APPLICATION_PATH . '/../domain);

require_once "Zend/Loader.php";
Zend_Loader::registerAutoload();

$frontController = new Zf_Controller_Front();
$frontController->setLayoutPath(APPLICATION_PATH . '/views/layouts');
$frontController->dispatch();

Action Controller

The default action controller and the default action are named “index”:

class IndexController extends Zf_Controller_Action
{
  public function indexAction()
  {}
}

Error Controller

Zend_Controller:

class ErrorController extends Zend_Controller_Action
{
  // Action used by Zend_Controller
  public function errorAction()
  {
    $error = $this->_getParam('error_handler');
    echo $error->exception->getMessage();
  }
}

Zf_Controller:

class ErrorController extends Zf_Controller_Action
{
  // Action used by Zf_Controller
  public function indexAction($e)
  {
    echo $e->getMessage();
  }
}

Rendering a View Script

Zf_Controller does not use the ViewRenderer helper class. To make the code more readable and testable, you need to call the render() method and return a value:

class IndexController extends Zf_Controller_Action
{
  public function indexAction()
  {
    $view = $this->initView();
    $view->message = 'Hello';

    // Renders views/scripts/index/index.phtml
    return $this->render();
  }

  public function testAction()
  {
    $view = $this->initView();
    $view->message = 'Goodbye';

    // Renders views/scripts/index/index.phtml
    return $this->render('index');
  }}

index.phtml file:

<p><?php echo $this->message ?></p>

Using a Layout

By setting the path to your layouts in the Bootstrap file, you automatically enable the default layout “layout.phtml”:

$frontController = new Zf_Controller_Front();
$frontController->setLayoutPath(APPLICATION_PATH . '/views/layouts');

To disable the layout:

class IndexController extends Zf_Controller_Action
{
    protected $_isLayoutEnabled = false;
}

To use a different layout:

class IndexController extends Zf_Controller_Action
{
    protected $_layoutScript = 'main.phtml';
}

main.phtml file:

<!DOCTYPE html
PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<?php echo $this->headTitle() ?>
<?php echo $this->headScript() ?>
<?php echo $this->headStyle() ?>
</head>
<body>
<div id="content"><?php echo $this->layout()->content ?></div>
</body>
</html>

Part 2: An Alternative to Zend_Controller: The Router