In questa guida, Guida alla creazione e al test di API REST con PHP, vedremo come creare Api Rest con PHP e come testare il nostro servizio WEB con i metodi CRUD
Indice dei contenuti
Introduzione
I Web Services REST
I Web Services REST (Representational State Transfer) sono un’architettura software per sistemi distribuiti. Permettono la comunicazione tra client e server tramite il protocollo HTTP, utilizzando i metodi standard:
- GET: recupera dati
- POST: inserisce dati
- PUT: aggiorna dati
- DELETE: elimina dati
Un servizio REST è spesso impiegato per fornire un’interfaccia API, che espone operazioni su dati rappresentati in formato JSON.
Principi di un Web Service REST:
Separazione Client/Server.
Stateless: ogni richiesta è indipendente.
Accessibilità: accessibile via URL.
Formato dei dati: solitamente JSON o XML.
Il progetto
Ci proponiamo di realizzare un servizio WEB con API REST in PHP che consenta di ineragire con le risorse memorizzate in una tabella di un database attraverso le operazioni CRUD. Si tratta di una rubrica per cui saremo in grado di leggere i record, inserire nuovi utenti, modificare i dati degli utenti e cancellare gli utenti.
Creazione del database
Apriamo l’interfaccia PHPMyAdmin cliccando sul tasto “Admin” in corrispondenza di MySQL nel pannello di XAMPP e creiamo il database”rubrica” con la tabella “utenti”
CREATE DATABASE rubrica;
USE rubrica;
CREATE TABLE utenti(
id INT AUTO_INCREMENT PRIMARY KEY,
cognome VARCHAR(50) NOT NULL,
nome VARCHAR(50) NOT NULL,
email VARCHAR(100),
via VARCHAR(100),
citta VARCHAR(50),
provincia VARCHAR(2),
cap VARCHAR(10),
telefono VARCHAR(20),
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);popoliamo la tabella utenti:
INSERT INTO utenti (cognome, nome, email, via, citta, provincia, cap, telefono) VALUES
('Rossi', 'Mario', 'mario.rossi@example.com', 'Via Roma 12', 'Milano', 'MI', '20121', '3201234567'),
('Verdi', 'Luca', 'luca.verdi@example.com', 'Via Torino 45', 'Torino', 'TO', '10121', '3339876543'),
('Bianchi', 'Giulia', 'giulia.bianchi@example.com', 'Viale Italia 8', 'Firenze', 'FI', '50100', '3471112233'),
('Russo', 'Anna', 'anna.russo@example.com', 'Corso Venezia 5', 'Napoli', 'NA', '80100', '3894455667'),
('Gallo', 'Stefano', 'stefano.gallo@example.com', 'Via Garibaldi 22', 'Genova', 'GE', '16100', '3925544332'),
('Ferrari', 'Elena', 'elena.ferrari@example.com', 'Via Dante 14', 'Bologna', 'BO', '40121', '3406677889'),
('Marino', 'Francesca', 'francesca.marino@example.com', 'Via Mazzini 3', 'Roma', 'RM', '00100', '3289988776'),
('Conti', 'Paolo', 'paolo.conti@example.com', 'Via Manzoni 9', 'Palermo', 'PA', '90100', '3367766554'),
('De Luca', 'Alessandro', 'alessandro.deluca@example.com', 'Via Foscolo 1', 'Bari', 'BA', '70121', '3481122334'),
('Ricci', 'Laura', 'laura.ricci@example.com', 'Via Verdi 18', 'Venezia', 'VE', '30100', '3514433221');Realizziamo ora il progetto utilizzando due diversi metodi: procedurale e OOP. Iniziamo con il metodo procedurale
Realizzazione del progetto con metodo procedurale
Creare la cartella WEBServicePHP_procedurale all’interno di htdocs di XAMPP. Tutti i file verranno salvati in questa directory. Aprire Visual studio Code in questa directory e definire gli script in questa posizione.
connessione.php
Definiamo lo script di connessione al database:
<?php
$servername = "localhost";
$username = "root";
$password = "";
$database = "rubrica";
// Connessione in stile OOP
$conn = new mysqli($servername, $username, $password, $database);
// Verifica della connessione
if ($conn->connect_error) {
die(json_encode(["message" => "Connessione fallita: " . $conn->connect_error]));
}
?>
Perché usare echo json_encode(...):
-
Standardizzazione del formato di risposta:
Restituire sempre un oggetto JSON è una best practice nei Web Services REST, perché consente al client (es. Postman, Thunder Client, applicazioni frontend) di interpretare correttamente la risposta, indipendentemente dal metodo HTTP. -
Migliore compatibilità con gli strumenti di test:
Postman e Thunder Client si aspettano spesso risposte formattate in JSON. Se usidie()con stringhe HTML/testuali, possono interpretarle come errori non gestiti.
header.php
Sempre nella stessa cartella disponiamo uno script con gli header che verranno richiamati in tutti e quattro gli script che realizzano le operazioni CRUD.
<?php
// Accesso da qualsiasi dominio
header("Access-Control-Allow-Origin: *");
// Risposta in formato JSON
header("Content-Type: application/json; charset=UTF-8");
// Permette metodi PUT, GET, POST, DELETE
header("Access-Control-Allow-Methods: PUT, GET, POST, DELETE");
// Tempo di caching per le preflight request
header("Access-Control-Max-Age: 3600");
// Header consentiti
header("Access-Control-Allow-Headers: Content-Type, Authorization, X-Requested-With");
?>
La prima istruzione rende accessibile le pagine PHP a qualsiasi dominio, la seconda indica di restituire un contenuto di tipo JSON, codificato in UTF-8, le successive rendono accessibile i metodi CRUD, le due righe successive fanno parte della configurazione CORS (Cross-Origin Resource Sharing) e servono a definire le regole di accesso da parte di client che risiedono su domini differenti rispetto al server che ospita le API
header("Access-Control-Max-Age: 3600");
Significato: Questa intestazione specifica per quanto tempo (in secondi) il browser può memorizzare nella cache la risposta a una richiesta preflight.
Esempio pratico:
- Quando il browser esegue una richiesta non semplice (es.
PUT,DELETEo con intestazioni personalizzate), effettua prima una richiestaOPTIONSdetta preflight per chiedere al server se il client ha il permesso di procedere. - Con questa riga, diciamo al browser: “Puoi riutilizzare il risultato della preflight per i prossimi 3600 secondi (1 ora), senza ripetere la richiesta OPTIONS ogni volta.”
Vantaggio: Riduce il numero di richieste HTTP e migliora le prestazioni della comunicazione tra frontend e backend.
header("Access-Control-Allow-Headers: Content-Type, Authorization, X-Requested-With");
Significato: Questa intestazione dichiara quali intestazioni HTTP personalizzate il client può inviare nella richiesta effettiva dopo la preflight.
Cosa contiene:
-
Content-Type: consente al client di specificare il tipo di contenuto (es.application/json) -
Authorization: permette di inviare un token di autenticazione (es. JWT, Bearer token) -
X-Requested-With: utilizzato spesso da framework AJAX come jQuery per indicare che la richiesta è asincrona
rubrica.php
Ora generiamo lo script “rubrica.php” che contiene la logica di gestione dei quattro metodi. Ipotizziamo ciascun utente della rubrica abbia come attributi:
telefono, cognome, nome, email, via, citta, provincia, cap
Iniziamo ad includere la connessione, gli header e a ottenere il metodo HTTP della richiesta:
<?php
// Header comuni
include 'connessione.php';
include_once 'header.php';
// Ottieni il metodo HTTP
$method = $_SERVER['REQUEST_METHOD'];
// Leggi il corpo della richiesta
$input = json_decode(file_get_contents("php://input"), true);
Come già spiegato in altri articoli la riga di codice (file_get_contents("php://input"), true) permette di accedere al body della HTTP Request. Per cui la riga 10 del codice legge il contenuto del body, lo decodifica dal formato JSON e lo memorizza in $input
Ora, in base al metodo, dobbiamo eseguire le funzioni di lettura, scrittura, aggiornamento e cancellazione. Verifichiamo il metodo richiesto con il costrutto: switch-case.
Case : ‘GET’
switch ($method) {
case 'GET':
$sql = "SELECT * FROM utenti";
$result = mysqli_query($conn, $sql);
$rubrica = [];
while ($row = mysqli_fetch_assoc($result)) {
$rubrica[] = $row;
}
echo json_encode(["records" => $rubrica]);
break;Selezioniamo tutti i record e li memorizziamo in un array di record ( $rubrica )
Case ‘POST’
case 'POST':
if (!empty($input['cognome']) && !empty($input['nome'])) {
$cognome = mysqli_real_escape_string($conn, $input['cognome']);
$nome = mysqli_real_escape_string($conn, $input['nome']);
$email = mysqli_real_escape_string($conn, $input['email'] ?? '');
$via = mysqli_real_escape_string($conn, $input['via'] ?? '');
$citta = mysqli_real_escape_string($conn, $input['citta'] ?? '');
$provincia = mysqli_real_escape_string($conn, $input['provincia'] ?? '');
$cap = mysqli_real_escape_string($conn, $input['cap'] ?? '');
$telefono = mysqli_real_escape_string($conn, $input['telefono'] ?? '');
$sql = "INSERT INTO utenti (cognome, nome, email, via, citta, provincia, cap, telefono)
VALUES ('$cognome', '$nome', '$email', '$via', '$citta', '$provincia', '$cap', '$telefono')";
if (mysqli_query($conn, $sql)) {
echo json_encode(["message" => "Contatto inserito con successo."]);
} else {
echo json_encode(["message" => "Errore durante l'inserimento."]);
}
} else {
echo json_encode(["message" => "Dati obbligatori mancanti."]);
}
break;Facciamo un controllo sul set del cognome e del nome, se sono stati impostati nella richiesta eseguiamo la query di inserimento. Gestiamo eventuali errori di connessione o di mancato inserimento di nome e/o cognome.
La funzione mysqli_real_escape_string() in PHP serve a proteggere i dati ricevuti da input (es. da un form o da una chiamata API) prima di inserirli in una query SQL, per evitare attacchi di tipo SQL Injection. Sanitizziamo (puliamo) le stringhe di input escapando (cioè precedendo con una barra rovesciata \) i caratteri speciali che potrebbero alterare la struttura della query SQL. La funzione intval() converte un valore in un intero (integer). È molto utile (e spesso necessaria) per sanificare valori numerici, in particolare quando provengono da input esterni (es. dati ricevuti da una richiesta HTTP).
Case ‘PUT’
Il metodo put permette di modificare uno o più valori associati ai campi di un record quindi, una volta letto l’id del record da modificare, dobbiamo leggere i valori dei campi da modificare. Inseriamo i nuovi valori in un array ($update), eseguiamo la query di aggiornamento. La funzione implode() in PHP serve a unire gli elementi di un array in una singola stringa, utilizzando un separatore definito dall’utente (nel nostro caso la virgola.
case 'PUT':
if (!empty($input['id'])) {
$id = intval($input['id']);
$updates = [];
foreach (['cognome', 'nome', 'email', 'via', 'citta', 'provincia', 'cap', 'telefono'] as $field) {
if (isset($input[$field])) {
$value = mysqli_real_escape_string($conn, $input[$field]);
$updates[] = "$field = '$value'";
}
}
if (!empty($updates)) {
$sql = "UPDATE utenti SET " . implode(", ", $updates) . " WHERE id = $id";
if (mysqli_query($conn, $sql)) {
echo json_encode(["message" => "Contatto aggiornato con successo."]);
} else {
echo json_encode(["message" => "Errore durante l'aggiornamento."]);
}
} else {
echo json_encode(["message" => "Nessun campo da aggiornare."]);
}
} else {
echo json_encode(["message" => "ID non fornito."]);
}
break;
Case ‘DELETE’
Il metodo DELETE è molto semplice: una volta ottenuto l’id del record da eliminare si procede all’eliminazione:
case 'DELETE':
if (!empty($input['id'])) {
$id = intval($input['id']);
$sql = "DELETE FROM utenti WHERE id = $id";
if (mysqli_query($conn, $sql)) {
echo json_encode(["message" => "Contatto eliminato con successo."]);
} else {
echo json_encode(["message" => "Errore durante l'eliminazione."]);
}
} else {
echo json_encode(["message" => "ID non fornito."]);
}
break;
Chiudiamo lo script con un caso di default (metodo non consentito). Qui di seguito il codice completo di rubrica.php:
<?php
// Header comuni
include 'connessione.php';
include_once 'header.php';
// Ottieni il metodo HTTP
$method = $_SERVER['REQUEST_METHOD'];
// Leggi il corpo della richiesta
$input = json_decode(file_get_contents("php://input"), true);
switch ($method) {
case 'GET':
$sql = "SELECT * FROM utenti";
$result = mysqli_query($conn, $sql);
$rubrica = [];
while ($row = mysqli_fetch_assoc($result)) {
$rubrica[] = $row;
}
echo json_encode(["records" => $rubrica]);
break;
case 'POST':
if (!empty($input['cognome']) && !empty($input['nome'])) {
$cognome = mysqli_real_escape_string($conn, $input['cognome']);
$nome = mysqli_real_escape_string($conn, $input['nome']);
$email = mysqli_real_escape_string($conn, $input['email'] ?? '');
$via = mysqli_real_escape_string($conn, $input['via'] ?? '');
$citta = mysqli_real_escape_string($conn, $input['citta'] ?? '');
$provincia = mysqli_real_escape_string($conn, $input['provincia'] ?? '');
$cap = mysqli_real_escape_string($conn, $input['cap'] ?? '');
$telefono = mysqli_real_escape_string($conn, $input['telefono'] ?? '');
$sql = "INSERT INTO utenti (cognome, nome, email, via, citta, provincia, cap, telefono)
VALUES ('$cognome', '$nome', '$email', '$via', '$citta', '$provincia', '$cap', '$telefono')";
if (mysqli_query($conn, $sql)) {
echo json_encode(["message" => "Contatto inserito con successo."]);
} else {
echo json_encode(["message" => "Errore durante l'inserimento."]);
}
} else {
echo json_encode(["message" => "Dati obbligatori mancanti."]);
}
break;
case 'PUT':
if (!empty($input['id'])) {
$id = intval($input['id']);
$updates = [];
foreach (['cognome', 'nome', 'email', 'via', 'citta', 'provincia', 'cap', 'telefono'] as $field) {
if (isset($input[$field])) {
$value = mysqli_real_escape_string($conn, $input[$field]);
$updates[] = "$field = '$value'";
}
}
if (!empty($updates)) {
$sql = "UPDATE utenti SET " . implode(", ", $updates) . " WHERE id = $id";
if (mysqli_query($conn, $sql)) {
echo json_encode(["message" => "Contatto aggiornato con successo."]);
} else {
echo json_encode(["message" => "Errore durante l'aggiornamento."]);
}
} else {
echo json_encode(["message" => "Nessun campo da aggiornare."]);
}
} else {
echo json_encode(["message" => "ID non fornito."]);
}
break;
case 'DELETE':
if (!empty($input['id'])) {
$id = intval($input['id']);
$sql = "DELETE FROM utenti WHERE id = $id";
if (mysqli_query($conn, $sql)) {
echo json_encode(["message" => "Contatto eliminato con successo."]);
} else {
echo json_encode(["message" => "Errore durante l'eliminazione."]);
}
} else {
echo json_encode(["message" => "ID non fornito."]);
}
break;
default:
http_response_code(405);
echo json_encode(["message" => "Metodo non consentito."]);
break;
}
mysqli_close($conn);
?>Realizzazione del progetto con metodo OOP
Ci proponiamo ora di realizzare il progetto con metodo OOP.
Connessione: La connessione al database sarà gestita dalla classe Database e passata come parametro al costruttore di Rubrica.
Rubrica: La classe Rubrica gestirà tutte le operazioni CRUD (Create, Read, Update, Delete) e le eseguirà tramite metodi della classe.
Routing: Il codice di routing e gestione dei metodi REST (GET, POST, PUT, DELETE) sarà implementato nel file rubrica.php
connessione.php
Definiamo la classe Database con gli attributi utili alla connessione e con il metodo getConnection() che consente la connessione:
<?php
class Database {
private $servername = "localhost";
private $username = "root";
private $password = "";
private $database = "rubrica";
private $conn;
// Connessione al database
public function getConnection() {
$this->conn = new mysqli($this->servername, $this->username, $this->password, $this->database);
if ($this->conn->connect_error) {
die(json_encode(["message" => "Connessione fallita: " . $this->conn->connect_error]));
}
return $this->conn;
}
}
?>
Gli header rimangono invariati. Vediamo come cambia lo script rubrica.php
rubrica.php
importiamo gli script header.php e connessione.php:
<?php
// Includi header comuni
include_once 'header.php';
// Includi il file per la connessione al database
include_once 'connessione.php';
Implementiamo la classe principale definendo gli attributi degli utenti ed il metodo costruttore:
// Classe per la gestione delle operazioni sulla rubrica
class Rubrica {
private $conn;
private $table_name = "utenti";
// Proprietà degli utenti
public $id;
public $cognome;
public $nome;
public $email;
public $via;
public $citta;
public $provincia;
public $cap;
public $telefono;
// Costruttore con connessione
public function __construct($db) {
$this->conn = $db;
}definiamo i metodi per la lettura, scrittura, aggiornamento e cancellazione
// Metodo per leggere tutti gli utenti
public function read() {
$query = "SELECT * FROM " . $this->table_name;
$stmt = $this->conn->query($query);
return $stmt;
}
// Metodo per creare un nuovo utente
public function create() {
$query = "INSERT INTO " . $this->table_name . "
(cognome, nome, email, via, citta, provincia, cap, telefono)
VALUES (?, ?, ?, ?, ?, ?, ?, ?)";
$stmt = $this->conn->prepare($query);
$stmt->bind_param("ssssssss", $this->cognome, $this->nome, $this->email, $this->via,
$this->citta, $this->provincia, $this->cap, $this->telefono);
if ($stmt->execute()) {
return true;
}
return false;
}
// Metodo per aggiornare un utente
public function update() {
$query = "UPDATE " . $this->table_name . "
SET cognome = ?, nome = ?, email = ?, via = ?, citta = ?, provincia = ?, cap = ?, telefono = ?
WHERE id = ?";
$stmt = $this->conn->prepare($query);
$stmt->bind_param("ssssssssi", $this->cognome, $this->nome, $this->email, $this->via,
$this->citta, $this->provincia, $this->cap, $this->telefono, $this->id);
if ($stmt->execute()) {
return true;
}
return false;
}
// Metodo per eliminare un utente
public function delete() {
$query = "DELETE FROM " . $this->table_name . " WHERE id = ?";
$stmt = $this->conn->prepare($query);
$stmt->bind_param("i", $this->id);
if ($stmt->execute()) {
return true;
}
return false;
}
}Adesso serve creare un’istanza di connessione, creare un’istanza di rubrica e ottenere il metodo richiesto dal client:
// Creazione connessione
$database = new Database();
$db = $database->getConnection();
// Creazione istanza della classe Rubrica
$rubrica = new Rubrica($db);
// Ottieni il metodo della richiesta
$method = $_SERVER['REQUEST_METHOD'];
// Decodifica il contenuto JSON
$data = json_decode(file_get_contents("php://input"), true);Infine definiamo il routing per i quattro metodi utilizzando uno switch-case.
Se il metodo è GET, richiamiamo la funzione read(), eseguiamo quindi la query e, finchè sono presenti righe, memorizziamo tutti i dati in un array $utenti, All’interno dell’array $utenti, viene creato un sotto-array associativo chiamato "records" che conterrà ogni riga utente come array associativo. Ogni $row viene aggiunto (push) all’interno dell’array "records" all’interno di $utenti.
In pratica si costruisce un array del tipo:
Copied!$utenti = [ "records" => [ ["id" => 1, "nome" => "Mario", "cognome" => "Rossi", …], ["id" => 2, "nome" => "Luigi", "cognome" => "Verdi", …], … ] ];
// Routing per i metodi REST
switch ($method) {
case 'GET':
$stmt = $rubrica->read();
if ($stmt->num_rows > 0) {
$utenti = array();
$utenti["records"] = array();
while ($row = $stmt->fetch_assoc()) {
$utenti["records"][] = $row;
}
echo json_encode($utenti);
} else {
echo json_encode(["message" => "Nessun utente trovato."]);
}
break;
Analogamente scriviamo il routing per gli altri metodi:
case 'POST':
if (!empty($data["cognome"]) && !empty($data["nome"])) {
$rubrica->cognome = $data["cognome"];
$rubrica->nome = $data["nome"];
$rubrica->email = $data["email"] ?? '';
$rubrica->via = $data["via"] ?? '';
$rubrica->citta = $data["citta"] ?? '';
$rubrica->provincia = $data["provincia"] ?? '';
$rubrica->cap = $data["cap"] ?? '';
$rubrica->telefono = $data["telefono"] ?? '';
if ($rubrica->create()) {
echo json_encode(["message" => "Utente inserito con successo."]);
} else {
echo json_encode(["message" => "Errore durante l'inserimento."]);
}
} else {
echo json_encode(["message" => "Dati incompleti."]);
}
break;
case 'PUT':
if (!empty($data["id"])) {
$rubrica->id = $data["id"];
$rubrica->cognome = $data["cognome"] ?? '';
$rubrica->nome = $data["nome"] ?? '';
$rubrica->email = $data["email"] ?? '';
$rubrica->via = $data["via"] ?? '';
$rubrica->citta = $data["citta"] ?? '';
$rubrica->provincia = $data["provincia"] ?? '';
$rubrica->cap = $data["cap"] ?? '';
$rubrica->telefono = $data["telefono"] ?? '';
if ($rubrica->update()) {
echo json_encode(["message" => "Utente aggiornato con successo."]);
} else {
echo json_encode(["message" => "Errore durante l'aggiornamento."]);
}
} else {
echo json_encode(["message" => "ID non specificato."]);
}
break;
case 'DELETE':
if (!empty($data["id"])) {
$rubrica->id = $data["id"];
if ($rubrica->delete()) {
echo json_encode(["message" => "Utente eliminato con successo."]);
} else {
echo json_encode(["message" => "Errore durante l'eliminazione."]);
}
} else {
echo json_encode(["message" => "ID non specificato."]);
}
break;
default:
http_response_code(405);
echo json_encode(["message" => "Metodo non consentito."]);
break;
}
?>Qui di seguito il codice completo di rubrica.php
<?php
// Includi header comuni
include_once 'header.php';
// Includi il file per la connessione al database
include_once 'connessione.php';
// Classe per la gestione delle operazioni sulla rubrica
class Rubrica {
private $conn;
private $table_name = "utenti";
// Proprietà degli utenti
public $id;
public $cognome;
public $nome;
public $email;
public $via;
public $citta;
public $provincia;
public $cap;
public $telefono;
// Costruttore con connessione
public function __construct($db) {
$this->conn = $db;
}
// Metodo per leggere tutti gli utenti
public function read() {
$query = "SELECT * FROM " . $this->table_name;
$stmt = $this->conn->query($query);
return $stmt;
}
// Metodo per creare un nuovo utente
public function create() {
$query = "INSERT INTO " . $this->table_name . "
(cognome, nome, email, via, citta, provincia, cap, telefono)
VALUES (?, ?, ?, ?, ?, ?, ?, ?)";
$stmt = $this->conn->prepare($query);
$stmt->bind_param("ssssssss", $this->cognome, $this->nome, $this->email, $this->via,
$this->citta, $this->provincia, $this->cap, $this->telefono);
if ($stmt->execute()) {
return true;
}
return false;
}
// Metodo per aggiornare un utente
public function update() {
$query = "UPDATE " . $this->table_name . "
SET cognome = ?, nome = ?, email = ?, via = ?, citta = ?, provincia = ?, cap = ?, telefono = ?
WHERE id = ?";
$stmt = $this->conn->prepare($query);
$stmt->bind_param("ssssssssi", $this->cognome, $this->nome, $this->email, $this->via,
$this->citta, $this->provincia, $this->cap, $this->telefono, $this->id);
if ($stmt->execute()) {
return true;
}
return false;
}
// Metodo per eliminare un utente
public function delete() {
$query = "DELETE FROM " . $this->table_name . " WHERE id = ?";
$stmt = $this->conn->prepare($query);
$stmt->bind_param("i", $this->id);
if ($stmt->execute()) {
return true;
}
return false;
}
}
// Creazione connessione
$database = new Database();
$db = $database->getConnection();
// Creazione istanza della classe Rubrica
$rubrica = new Rubrica($db);
// Ottieni il metodo della richiesta
$method = $_SERVER['REQUEST_METHOD'];
// Decodifica il contenuto JSON
$data = json_decode(file_get_contents("php://input"), true);
// Routing per i metodi REST
switch ($method) {
case 'GET':
$stmt = $rubrica->read();
if ($stmt->num_rows > 0) {
$utenti = array();
$utenti["records"] = array();
while ($row = $stmt->fetch_assoc()) {
$utenti["records"][] = $row;
}
echo json_encode($utenti);
} else {
echo json_encode(["message" => "Nessun utente trovato."]);
}
break;
case 'POST':
if (!empty($data["cognome"]) && !empty($data["nome"])) {
$rubrica->cognome = $data["cognome"];
$rubrica->nome = $data["nome"];
$rubrica->email = $data["email"] ?? '';
$rubrica->via = $data["via"] ?? '';
$rubrica->citta = $data["citta"] ?? '';
$rubrica->provincia = $data["provincia"] ?? '';
$rubrica->cap = $data["cap"] ?? '';
$rubrica->telefono = $data["telefono"] ?? '';
if ($rubrica->create()) {
echo json_encode(["message" => "Utente inserito con successo."]);
} else {
echo json_encode(["message" => "Errore durante l'inserimento."]);
}
} else {
echo json_encode(["message" => "Dati incompleti."]);
}
break;
case 'PUT':
if (!empty($data["id"])) {
$rubrica->id = $data["id"];
$rubrica->cognome = $data["cognome"] ?? '';
$rubrica->nome = $data["nome"] ?? '';
$rubrica->email = $data["email"] ?? '';
$rubrica->via = $data["via"] ?? '';
$rubrica->citta = $data["citta"] ?? '';
$rubrica->provincia = $data["provincia"] ?? '';
$rubrica->cap = $data["cap"] ?? '';
$rubrica->telefono = $data["telefono"] ?? '';
if ($rubrica->update()) {
echo json_encode(["message" => "Utente aggiornato con successo."]);
} else {
echo json_encode(["message" => "Errore durante l'aggiornamento."]);
}
} else {
echo json_encode(["message" => "ID non specificato."]);
}
break;
case 'DELETE':
if (!empty($data["id"])) {
$rubrica->id = $data["id"];
if ($rubrica->delete()) {
echo json_encode(["message" => "Utente eliminato con successo."]);
} else {
echo json_encode(["message" => "Errore durante l'eliminazione."]);
}
} else {
echo json_encode(["message" => "ID non specificato."]);
}
break;
default:
http_response_code(405);
echo json_encode(["message" => "Metodo non consentito."]);
break;
}
?>Test dei Metodi CRUD con Postman o Thunder Client
Per testare il nostro Servizio dobbiamo verificare che i metodi Create, Read, Update e Delete funzionino correttamente. Per fare ciò abbiamo diversi tool a disposizione. Il primo è una estensione di VSC (Thunder Client). Se si vuole testare questo tool occorre installare questa estensione:
In alternativa possiamo scaricare ed installare il tool Postman al seguente link: https://www.postman.com/downloads
Adesso proviamo i metodi:
Lettura (GET, Read)
-
Endpoint:
GET localhost/test/WebServicePHP_procedurale/rubrica.php - Risultato atteso: Lista di utenti.
Cliccare l’icona Thunder in VSC e cliccare “new request”. Selezionare il metodo GET e digitare l’endpoint accanto al metodo. Clicchiamo su “SEND” e otteniamo:
Creazione (POST, Create)
-
Endpoint:
POST localhost/test/WebServicePHP_procedurale/rubrica.php - Body JSON:
{
"cognome": "Test",
"nome": "Test",
"email": "Test",
"via": "Test",
"citta": "Test",
"provincia": "Test",
"cap": "Test",
"telefono": "Test"
}Quindi selezionare POST, non modificare l’endpoint e inserire un nuovo utente digitando nel body quanto indicato nel codice in alto. Cliccare su “SEND”.
Nel mio caso è stato inserito il nuovo utente con id=14:
Aggiornamento (PUT/PATCH, Update)
- PUT (modifica)
-
Endpoint:
localhost/test/WebServicePHP_procedurale/rubrica.php
Modifichiamo, ad esempio, il nome del record con id = 14. Scegliamo PUT, scriviamo l’endpoint e nel body scriviamo:
{
"id": "14",
"cognome": "Giagnotti",
"nome": "Mario"
}Cliccando SEND vediamo la modifica:
Eliminazione (DELETE)
-
Endpoint:
DELETE localhost/test/WebServicePHP_procedurale/rubrica.php - Risultato atteso: Utente eliminato.
Proviamo ad eliminare l’utente con id = 14. Scegliere il metodo DELETE, scrivere l’endpoint e nel body scrivere:
{
"id": "14"
}Cliccare su SEND. Se tutto è andato a buon fine dovreste visualizzare:
Postman
Il test dell’API REST appena creata può essere eseguito allo stesso modo anche attraverso l’applicazione Postman. Ricordare di selezionare “row” per inserire il testo nel body
Si lascia al lettore il test dell’applicazione con metodo OOP magari utilizzando POSTMAN
Il codice può essere scaricato qui:
WebService API REST in PHP (25 download )oppure dalla sezione DOWNLOAD: https://profgiagnotti.it/download_page/download-tps/download-tps-quinto-anno/
Lascia un commento