Zend_Controller_Action es una clase abstracta que puede utilizar para implementar controladores de acción (Action Controllers) para usar con el Front Controller al crear un un sitio basado en el patrón Modelo-Vista-Controlador ( MVC ).

Para usar Zend_Controller_Action , necesitará hacerla una subclase en sus clases actuales de controladores de acción (o hacerla una subclase para crear su propia clase base de acción de controladores). La operación más elemental es hacerla una subclase, y crear métodos de acción que corresponden a las diversas acciones que desee que el contralor maneje para su sitio. El manejo del ruteo y envío de Zend_Controller descubrirá por sí mismo cualquier método que termine en 'Action' en su clase, como posibles acciones del controlador.

Por ejemplo, digamos que su clase se define como sigue:

class FooController extends Zend_Controller_Action
{
    public function barAction()
    {
        // hacer algo
    }

    public function bazAction()
    {
        // hacer algo
    }
}

La clase de arriba FooController (el controlador foo ) define dos acciones, bar y baz .

Se pueden lograr muchas cosas más, tales como personalizar la inicialización de acciones, las acciones a llamar por defecto no deberían especificar ninguna acción (o una acción inválida), ganchos de pre y post despacho, y una variedad de métodos ayudantes. Este capítulo sirve como panorama de la funcionalidad del controlador de acciones.

class FooController extends Zend_Controller_Action
{
    public function init()
    {
        // Local a este controlador únicamente; afecta a todas las acciones
        // al cargarse en init:
        $this->_helper->viewRenderer->setNoRender(true);

        // Globalmente:
        $this->_helper->removeHelper('viewRenderer');

        // También globalmente, pero tendría que ser en conjunción con la
        // versión local con el fin de propagarlo para este controlador:
        Zend_Controller_Front::getInstance()
            ->setParam('noViewRenderer', true);
    }
}

class FooController extends Zend_Controller_Action
{
    public function barAction()
    {
        // deshabilitar el autorendering para esta acción solamente:
        $this->_helper->viewRenderer->setNoRender();
    }
}

Si bien siempre puede anular el contolador de acción del constructor, no lo recomendamos. Zend_Controller_Action::__construct() realiza algunas tareas importantes, tales como registrar los objetos de solicitud y respuesta, así como los argumentos de cualquier invocación personalizada pasados desde el front controller. Si debe anular el constructor, asegúrese de llamar a parent::__construct($request, $response, $invokeArgs) .

La manera más apropiada de personalizar la instanciación es utilizar el método init() , el cual es llamado como la última tarea de __construct() . Por ejemplo, si se quiere conectar a una base de datos en la instanciación:

class FooController extends Zend_Controller_Action
{
    public function init()
    {
        $this->db = Zend_Db::factory('Pdo_Mysql', array(
            'host'     => 'myhost',
            'username' => 'user',
            'password' => 'XXXXXXX',
            'dbname'   => 'website'
        ));
    }
}

Zend_Controller_Action especifica dos métodos que pueden ser llamados para marcar una solicitud de acción, preDispatch() y postDispatch() . Estas pueden ser útiles de varias maneras: verificar la autenticación y ACL s antes de ejecutar una acción (llamando a _forward() en preDispatch() , se saltará la acción), por ejemplo, o colocando contenido generado en una plantilla general del sitio ( postDispatch() ).

Con el objeto, se registran una serie de objetos y variables, y cada uno tiene métodos de acceso.

Zend_Controller_Action proporciona un mecanismo rudimentario y flexible para ver la integración. Hay dos métodos para lograrlo, initView() y render() ; el anterior método $view carga la propiedad pública, y este último muestra una vista en base a la acción requerida actual, utilizando la jerarquía del directorio para determinar el path del script.

applicationOrModule/
    controllers/
        IndexController.php
    views/
        scripts/
            index/
                index.phtml
        helpers/
        filters/

string render(string $action = null,
              string $name = null,
              bool $noController = false);

class MyController extends Zend_Controller_Action
{
    public function fooAction()
    {
        // Suministra my/foo.phtml
        $this->render();

        // Suministra my/bar.phtml
        $this->render('bar');

        // Suministra baz.phtml
        $this->render('baz', null, true);

        // Suministra my/login.phtml al segmento 'form' del
        // objeto respuesta
        $this->render('login', 'form');

        // Suministra site.phtml al segmento 'page' del objeto
        // respuesta; no usa el subdirectorio 'my/'
        $this->render('site', 'page', true);
    }

    public function bazBatAction()
    {
        // Suministra my/baz-bat.phtml
        $this->render();
    }
}

Además de los accesadores y de los métodos de integración de vistas, Zend_Controller_Action tiene varios métodos utilitarios para realizar tareas comunes dentro de sus métodos de acción (o de pre- y post-dispatch).

Por diseño, Zend_Controller_Action debe ser "subclaseada" a fin de crear un controlador de acción. Como mínimo, necesitará definir los métodos de acción que podrá llamar el controlador.

Además de crear una funcionalidad útil para su aplicaciones web, también puede encontrar que está repitiendo demasiado los mismos setups o métodos utilitarios en sus diferentes controladores; si así fuera, creando una clase base común del controlador que extienda Zend_Controller_Action puede resolver esta redundacia.

class MyController extends Zend_Controller_Action
{
    public function __call($method, $args)
    {
        if ('Action' == substr($method, -6)) {
            // Si no se encontró el método de la acción, suministrar la
            // plantilla de error
            return $this->render('error');
        }

        // todos los otros métodos lanzan una excepción
        throw new Exception('Se ha llamado al método "'
                            . $method
                            . '" que es inválido',
                            500);
    }
}

class MyController extends Zend_Controller_Action
{
    public function indexAction()
    {
        $this->render();
    }

    public function __call($method, $args)
    {
        if ('Action' == substr($method, -6)) {
            // Si no se encontró el método de acción, avance a la
            // acción index
            return $this->_forward('index');
        }

        // todos los otros métodos lanzan una excepción
        throw new Exception('Se ha llamado al método "'
                            . $method
                            . '" que es inválido',
                            500);
    }
}

Además de sobrecargar __call() , cada uno de los métodos gancho de inicialización, utilidad, accesador, vista, y despacho mencionados anteriormente en este capítulo pueden ser anulados a fin de personalizar sus controladores. Como ejemplo, si está almacenando su objeto vista en un registro, quizás desee modificar su método initView() con código parecido al siguiente:

abstract class My_Base_Controller extends Zend_Controller_Action
{
    public function initView()
    {
        if (null === $this->view) {
            if (Zend_Registry::isRegistered('view')) {
                $this->view = Zend_Registry::get('view');
            } else {
                $this->view = new Zend_View();
                $this->view->setBasePath(dirname(__FILE__) . '/../views');
            }
        }

        return $this->view;
    }
}

Es de esperar, que de la información en este capítulo, usted puede ver la flexibilidad de este componente en particular y cómo puede darle forma a su aplicaciones o a las necesidades de su sitio web.