request y isPost en ZF

[Fenris]

Hola

He visto en manuales de ZF que utilizan $this->request->isPost() o $this->getRequest()->isPost(),
Quisiera saber si alguien ayuda, como está construido el método isPost y getRequest y que se almacena en tal caso en $this->request.

Saludos

[SergeMedina]

Request es el objeto de la peticion al servidor. Por lo tanto isPost busca en la peticion al servidor el metodo de peticion:

Código PHP:

/**
     * Was the request made by POST?
     *
     * @return boolean
     */
    public function isPost()
    {
        if ('POST' == $this->getMethod()) {
            return true;
        }
 
        return false;
    }
 

[Fenris]

Hola

Gracias por responder, pero me surgen varias consultas mas:

• Como obtengo ese objeto request y donde sera en el FrontController?
• Si request es un objeto, isPost es un método de la misma clase donde se define request?
• Que contiene el método $this->getMethod() y a que clase pertenece?
• El método getRequest() que contiene, se define un request por cada peticion al servidor?
• En que clase podría definir esos métodos.

Saludos y espero sus respuestas ya que serán de gran ayuda para entender mas ZF, POO y PHP.

[SergeMedina]

Toda esa información la encontraras mucho mejor explicada en el manual de Zend. Tambien puedes ver el camino que sigue una aplicación hecha en zend framework viendo que se ejecuta y como estan construidas las clases.

[GatorV]

Otra cosa, y es una de las ventajas es que Zend es opensource por lo que puedes el código fuente sin problemas.

Saludos.

[Fenris]

GatorV

Justamente eso estaba tratando de hacer mirando el código fuente de ZF para ver donde encuentro esa implementación pero no he dado con ella por ello es que consultaba aquí a ver que me podrían decir no solamente con el fin de ver código sino de entender como se manejan esas transacciones, peticiones al servidor, ya que no entiendo aun donde se genera ese objeto request, quien lo genera, y como sabe si es POST o GET, yo en los actions de mi implementación lo estaba haciendo simplemente asi :
if ($_POST && $_SERVER['REQUEST_METHOD']=='POST') -> proceso los datos del formulario según action. Pero me parece que hay mas concepto de POO y encapsulación en como lo implementa ZF en contraposición a lo que estoy haciendo yo por eso quería saber como lo hacia para entenderlo y aplicarlo a mi implementación.

Saludos

[GatorV]

Lo hace en el request default, lo puedes ver en el archivo Zend/Controller/Request/Http.php y tal cual la implementación es algo similar:

Código PHP:

/**
     * Return the method by which the request was made
     *
     * @return string
     */
    public function getMethod()
    {
        return $this->getServer('REQUEST_METHOD');
    }
 
    /**
     * Was the request made by POST?
     *
     * @return boolean
     */
    public function isPost()
    {
        if ('POST' == $this->getMethod()) {
            return true;
        }
 
        return false;
    }
 

Saludos.

[Fenris]

Gracias GatorV

Ya lo he encontrado solo busque mal, pero aun tengo mas consultas quizás puedan parecer obvias pero quiero entender bien el flujo de información, por ende quisiera saber si es así el flujo de información en un ejemplo hipotético.

• Ingreso al index.php que carga la vista de listado de artículos
• Luego en el menú busco agregar artículos. Donde aparece el formulario para agregar artículos a la bd.
• Completo el formulario y presiono el boton "agregar" para enviar el formulario para ser procesado.
• El FrontController captura la URI y de ella desprende el controlador(artículos) y el action(add).
• Instancia el controlador y despacha a la accion solicitada que seria add por ejemplo.

Donde en toda esa ejecución creo un objeto Request, como lo creo, ese objeto se almacena en el registro? (patrón Registry) y luego en el action se llama de esta manera $this->request = Registry::get('request') ?; ya que en el action addAction yo debería usar if ($this->request->isPost())

Saludos cordiales y espero se entienda, lamento si les parece muy obvio pero necesito entender bien antes de programar.

[SergeMedina]

A mi entender el request no esta almacenado en el registro, este es manejado unicamente por el front controller (Zend/Controller/Front.php):

Código PHP:

