Sviluppo Web Avanzato :: Diario del corso

Diario delle Lezioni - A.A. 2023/2024

Lezioni totali: 12, ore erogate: 24 (100%) - Prima lezione: 01/03/2024, Ultima lezione: 31/05/2024

Lezione 1: Introduzione ai (RESTful) web services

01/03/2024, ore 11:30 (2 ore)
Slides WS-Rest

(1-1)

Presentazione del corso
(1-2)

Perché i servizi (web) sono un modo efficace di sviluppare software
(1-3)

La storia dei servizi (web) distribuiti: dalla RPC al RESTful
(1-4)

Presentazione degli argomenti: RESTful web services
(1-5)

Esempio I servizi RESTful come estensione delle applicazioni web standard
(1-6)

Esempio I servizi RESTful come elemento base delle applicazioni fortemente client side come le SPA (Angular, React, ecc.)
(1-7)

Esempio I servizi RESTful come elemento base delle applicazioni mobili ibride (Cordova, ecc.)
(1-8)

Presentazione degli argomenti: progettazione di servizi RESTful
(1-9)

Presentazione degli argomenti: implementazione di servizi RESTful (Java, PHP)
(1-10)

Presentazione degli argomenti: implementazione di client RESTful (Java, PHP, Javascript)
(1-11)

I Web services nel Web 2.0
(1-12)

Cosa sono i web services veramente?
(1-13)

Che ruolo giocano i web services nel web 2.0?
(1-14)

Esempio Analisi di servizi pubblicati su web dalla PA
(1-15)

Esempio Un esempio di veri web services: Amazon

Lezione 2: La semantica dei servizi RESTful 1

08/03/2024, ore 11:30 (2 ore)
Slides Restful

(2-1)

Esempio Realizzare i servizi della PA come veri web services
(2-2)

I servizi web RESTful: quando usarli, e quali alternative esistono
(2-3)

Il paradigma REST
(2-4)

I servizi web con paradigma REST: RESTful web services
(2-5)

Caratteristiche di base di un servizio RESTful: protocolli, formati, metodi
(2-6)

Semantica di un servizio web RESTful: a quali tipi di applicazione si adatta meglio?
(2-7)

Struttura delle URL in un servizio RESTful
(2-8)

Mappare le risorse sulle URL: la struttura di base collection-item
(2-9)

Esempio Mappare strutture relazionali su URL RESTful
(2-10)

Operazioni CRUD via RESTful: il metodo GET
link https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/GET
(2-11)

Esempio GET su collezioni: SELECT
(2-12)

Esempio GET su collezioni con query string: SELECT * WHERE
(2-13)

La codifica dei dati restituiti da una GET e gli header Accept/Content-Type
(2-14)

Il valore di ritorno delle GET su collezioni: lista di record o di sole chiavi?
(2-15)

Esempio GET su collezioni: usare la query string per simulare la clausola LIMIT
(2-16)

Esempio GET su item: SELECT * WHERE id=...
(2-17)

Esempio GET su attributi: SELECT a WHERE id=...
(2-18)

GET: stati HTTP di ritorno
link https://developer.mozilla.org/en-US/docs/Web/HTTP/Status
(2-19)

Operazioni CRUD via RESTful: il metodo PUT
link https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT
(2-20)

Esempio PUT su item: UPDATE globale su uno specifico record
(2-21)

Il payload del metodo PUT e l'header Content-Type
(2-22)

Esempio PUT su attributi: UPDATE di singoli attributi in uno specifico record
(2-23)

Esempio PUT su collezioni: sostituzione di un'intera collezione
(2-24)

PUT: stati HTTP di ritorno
(2-25)

Operazioni CRUD via RESTful: il metodo PATCH
link https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH
(2-26)

Esempio PATCH su item: UPDATE parziale su uno specifico record
(2-27)

Estensione della semantica PUT in ambienti che non supportano la PATCH

Lezione 3: La semantica dei servizi RESTful 2

15/03/2024, ore 11:30 (2 ore)
Slides Restful

(3-1)

Operazioni CRUD via RESTful: il metodo POST
link https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST
(3-2)

Esempio POST su collezioni: INSERT di un nuovo record
(3-3)

Il payload del metodo POST e l'header Content-Type
(3-4)

POST: stati HTTP e valori di ritorno
(3-5)

Operazioni CRUD via RESTful: il metodo DELETE
link https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/DELETE
(3-6)

Esempio DELETE su item: DELETE di un record specifico
(3-7)

Esempio DELETE su collezioni: svuotamento di una tabella
(3-8)

DELETE: stati HTTP di ritorno
(3-9)

Altri metodi HTTP: HEAD, OPTIONS
link https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/HEAD
link https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/OPTIONS
(3-10)

