PHP e i servizi REST con Slim Framework

07 May 2019 | M.A.D.R.

Micro Framework: Slim per facilitare lo sviluppo di servizi Rest con PHP

Di nuovo benvenuti a tutti, parliamo di come costruire delle API per estendere le funzionalità della nostra applicazione e come creare dei  servizi con il framework Slim – PHP.

  1. A cosa serve?
  2. Il suo reale utilizzo?
  3. Necessito effettivamente di questo framework?

Per rispondere velocemente alle 3 domande sopra:

  • 1- Se necessiti di recuperare dei contenuti remoti con elaborazione da parte del server potrebbe essere utile utilizzare SLIM.
  • 2- Pensiamo semplicemente a delle chiamate in ajax, separeremo l’applicazione dalle API.
  • 3- No, nessuno obbliga l’utilizzo dei framework, ma onestamente semplifica la vita.

Detto questo…. Slim framework è scritto in PHP, pensato per creare piccole applicazioni web. Il suo punto di forza rispetto ad altri framework è l’estrema semplicità di utilizzo.

Cosa ci attende e cosa riesce a gestire?

  • Routing engine
  • Gestione cookie
  • Cache HTTP
  • Messaggi Flash
  • Templating

Visto che l’articolo parla dei Servizi Rest, oggi tratteremo  Slim Framework con il solo scopo di creare una libreria di servizi REST, soffermandoci sulle route, e cercando di capire come implementare questo fantastico tool in un progetto esistente…

Prima di tutto dobbiamo scaricarlo,  seguendo la documentazione ufficiale.

Bene pronti per partire…

Creiamo la nostra paginetta “index.php" e iniziamo a creare l’oggetto Slim:

require 'Slim/Slim.php';
SlimSlim::registerAutoloader();
 
$app = new SlimSlim();

//rotta definita all'interno della index
$app->get('/home', function() {
    echo "Sono la tua prima rotta";
});
/**ALTERNATIVA*/
//per semplicità solitamente creo dei file di route dividendoli per scopo
//in questo caso includerei il file che richiama correttamente le route
include_once('my_route.php');
//All'interno di questo file definisco le route!

Abbiamo creato una rotta “sito_web/home" che risponderà con un print  “Sono la tua prima rotta", come avete visto l’utilizzo di questo framework in modalità basica è estremamente facile…

Ma vediamo qualcosina di più….

Slim permette di definire le rotte con le 4 operazioni CRUD (Create, Read, Update, Delete), in questo modo creiamo un primo strato per la nostra applicazione riuscendo a separare effettivamente le operazioni di lettura, aggiornamente etc etc.

Altra nota positiva per questo fantastico framework è la possibilità di creare dei middleware (sono classi PHP che vengono eseguite prima di qualsiasi chiamata). Per spiegare un Middleware pensate ad una cipolla…

Ossia ogni strato della nostra “cipolla" fa qualcosa e solo alla fine si arriva al centro con il codice effettivamente richiesto….

Definiamo meglio:

“la route che vogliamo invocare si trova al centro, ogni middleware rappresenta uno strato aggiuntivo, aggiungendo/togliendo dati, e/o verificare username e password, effettuare una registrazione di azioni etc etc".

Ma vediamo un pò come funziona:

//Recuperiamo una risorsa
$app->get('/utenti/get_all', function(){
   //codice da eseguire
$result=codice_eseguito;
    echo json_encode($result);
});
//Chiediamo uno specifico utente
$app->get('/utenti/details/:id', function($id) {
     //codice da eseguire
$result=codice_eseguito;
if(!empty($result))echo json_encode($result);
else echo json_encode(['errore']);
});
//Creiamo un nuovo utente
$app->post('/utenti/nuovo/', function() use($app,$db) {
    $campi_nuovo_utente= json_decode($app->request()->getBody());
 //codice da eseguire
    echo json_encode($campi_nuovo_utente);
 
});

Quanto appena letto per applicazioni piccoline è ottimo, ma per uniformare le risposte sarebbe opportuno generare una nostra funzione che uniformerà le risposte di slim, così da rendere l’output sempre uguale.

Parlando di servizi REST solitamente l’output di risposta è un JSON, così da rendere il parsing dello stesso immediato con l’utilizzo di ajax (non è il vero motivo), quindi ogni chiamata avrà come output un JSON, una possibile risposta potrebbe essere:

{
    "id": 1,
    "nome": "Nome",
    "cognome": "Cognome"
}

Questa notazione seppur corretta non la prediligo, per un semplice motivo, se dovessimo recuperare più utenti dovremmo cambiare la nostra funzione che richiama questo output, sarebbe meglio una risposta in questo modo

[{
    "id": 1,
    "nome": "Nome",
    "cognome": "Cognome"
}]

Cosa cambia? Abbiamo passato un’array di oggetti e non solo l’oggetto corrente, in questo modo uniformando la risposta potremmo provvedere alla creazione di un solo modello capace di gestire le richieste…

Soluzioni complete per ogni esigenza