Symfony: tutorial 5: los controladores

Symfony tutorial controladores

Extendiendo el tutorial sobre enrutamiento anterior, seguimos hoy con los controladores, un paso más allá. En Symfony Flex, Symfony 4, se ha mejorado de nuevo otra de sus herramientas, el enrutamiento. Todo el enrutamiento se configura dentro de los controladores con las últimas versiones. Todo, URLs, parámetros, tipo de petición, se puede ya configurar dentro de los mismos ficheros de controladores. Esto es realmente cómodo en el día a día.

Además, en estas últimas versiones del enrutador de Symfony, según rankings independientes a Symfony, disponemos de un enrutamiento 75 veces más rápido que en la versión anterior. Es el enrutador PHP más rápido que hay, de nuevo, otro referente en este mundillo.

Un poco de teoría

Para éste tutorial, sino lo sabías quizá ya lo has intuido leyendo lo anterior, pero lo único que hay que saber es que los controladores son lo que realizan las acciones. Es decir, si el navegador pide cada página del sitio web, debe haber un controlador que reciba dicha URL, haciendo lo que tenga que hacer, y devolviendo lo que tenga que devolver.

Hay URLs que corresponden a ficheros, en las que el servidor devolverá el fichero al navegador. Pero incluso podemos simular peticiones a ficheros que no existen en el servidor, y con un controlador, ‘generarlos’ al vuelo y devolverlos al visitante. Digo ‘generarlos’ porque no hace falta ni grabar el fichero a disco, sino crearlo en el momento dentro del controlador y devolverlo como si se tratara de un fichero.

Creando el proyecto de pruebas

Vamos a nuestro directorio de trabajo y ejecutamos la creación de un proyecto nuevo:

composer create-project symfony/skeleton symfony-tutorial-controllers

Entramos dentro del directorio nuevo, y le instalamos algunos vendors que vamos a usar en este proyecto:

cd symfony-tutorial-controllers/
composer require --dev maker server
composer require annotations twig orm form validator security-csrf

Arrancamos el servidor local para comenzar a probar cosas con los controladores:

php bin/console server:start

Si vamos a http://localhost:8000/ no veremos nada más que lo siguiente en nuestro navegador. Eso es que ha ido bien..

Symfony Controllers

Esta es la página por defecto que nos sale cuando estamos en local, y acabamos de crear un proyecto que no tiene todavía controladores.

Comenzamos a enrutar

Para esto simplemente necesitamos crear nuestro primer controlador de este proyecto:

php bin/console make:controller

..y le ponemos un nombre, por ejemplo DefaultController. Esto nos creará el fichero src/Controller/DefaultController.php que es el controlador, y el fichero templates/default/index.html.twig porque he instalado el vendor de Twig para usarlo en la vista.

<?php

namespace App\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Routing\Annotation\Route;

class DefaultController extends AbstractController
{
    /**
     * @Route("/default", name="default")
     */
    public function index()
    {
        return $this->render('default/index.html.twig', [
            'controller_name' => 'DefaultController',
        ]);
    }
}

Mirando el código podemos ver que ya con este controlador, tenemos enrutada la URL /default que apunta a este recién generado controlador. Sigamos y vamos a hacer cosas.

Rutas con parámetros, enrutamiento de URLs dinámicas

Para esto simplemente podemos poner como hemos visto en tutoriales anteriores los parámetros en las anotaciones. Por ejemplo, si queremos recibir en este controlador un parámetro de forma amigable con la URL /ruta-amigable/parametro podemos editar el controlador anterior así:

    /**
     * @Route("/ruta-amigable/{parametro}", name="default")
     */
    public function index($parametro)
    {

De esta forma ya podemos usar la variable $parametro dentro de la acción del controlador.

Los objetos Request and Session

Desde que se recibe la petición del navegador hasta que se devuelve la respuesta, en Symfony ocurren muchas cosas. Hay dos objetos muy interesantes para gestionar lo que nos llega del navegador del visitante. Por ejemplo tenemos el objeto Request que representa la petición al completo. En esta petición tenemos información como parámetros, tanto datos GET como POST, o el tipo de petición, URL, IPs de clientes o forwarding si pasa por proxys, puertos, idioma, etcétera..

En el objeto Session tenemos otra información relacionada con la sesión que ha abierto un usuario en nuestro navegador. Es decir, cuando un usuario llega al servidor, se crea una sessión. Cuando va haciendo varias peticiones, podemos seguirle, sabiendo si es anónimo, si se ha logueado sabemos quién es, podemos almacenar variables de sesión, mensajes, etcétera..

Todo esto entonces lo tenemos modificando el ejemplo anterior así:

<?php

namespace App\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Session\Session;

class DefaultController extends AbstractController
{
    /**
     * @Route("/ruta-amigable/{parametro}", name="default")
     */
    public function index($parametro, Request $request, Session $session)
    {
        return $this->render('default/index.html.twig', [
            'controller_name' => 'DefaultController',
        ]);
    }
}

Simplemente, con eso, ya tenemos estos dos objetos en el controlador.

Redirigiendo visitas

Hay dos funcionalidades muy útiles en los controladores. La primera es la redirección, la otra es el forwarding. Con la redirección le devolvemos una respuesta al cliente y éste se redirigirá a otra web de destino que le indiquemos. Por ejemplo, para redirigir a otra ruta se hace así:

return $this->redirectToRoute('route_name2', array('parameter' => $value));

Con el forwarding lo que hacemos es ejecutar un controlador final cuando inicialmente hemos llamado a uno. El visitante recibirá directamente la respuesta del segundo controlador, no sabrá que se le ha hecho forwarding, con lo que su URL no cambiará. Esto se hace así:

$response = $this->forward('App\Controller\DefaultController::otherRoute', array(
    'parameter'  => $value,
));

Generando controladores CRUD automáticamente

Para terminar con este post, pienso que es muy interesante ver el generador de CRUDs que tiene Symfony. Es una maravilla ya que a partir de una entidad, te genera un controlador con todas las acciones de creación, listado, edición y borrado.

Vamos entonces a generar una entidad de prueba, ejecutamos:

php bin/console make:entity

..y generamos una entidad para guardar una agenda de teléfonos. Podemos llamar a la entidad Direccion con nombre y teléfono como parámetros. Así ya tenemos 2 columnas. Luego configuramos el fichero .env para que tenga base de datos, y ejecutamos lo siguiente para crear localmente nuestra base de datos:

php bin/console doctrine:database:create
php bin/console doctrine:schema:create

Y ahora vamos a generar el controlador y vistas de este CRUD, ejecutamos:

php bin/console make:crud

..y elegimos la entidad Direccion recién creada. Y ahora, ya tenemos la interfaz completa para gestionar las direcciones. ¡Ya está! ¡Brutal! ¿Cierto? Si esto lo hacemos para 8-10 entidades de un proyecto completo, tenemos un buen punto de partida en muy pocos minutos para una aplicación de gestión. Tendremos los controladores CRUD funcionales, podremos ir directos a maquetar las plantillas y trabajar los controladores para las funcionalidades accesorias.

SymfonyControllerCRUD

Compartir..

Dejar un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

18 + dos =