PHP vs Symfony Differenza Comunicazione Richiesta e risposta

Nella guida di oggi mettiamo a confronto PHP vs Symfony, il processo fondamentale che guida tutta la comunicazione sul web è la conversazione richiesta-risposta. Questo processo è tanto importante e potente, quanto inevitabilmente semplice.

Un importante strumento per verificare sia gli header di richiesta che quelli di risposta durante la navigazione è l’estensione Live HTTP Headers  di Firefox.

Richieste e risposte in PHP

Dunque, come interagire con la “richiesta” e creare una “risposta” quando si usa PHP? In realtà, PHP astrae un po’ l’intero processo:

$uri = $_SERVER[‘REQUEST_URI’];
$pippo = $_GET[‘pippo’];
header(‘Content-type: text/html’);
echo ‘L\’URI richiesto è: ‘.$uri;
echo ‘Il valore del parametro “pippo” è: ‘.$pippo;

Questa piccola applicazione di fatto prende informazioni dalla richiesta HTTP e le usa per creare una risposta HTTP. Invece di analizzare il messaggio di richiesta
HTTP grezzo, PHP prepara della variabili superglobali, come $_SERVER e $_GET, che contengono tutte le informazioni dalla richiesta.

Similmente, inece di restituire un testo di risposta formattato come da HTTP, si può usare la funzione header() per creare header di risposta e stampare semplicemente il
contenuto, che sarà la parte di contenuto del messaggio di risposta. PHP creerà una vera risposta HTTP e la restituirà al client:

HTTP/1.1 200 OK
 Date: Sat, 03 Apr 2011 02:14:33 GMT
 Server: Apache/2.2.17 (Unix)
 Content-Type: text/html
 L’URI richiesto è: /testing?pippo=symfony
 Il valore del parametro “pippo” è: symfony

Richieste e risposte in Symfony

Symfony fornisce un’alternativa all’approccio grezzo di PHP, tramite due classi che consentono di interagire con richiesta e risposta HTTP in modo più facile. La classe Request è una semplice rappresentazione orientata agli oggetti del messaggio di richiesta HTTP.

Con essa, si hanno a portata di mano tutte le informazioni sulla richiesta:

use Symfony\Component\HttpFoundation\Request;
 $request = Request::createFromGlobals();
 // l’URI richiesto (p.e. /about) tranne ogni parametro
 $request->getPathInfo();
 // recupera rispettivamente le variabili GET e POST
 $request->query->get(‘pippo’);
 $request->request->get(‘pluto’);
 // recupera le variabili SERVER
 $request->server->get(‘HTTP_HOST’);
 // recupera un’istanza di UploadedFile identificata da pippo
 $request->files->get(‘pippo’);
 // recupera il valore di un COOKIE
 $request->cookies->get(‘PHPSESSID’);
 // recupera un header di risposta HTTP, con chiavi normalizzate e minuscole
 $request->headers->get(‘host’);
 $request->headers->get(‘content_type’);
 $request->getMethod(); // GET, POST, PUT, DELETE, HEAD
 $request->getLanguages(); // un array di lingue accettate dal client

Per esempio, il metodo isSecure() verifica tre diversi valori in PHP che possono indicare  se l’utente si stia connettendo o meno tramite una connessione sicura (cioè https).
ParameterBags e attributi di Request
Come visto in precedenza, le variabili $_GET e $_POST sono accessibili rispettivamente tramite le proprietà pubbliche query e request. Entrambi questi oggetti sono oggetti della classe ParameterBag, che ha metodi come get(), has(), all() e altri. In effetti, ogni proprietà pubblica usata nell’esempio precedente è un’istanza di ParameterBag.
La classe Request ha anche una proprietà pubblica attributes, che contiene dati speciali relativi a come l’applicazione funziona internamente.

Per il framework Symfony2, attributes contiene valori restituiti dalla rotta corrispondente, come _controller, id (se si ha un parametro {id}), e anche il nome della rotta stessa (_route). La proprietà attributes è pensata apposta per essere un posto in cui preparare e memorizzare informazioni sulla richiesta relative al contesto.
Symfony fornisce anche una classe Response: una semplice rappresentazione PHP di un messaggio di risposta HTTP. Questo consente a un’applicazione di usare  un’interfaccia orientata agli oggetti per costruire la risposta che occorre restituire al client:

use Symfony\Component\HttpFoundation\Response;
 $response = new Response();
 $response->setContent(‘<html><body><h1>Ciao mondo!</h1></body></html>’);
 $response->setStatusCode(Response::HTTP_OK);
 $response->headers->set(‘Content-Type’, ‘text/html’);
 // stampa gli header HTTP seguiti dal contenuto
 $response->send();

New in version 2.4: Il supporto per le costanti dei codici di stato HTTP è stato aggiunto in Symfony 2.4.
Se Symfony offrisse solo questo, si avrebbe già a disposizione un kit di strumenti per accedere facilmente alle informazioni di richiesta e un’interfaccia orientata agli oggetti per creare la risposta.

Anche imparando le molte potenti caratteristiche di Symfony, si tenga a mente che lo scopo di un’applicazione è sempre quello di interpretare una richiesta e creare  l’appropriata risposta, basata sulla logica dell’applicazione.
Le classi Request e Response fanno parte di un componente a sé stante incluso con Symfony, chiamato HttpFoundation. Questo componente può essere usato in modo completamente indipendente da Symfony e fornisce anche classi per gestire sessioni e caricamenti di file.

Se qualcosa non è chiara fateci sapere.