Esempio HEAD su risorsa: controllo dei metadati
(3-11)

Esempio HEAD usato per il caching delle risorse
(3-12)

Esempio OPTIONS su risorsa: controllo sui metodi supportati
(3-13)

Il problema della same-origin-policy per i servizi
link https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy
(3-14)

Permettere l'accesso ai propri servizi RESTful dall'esterno (del loro dominio): CORS
link https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS
(3-15)

OPTIONS e CORS: la preflight delle risorse
link https://developer.mozilla.org/en-US/docs/Glossary/Preflight_request
(3-16)

Operazioni di tipo RMI via RESTful
(3-17)

Specificare un oggetto (contesto) e un metodo da invocare tramite una URL
(3-18)

Esempio Il metodo POST utilizzato per effettuare una RMI
(3-19)

Codifica dei parametri e del valore di ritorno di un metodo invocato tramite POST
(3-20)

Payload e risultato del metodo POST: header Accept e Content-Type
(3-21)

POST per RMI: stati HTTP di ritorno
(3-22)

Esempio Operazioni di tipo RMI via RESTful: usare GET per metodi di lettura (attributi calcolati)
(3-23)

Esempio Usare il metodo POST come alternativa alla GET su collezione per definire filtri complessi
(3-24)

Esempio Un pattern avanzato per le API RESTful: l'asynchronous long running operation
link http://restalk-patterns.org/long-running-operation-polling.html
link https://learn.microsoft.com/en-us/azure/architecture/patterns/async-request-reply

Lezione 4: La sicurezza nei servizi RESTful

22/03/2024, ore 11:30 (2 ore)

(4-1)

Sicurezza nelle API RESTful
(4-2)

Il ruolo del token di accesso nella sicurezza delle API
(4-3)

Come scambiarsi il token di accesso: dai metodi rudimentali (query string, path) alla Bearer Authorization
link https://datatracker.ietf.org/doc/html/rfc7519
(4-4)

Gestire la scadenza e il refresh dei token di accesso
(4-5)

Generare i token di accesso: schemi di autenticazione
(4-6)

Esempio Realizzare la tecnica del login/logout in un servizio RESTful
(4-7)

OAuth: un sistema di autenticazione particolarmente adatto ai servizi
link https://datatracker.ietf.org/doc/html/rfc6749
link https://datatracker.ietf.org/doc/html/rfc6750
link https://oauth.net/2
(4-8)

Il flusso di autorizzazione OAuth 2
(4-9)

I vantaggi di OAuth: nessuna memorizzazione delle credenziali e codici di autorizzazione con contesto
(4-10)

Esempio OAuth nel mondo reale
link https://learn.microsoft.com/en-us/azure/active-directory/develop/v2-oauth2-auth-code-flow
(4-11)

Esempio Il caso di studio events
materiale REST_Specs

Lezione 5: Progettazione di un servizio RESTful

05/04/2024, ore 11:30 (2 ore)

(5-1)

Definire le strutture JSON necessarie a un servizio (o ereditarle da codice!)
(5-2)

Identificare il pattern collection-item all'interno delle API
(5-3)

Definire una struttura di URL coerente con le API
(5-4)

Fuori dal pattern: quando violare la semantica standard RESTful ci aiuta a essere più efficienti
(5-5)

Mappare metodi e payload sulle URL
(5-6)

Gestire i binari in maniera corretta ed efficace
(5-7)

Esempio La RESTful API per il caso di studio events
materiale REST_Specs_RESTful
(5-8)

Introduzione a JSON Schema

Lezione 6: JSON Schema

12/04/2024, ore 11:30 (2 ore)
Slides JSONSchema

(6-1)

JSON Schema: struttura base e annotazioni
link https://json-schema.org/specification.html
(6-2)

JSON Schema: significato della schema vuoto e tecnica della modellazione per restrizioni
(6-3)

JSON Schema: i tipi di dato
(6-4)

JSON Schema: tipo stringa e relativi vincoli
(6-5)

JSON Schema: tipi numerici e relativi vincoli
(6-6)

JSON Schema: tipo oggetto e specifica delle proprietà
(6-7)

JSON Schema: vincoli del tipo oggetto
(6-8)

JSON Schema: tipo array e relativi vincoli
(6-9)

JSON Schema: enumerazioni
(6-10)

JSON Schema: composizione di schemi (allOf, anyOf, oneOf, not)
(6-11)

JSON Schema: riferimenti a schemi e modularizzazione (proprietà $ref)
(6-12)

Esempio La struttura dati evento definita con JSON Schema
materiale Event_Object.json
materiale Event_Object_Schema.json
(6-13)

