Di seguito un esempio di implementazione di un sistema RESTful API in PHP per la registrazione di un utente.
- Codice PHP
- Esempio di chiamata AJAX da sito web
- Esempio di implementazione da app Android
- Controllo delle origini incrociate (CORS)
- Un po’ di teoria
Per prima cosa, creiamo una tabella “users” in un database MySQL che contiene i campi “id”, “username” e “password”.
CREATE TABLE User (
id INT NOT NULL AUTO_INCREMENT,
name VARCHAR(255) NOT NULL,
email VARCHAR(255) NOT NULL,
password VARCHAR(255) NOT NULL,
PRIMARY KEY (id)
);
Il nostro obiettivo, ora, è quello di creare un’ API che consenta a un utente di registrarsi con una richiesta POST contenente un username e una password. Il primo passo è quello di creare un file chiamato “register.php” che gestisce le richieste di registrazione e restituirà i risultati in formato JSON.
Supponiamo di avere una tabella “users” in un database MySQL che contiene i campi “id”, “username” e “password”. Il nostro obiettivo è quello di creare un’API che consenta a un utente di registrarsi con una richiesta POST contenente un username e una password.
Il primo passo è quello di creare un file chiamato “register.php” che gestirà le richieste di registrazione e restituirà i risultati in formato JSON.
Codice PHP
<?php
// Connessione al database
$servername = "localhost";
$username = "username";
$password = "password";
$dbname = "database_name";
$conn = new mysqli($servername, $username, $password, $dbname);
// Controllo degli errori di connessione
if ($conn->connect_error) {
die("Connection failed: " . $conn->connect_error);
}
// Verifica che la richiesta sia stata effettuata tramite metodo POST
if ($_SERVER["REQUEST_METHOD"] == "POST") {
// Verifica che i dati siano stati inviati correttamente
if (isset($_POST["username"]) && isset($_POST["password"])) {
$username = $_POST["username"];
$password = $_POST["password"];
// Controllo che l'username non sia già presente nel database
$query = "SELECT id FROM users WHERE username = '$username'";
$result = $conn->query($query);
if ($result->num_rows > 0) {
// Username già presente
http_response_code(400);
echo json_encode(array("message" => "Username già presente nel database."));
} else {
// Username non presente, procedo con la registrazione
$query = "INSERT INTO users (username, password) VALUES ('$username', '$password')";
if ($conn->query($query) === TRUE) {
// Registrazione effettuata con successo
http_response_code(201);
echo json_encode(array("message" => "Registrazione effettuata con successo."));
} else {
// Errore durante la registrazione
http_response_code(500);
echo json_encode(array("message" => "Errore durante la registrazione."));
}
}
} else {
// Dati non inviati correttamente
http_response_code(400);
echo json_encode(array("message" => "Dati non inviati correttamente."));
}
} else {
// Metodo non consentito
http_response_code(405);
echo json_encode(array("message" => "Metodo non consentito."));
}
// Chiudo la connessione al database
$conn->close();
In questo esempio, il codice PHP verifica che la richiesta sia stata effettuata tramite metodo POST e che siano stati inviati i dati “username” e “password”. Successivamente, viene effettuata una query per verificare che l’username non sia già presente nel database. Se l’username non è presente, viene effettuata una query per inserire l’utente nel database. In caso contrario, viene restituito un messaggio di errore. Infine, la risposta viene restituita in formato JSON con il corretto codice di stato HTTP.
Chiamata AJAX da sito web al sistema RESTful API in PHP
Supponiamo di avere un modulo di registrazione in un file HTML chiamato “register.html” che contiene un campo “username” e un campo “password”. Utilizziamo jQuery per effettuare la chiamata AJAX al nostro sistema RESTful API come nel seguente esempio:
<!DOCTYPE html>
<html>
<head>
<title>Registrazione utente</title>
</head>
<body>
<h1>Registrazione utente</h1>
<form id="register-form">
<label for="username">Username:</label>
<input type="text" id="username" name="username" required>
<label for="password">Password:</label>
<input type="password" id="password" name="password" required>
<button type="submit">Registrati</button>
</form>
<script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
<script>
$(document).ready(function() {
$('#register-form').submit(function(event) {
event.preventDefault();
// Prendo i dati dal form
var username = $('#username').val();
var password = $('#password').val();
// Effettuo la chiamata AJAX
$.ajax({
url: 'http://localhost/register.php',
type: 'POST',
dataType: 'json',
data: {
username: username,
password: password
},
success: function(data) {
// Registrazione effettuata con successo
alert(data.message);
},
error: function(xhr, status, error) {
// Errore durante la registrazione
alert(xhr.responseJSON.message);
}
});
});
});
</script>
</body>
</html>
In questo esempio, quando l’utente invia il modulo di registrazione, viene effettuata una chiamata AJAX tramite jQuery al nostro sistema RESTful API in PHP, passiamo l’username e la password come dati nella richiesta POST. Se la registrazione ha successo, viene mostrato un messaggio di successo. In caso contrario, viene mostrato un messaggio di errore.
Utilizzo da un’applicazione Android del sistema RESTful API in PHP
Supponiamo che l’applicazione Android abbia un’interfaccia di registrazione con due campi di input per l’username e la password, e un pulsante di registrazione. Quando l’utente preme il pulsante, l’applicazione Android invia una richiesta HTTP POST al nostro sistema RESTful API in PHP.
private void registerUser(final String username, final String password) {
String url = "http://localhost/register.php";
StringRequest stringRequest = new StringRequest(Request.Method.POST, url,
new Response.Listener<String>() {
@Override
public void onResponse(String response) {
// Registrazione effettuata con successo
Toast.makeText(getApplicationContext(), "Registrazione effettuata con successo", Toast.LENGTH_SHORT).show();
}
},
new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
// Errore durante la registrazione
Toast.makeText(getApplicationContext(), "Errore durante la registrazione: " + error.getMessage(), Toast.LENGTH_SHORT).show();
}
})
{
@Override
protected Map<String, String> getParams() throws AuthFailureError {
Map<String, String> params = new HashMap<>();
params.put("username", username);
params.put("password", password);
return params;
}
};
RequestQueue requestQueue = Volley.newRequestQueue(this);
requestQueue.add(stringRequest);
}
In questo esempio, la chiamata HTTP POST è effettuata tramite la libreria Volley di Android. L’URL della nostra API RESTful e i dati di input (username e password) sono passati al costruttore di StringRequest. Inoltre, è definito il comportamento in caso di risposta positiva (onResponse) o di errore (onErrorResponse).
Successivamente, la richiesta è aggiunta alla coda delle richieste di Volley utilizzando un’istanza di RequestQueue.
Nota che per utilizzare Volley devi aggiungere la dipendenza alla libreria nel file build.gradle della tua applicazione Android:
dependencies {
implementation 'com.android.volley:volley:1.2.1'
}
Controllo delle origini incrociate (CORS)
Assicurati di includere il controllo delle origini incrociate (CORS) per consentire alle richieste provenienti dall’applicazione Android di accedere alla tua API RESTful.
<?php
// Abilita il CORS per tutte le origini
header("Access-Control-Allow-Origin: *");
// Imposta l'intestazione Access-Control-Allow-Methods per specificare i metodi HTTP consentiti
header("Access-Control-Allow-Methods: GET, POST, PUT, DELETE");
// Imposta l'intestazione Access-Control-Allow-Headers per specificare le intestazioni HTTP personalizzate consentite
header("Access-Control-Allow-Headers: Content-Type");
Questo è un esempio semplificato, va pensata anche ad un’adeguata struttura degli Endpoint:
| Endpoint | Metodo HTTP | Descrizione |
|---|---|---|
| /auth/login | POST | Effettua il login dell’utente |
| /auth/register | POST | Effettua la registrazione dell’utente |
| /auth/logout | DELETE | Effettua il logout dell’utente |
Un po’ di teoria
Infine un pochino di teoria:
Il termine “RESTful API” indica a un tipo di architettura software utilizzata per la creazione di servizi web. REST, che significa “Representational State Transfer” (trasferimento dello stato rappresentativo), è un insieme di principi e vincoli per la progettazione di tali servizi web.
In un sistema RESTful, le risorse sono definite come entità identificabili (come ad esempio i dati di un database) a cui si può accedere tramite una specifica URL. Le richieste da parte dei client per accedere a tali risorse sono effettuate utilizzando i metodi HTTP standard (GET, POST, PUT, DELETE, ecc.) e le risposte sono restituite in formato JSON o XML.
Il sistema RESTful API, quindi, è un tipo di architettura software che consente ai client di accedere alle risorse di un’applicazione web in modo semplice e flessibile, senza dover utilizzare protocolli o formati di dati specifici. È molto popolare per la creazione di servizi web, soprattutto in ambienti distribuiti e scalabili come quelli delle applicazioni cloud.