/**
     * Dispatch an HTTP request to a controller/action.
     *
     * @param Zend_Controller_Request_Abstract|null $request
     * @param Zend_Controller_Response_Abstract|null $response
     * @return void|Zend_Controller_Response_Abstract Returns response object if returnResponse() is true
     */
    public function dispatch(Zend_Controller_Request_Abstract $request = null, Zend_Controller_Response_Abstract $response = null)
    {
        if (!$this->getParam('noErrorHandler') && !$this->_plugins->hasPlugin('Zend_Controller_Plugin_ErrorHandler')) {
            // Register with stack index of 100
            require_once 'Zend/Controller/Plugin/ErrorHandler.php';
            $this->_plugins->registerPlugin(new Zend_Controller_Plugin_ErrorHandler(), 100);
        }
 
        if (!$this->getParam('noViewRenderer') && !Zend_Controller_Action_HelperBroker::hasHelper('viewRenderer')) {
            require_once 'Zend/Controller/Action/Helper/ViewRenderer.php';
            Zend_Controller_Action_HelperBroker::getStack()->offsetSet(-80, new Zend_Controller_Action_Helper_ViewRenderer());
        }
 
        /**
         * Instantiate default request object (HTTP version) if none provided
         */
        if (null !== $request) {
            $this->setRequest($request);
        } elseif ((null === $request) && (null === ($request = $this->getRequest()))) {
            require_once 'Zend/Controller/Request/Http.php';
            $request = new Zend_Controller_Request_Http();
            $this->setRequest($request);
        }
 
        /**
         * Set base URL of request object, if available
         */
        if (is_callable(array($this->_request, 'setBaseUrl'))) {
            if (null !== $this->_baseUrl) {
                $this->_request->setBaseUrl($this->_baseUrl);
            }
        }
 
        /**
         * Instantiate default response object (HTTP version) if none provided
         */
        if (null !== $response) {
            $this->setResponse($response);
        } elseif ((null === $this->_response) && (null === ($this->_response = $this->getResponse()))) {
            require_once 'Zend/Controller/Response/Http.php';
            $response = new Zend_Controller_Response_Http();
            $this->setResponse($response);
        }
 
        /**
         * Register request and response objects with plugin broker
         */
        $this->_plugins
             ->setRequest($this->_request)
             ->setResponse($this->_response);
 
        /**
         * Initialize router
         */
        $router = $this->getRouter();
        $router->setParams($this->getParams());
 
        /**
         * Initialize dispatcher
         */
        $dispatcher = $this->getDispatcher();
        $dispatcher->setParams($this->getParams())
                   ->setResponse($this->_response);
 
        // Begin dispatch
        try {
            /**
             * Route request to controller/action, if a router is provided
             */
 
            /**
            * Notify plugins of router startup
            */
            $this->_plugins->routeStartup($this->_request);
 
            $router->route($this->_request);
 
            /**
            * Notify plugins of router completion
            */
            $this->_plugins->routeShutdown($this->_request);
 
            /**
             * Notify plugins of dispatch loop startup
             */
            $this->_plugins->dispatchLoopStartup($this->_request);
 
            /**
             *  Attempt to dispatch the controller/action. If the $this->_request
             *  indicates that it needs to be dispatched, move to the next
             *  action in the request.
             */
            do {
                $this->_request->setDispatched(true);
 
                /**
                 * Notify plugins of dispatch startup
                 */
                $this->_plugins->preDispatch($this->_request);
 
                /**
                 * Skip requested action if preDispatch() has reset it
                 */
                if (!$this->_request->isDispatched()) {
                    continue;
                }
 
                /**
                 * Dispatch request
                 */
                try {
                    $dispatcher->dispatch($this->_request, $this->_response);
                } catch (Exception $e) {
                    if ($this->throwExceptions()) {
                        require_once 'Zend/Controller/Exception.php';
                        throw new Zend_Controller_Exception($e->getMessage(), $e->getCode(), $e);
                    }
                    $this->_response->setException($e);
                }
 
                /**
                 * Notify plugins of dispatch completion
                 */
                $this->_plugins->postDispatch($this->_request);
            } while (!$this->_request->isDispatched());
        } catch (Exception $e) {
            if ($this->throwExceptions()) {
                require_once 'Zend/Controller/Exception.php';
                throw new Zend_Controller_Exception($e->getMessage(), $e->getCode(), $e);
            }
 
            $this->_response->setException($e);
        }
 
        /**
         * Notify plugins of dispatch loop completion
         */
        try {
            $this->_plugins->dispatchLoopShutdown();
        } catch (Exception $e) {
            if ($this->throwExceptions()) {
                require_once 'Zend/Controller/Exception.php';
                throw new Zend_Controller_Exception($e->getMessage(), $e->getCode(), $e);
            }
 
            $this->_response->setException($e);
        }
 
        if ($this->returnResponse()) {
            return $this->_response;
        }
 
        $this->_response->sendResponse();
    }
}
 

[GatorV]

El request se inicializa en el frontController, la firma del frontController es:

Código PHP:

public function dispatch(Zend_Controller_Request_Abstract $request = null, Zend_Controller_Response_Abstract $response = null)
 

Es decir tu le puedes pasar un objeto $request, si no lo haces, crea uno:

Código PHP:

/**
         * Instantiate default request object (HTTP version) if none provided
         */
        if (null !== $request) {
            $this->setRequest($request);
        } elseif ((null === $request) && (null === ($request = $this->getRequest()))) {
            require_once 'Zend/Controller/Request/Http.php';
            $request = new Zend_Controller_Request_Http();
            $this->setRequest($request);
        }
 

Luego crea un dispatcher (por defecto esta en Zend/Controller/Dispatcher/Standard.php) y le pasa el $request que tiene el frontController. Posteriormente al crear el Controller pasa este objeto $request al controller y lo guarda en la variable $_request:

Código PHP:

/**
     * Zend_Controller_Request_Abstract object wrapping the request environment
     * @var Zend_Controller_Request_Abstract
     */
    protected $_request = null;
 

Por lo que tu dentro de tu action controller lo puedes leer ya sea usando $_request, o $this->getRequest().

Saludos.

[SergeMedina]

En este diagrama puedes ver la ruta que sigue una aplicacion de Zend:



Lo tome de esta web.

¿Será conveniente guardar esta imagen en algún lugar de este foro?

[GatorV]

Buen diagrama explica bien como funciona todo el proceso de Zend.

Saludos.