Il (meta) linguaggio YAML
link https://yaml.org/spec
(6-14)

Relazioni tra YAML e JSON
(6-15)

La sintassi YAML: scalari, oggetti e array

Lezione 7: OpenAPI /1

19/04/2024, ore 11:30 (2 ore)
Slides OpenAPI

(7-1)

Presentazione di OpenAPI 3
(7-2)

Tool e specifiche OpenAPI reperibili online
link https://www.openapis.org/
link https://swagger.io/tools/open-source/
(7-3)

OpenAPI: struttura di base
(7-4)

OpenAPI: oggetto info
(7-5)

OpenAPI: oggetto tags
(7-6)

OpenAPI: oggetto externalDocs
(7-7)

OpenAPI: servers
(7-8)

OpenAPI: fattorizzazione della specifica e oggetto components
(7-9)

OpenAPI: componenti di tipo schema
(7-10)

OpenAPI: componenti di tipo parameter
(7-11)

OpenAPI: componenti di tipo response
(7-12)

Esempio La specifica del servizio RESTful events con OpenAPI 3: struttura base, schemi, parametri e risposte

Lezione 8: OpenAPI /2

03/05/2024, ore 11:30 (2 ore)
Slides OpenAPI

(8-1)

OpenAPI: componenti di tipo requestBody
(8-2)

OpenAPI: componenti di tipo securityScheme
(8-3)

OpenAPI: specificare gli endpoint: struttura di base dell'oggetto paths
(8-4)

OpenAPI: definire URL parametriche nell'oggetto paths
(8-5)

OpenAPI: definire i parametri di un endpoint (parameters)
(8-6)

Parametri di livello path e metodo
(8-7)

OpenAPI: definire i possibili stati di risposta e associare il realtivo contenuto (responses)
(8-8)

OpenAPI: definire il contenuto delle richieste (requestBody)
(8-9)

OpenAPI: definire i requisiti di sicurezza di un endpoint (security)
(8-10)

Esempio La specifica del servizio RESTful events con OpenAPI 3
materiale Event_OpenAPI.yaml
(8-11)

Sviluppo di progetti RESTful con JAX-RS
link https://eclipse-ee4j.github.io/jersey/
(8-12)

Dipendenze JAX-RS in un progetto di web application con Maven
(8-13)

Configurare Jackson come provider per JAX-RS
link https://github.com/FasterXML/jackson-jaxrs-providers

Lezione 9: JAX-RS /1

10/05/2024, ore 11:30 (2 ore)
Materiale JAXRS_Examples

(9-1)

Esempio Creare una nuova applicazione server JAX-RS
materiale JAXRS_Base_T10
(9-2)

Esempio Adattare il progetto di base per eseguirlo su JavaEE/Tomcat 9
materiale JAXRS_Base_T9
(9-3)

Configurare JAX-RS con le risorse e i provider necessari: la classe Application e l'annotazione @ApplicationPath
(9-4)

Marcare le classi come risorse (root) RESTful: l'annotazione @Path
(9-5)

Marcare i metodi di una classe per rispondere ai metodi HTTP: l'annotazione @GET
(9-6)

Identificare il tipo RESTful di output di un metodo: l'annotazione @Produces
(9-7)

Tipi restituibili da JAX-RS e conversione automatica di tipo
(9-8)

Restituire tipo complessi con codifica automatica JSON: liste, mappe, oggetti
(9-9)

Oggetti Java (de)codificabili in JSON: caratteristiche richieste
(9-10)

L'annotazione @JsonIgnore per escludere campi dall'ouput
(9-11)

Creare (de)serializzatori custom avanzati
(9-12)

Esempio Creare un (de)serializzatore custom per la class Java Calendar
(9-13)

Usare la classe Response per costruire le risposte RESTful
(9-14)

Restituire codici di stato e costruire risposte complesse con la classe Response
(9-15)

Gestire e incapsulare le eccezioni: la classe WebApplicationException
(9-16)

Gestire le eccezioni: la classe ExceptionMapper
(9-17)

Iniettare un parametro di query in quelli di un metodo con l'annotazione @QueryParam
(9-18)

Uso dell'annotazione @Path sui metodi per identificare sotto-risorse
(9-19)

Uso dell'annotazione @Path con parti parametriche
(9-20)

Iniettare un parametro della URL in quelli di un metodo con l'annotazione @PathParam

Lezione 10: JAX-RS /2

17/05/2024, ore 11:30 (2 ore)
Materiale JAXRS_Examples

(10-1)

Restituire un binario da scaricare
(10-2)

Restituire uno stream: StreamingOutput
(10-3)

Implementazione dei metodi REST: l'annotazione @POST
(10-4)

