Rotte¶

Symfony2 dirige la richiesta al codice che la gestisce, cercando la corrispondenza tra l'URL richiesto e alcuni schemi configurati. Per impostazione predefinita, questi schemi (chiamate "rotte") sono definite nel file di configurazione app/config/routing.yml. Se si è nell'ambiente dev, indicato dal front controller app_**dev**.php, viene caricato il file di configurazione app/config/routing_dev.yml. Nella Standard Edition, le rotte delle pagine di demo sono in quel file:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# app/config/routing_dev.yml
_welcome:
    pattern:  /
    defaults: { _controller: AcmeDemoBundle:Welcome:index }

_demo:
    resource: "@AcmeDemoBundle/Controller/DemoController.php"
    type:     annotation
    prefix:   /demo

# ...

Le prime righe (dopo il commento) definiscono quale codice richiamare quanto l'utente richiede la risorsa "/" (come la pagina di benvenuto vista prima). Quando richiesto, il controllore AcmeDemoBundle:Welcome:index sarà eseguito. Nella prossima sezione, si imparerà esattamente quello che significa.

Controllori¶

Il controllore è una funzione o un metodo PHP che gestisce le richieste in entrata e restituisce delle risposte (spesso codice HTML). Invece di usare variabili e funzioni globali di PHP (come $_GET o header()) per gestire questi messaggi HTTP, Symfony usa degli oggetti: Request e Response. Il controllore più semplice possibile potrebbe creare la risposta a mano, basandosi sulla richiesta:

1
2
3
4
5

use Symfony\Component\HttpFoundation\Response;

$name = $request->query->get('name');

return new Response('Hello '.$name, 200, array('Content-Type' => 'text/plain'));

Symfony2 sceglie il controllore basandosi sul valore _controller della configurazione delle rotte: AcmeDemoBundle:Welcome:index. Questa stringa è il nome logico del controllore e fa riferimento al metodo indexAction della classe Acme\DemoBundle\Controller\WelcomeController:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// src/Acme/DemoBundle/Controller/WelcomeController.php
namespace Acme\DemoBundle\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\Controller;

class WelcomeController extends Controller
{
    public function indexAction()
    {
        return $this->render('AcmeDemoBundle:Welcome:index.html.twig');
    }
}

La classe WelcomeController estende la classe predefinita Controller, che fornisce alcuni utili metodi scorciatoia, come il metodo render(), che carica e rende un template (AcmeDemoBundle:Welcome:index.html.twig). Il valore restituito è un oggetto risposta, popolato con il contenuto resto. Quindi, se ci sono nuove necessità, l'oggetto risposta può essere manipolato prima di essere inviato al browser:

1
2
3
4
5
6
7

public function indexAction()
{
    $response = $this->render('AcmeDemoBundle:Welcome:index.txt.twig');
    $response->headers->set('Content-Type', 'text/plain');

    return $response;
}

Indipendentemente da come lo si raggiunge, lo scopo finale del proprio controllore è sempre quello di restituire l'oggetto Response da inviare all'utente. Questo oggetto Response può essere popolato con codice HTML, rappresentare un rinvio del client o anche restituire il contenuto di un'immagine JPG, con un header Content-Type del valore image/jpg.

Il nome del template, AcmeDemoBundle:Welcome:index.html.twig, è il nome logico del template e fa riferimento al file Resources/views/Welcome/index.html.twig dentro AcmeDemoBundle (localizzato in src/Acme/DemoBundle). La sezione successiva sui bundle ne spiega l'utilità.

Diamo ora un altro sguardo al file di configurazione delle rotte e cerchiamo la voce _demo:

1
2
3
4
5

# app/config/routing_dev.yml
_demo:
    resource: "@AcmeDemoBundle/Controller/DemoController.php"
    type:     annotation
    prefix:   /demo

Symfony2 può leggere e importare informazioni sulle rotte da diversi file, scritti in YAML, XML, PHP o anche inseriti in annotazioni PHP. Qui, il nome logico del file è @AcmeDemoBundle/Controller/DemoController.php e si riferisce al file src/Acme/DemoBundle/Controller/DemoController.php. In questo file, le rotte sono definite come annotazioni sui metodi delle azioni:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// src/Acme/DemoBundle/Controller/DemoController.php
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Template;

class DemoController extends Controller
{
    /**
     * @Route("/hello/{name}", name="_demo_hello")
     * @Template()
     */
    public function helloAction($name)
    {
        return array('name' => $name);
    }

    // ...
}

L'annotazione @Route() definisce una nuova rotta con uno schema /hello/{name}, che esegue il metodo helloAction quando trovato. Una stringa racchiusa tra parentesi graffe, come {name}, è chiamata segnaposto. Come si può vedere, il suo valore può essere recuperato tramite il parametro $name del metodo.

Dando un'occhiata più attenta al codice del controllore, si può vedere che invece di rendere un template e restituire un oggetto Response come prima, esso restituisce solo un array di parametri. L'annotazione @Template() dice a Symfony di rendere il template al posto nostro, passando ogni variabili dell'array al template. Il nome del template resto segue il nome del controllore. Quindi, nel nostro esempio, viene reso il template AcmeDemoBundle:Demo:hello.html.twig (localizzato in src/Acme/DemoBundle/Resources/views/Demo/hello.html.twig).

Template¶

Il controllore rende il template src/Acme/DemoBundle/Resources/views/Demo/hello.html.twig (oppure AcmeDemoBundle:Demo:hello.html.twig, se si usa il nome logico):

1
2
3
4
5
6
7
8

{# src/Acme/DemoBundle/Resources/views/Demo/hello.html.twig #}
{% extends "AcmeDemoBundle::layout.html.twig" %}

{% block title "Hello " ~ name %}

{% block content %}
    <h1>Hello {{ name }}!</h1>
{% endblock %}

Per impostazione predefinita, Symfony2 usa Twig come sistema di template, ma si possono anche usare i tradizionali template PHP, se si preferisce. Il prossimo capitolo introdurrà il modo in cui funzionano i template in in Symfony2.

Bundle¶

Forse vi siete chiesti perché il termine bundle viene usato così tante volte finora. Tutto il codice che si scrive per la propria applicazione è organizzato in bundle. Nel linguaggio di Symfony2, un bundle è un insieme strutturato di file (file PHP, fogli di stile, JavaScript, immagini, ...) che implementano una singola caratteristica (un blog, un forum, ...) e che può essere condivisa facilmente con altri sviluppatori. Finora abbiamo manipolato un solo bundle, AcmeDemoBundle. Impareremo di più sui bundle nell'ultimo capitolo di questa guida.