Identificare il tipo RESTful di input di un metodo: l'annotazione @Consumes
(10-5)

Iniettare il payload di una richiesta in un metodo
(10-6)

Tipi di dati accettabili come payload: stringhe, numeri, InputStream
(10-7)

Decodifica automatica di Java bean dal payload JSON
(10-8)

Usare la classe UriInfo per generare URI di risorse REST interne all'applicazione
(10-9)

Implementazione dei metodi REST: l'annotazione @PUT
(10-10)

Implementazione dei metodi REST: l'annotazione @DELETE
(10-11)

Riassunto delle tecniche utilizzabili con JAX-RS in una singola classe-risorsa
(10-12)

Esempio Il servizio RESTful events realizzato con JAX-RS
materiale JAXRS_Example_Events
(10-13)

Un pattern di sviluppo per i servizi RESTful: le sotto-risorse
(10-14)

Definire e restituire una sotto risorsa REST con l'annotazione @Path
(10-15)

Progettazione RESTful con JAX-RS: quando e come utilizzare le sotto-risorse?
(10-16)

Definire annotazioni associate alla sicurezza/autenticazione in JAX-RS
(10-17)

Limitare l'accesso a un metodo RESTful con un'annotazione di autenticazione
(10-18)

Scrivere un filtro di autenticazione in JAX-RS
(10-19)

Iniettare le informazioni sull'utente autenticato in un metodo RESTful

Lezione 11: Implementazione dei servizi RESTful e best practices

30/05/2024, ore 09:30 (2 ore)

(11-1)

Autenticazione in un'API RESTful: come restituire un token di autenticazione (header authentication, cookie o semplice payload
(11-2)

Inserire gli header CORS e gestire le richieste di preflight con un filtro
(11-3)

RESTful in PHP con il framework Slim
(11-4)

Esempio Un semplice servizio RESTful realizzato con Slim in PHP
materiale PHP_Example_Fattura
(11-5)

RESTful in PHP con il framework Slim
(11-6)

Oltre il RESTful: cenni su gRPC, Protobuf, GraphQL...
link https://grpc.io/
link https://protobuf.dev/
link https://graphql.org/
(11-7)

Best practices RESTful: le regole del corretto design linguistico
link https://doi.org/10.1109/SCC55611.2022.00017
(11-8)

Errori RESTful comuni: Over e under fetching, N+1 request problem, scarsa type safety
(11-9)

Sviluppo di client per servizi RESTful

Lezione 12: Client RESTful

31/05/2024, ore 11:30 (2 ore)

(12-1)

Client RESTful in Java con la libreria Apache HTTPComponents Client
(12-2)

Esempio Un client Java per il servizio RESTful events
materiale EventsREST_Client_Java
(12-3)

Client RESTful in PHP con la libreria HTTPful
(12-4)

Esempio Un client PHP per un semplice servizio RESTful
materiale PHP_Fattura_Client
(12-5)

Client RESTful in Javascript con l'oggetto XMLHttpRequest (AJAX)
(12-6)

Chiamate RESTful sincrone e asincrone
(12-7)

Esempio Un client Javascript per il servizio RESTful events: client XHR
materiale EventsREST_Client_JS
(12-8)

Client RESTful in Javascript con le Fetch API
link https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API
(12-9)

Esempio Un client Javascript per il servizio RESTful events: client Fetch
materiale EventsREST_Client_JS
(12-10)

Introduzione a JQuery
link https://jquery.com/
(12-11)

Quando usare JQuery in un progetto web?
(12-12)

La funzione $ e i modi per utilizzarla
(12-13)

Wrapping del DOM in oggetti JQuery
(12-14)

Selezionare elementi con JQuery: selettori CSS3 e funzioni di attraversamento
(12-15)

Attraversamento del DOM con JQuery
(12-16)

Le funzioni di manipolazione DOM in JQuery
(12-17)

Modifica del DOM con JQuery
(12-18)

Modifica degli stili CSS con JQuery
(12-19)

Event handling in JQuery: binding (in fase bubbling)
(12-20)

Event handling in JQuery: l'oggetto evento normalizzato
(12-21)

JQuery e AJAX: la funzione principale $.ajax
(12-22)

Decodifica automatica dei dati ricevuti via AJAX
(12-23)

Esempio Il dataType jsonp e le chiamate AJAX cross-origin eseguite senza XMLHTTPRequest
(12-24)

JQuery e AJAX: i metodi "scorciatoia"$.get, $.post e $.getJSON
(12-25)

Client RESTful in Javascript con JQuery
(12-26)

Esempio Un client Javascript per il servizio RESTful events: client JQuery
materiale EventsREST_Client_JS