Sviluppo Web Avanzato :: Diario del corso

Diario delle Lezioni - A.A. 2024/2025

Lezioni totali: 9, ore erogate: 18 (75%) - Prima lezione: 28/02/2025, Ultima lezione: 16/05/2025

Lezione 1: Introduzione ai (RESTful) web services

28/02/2025, 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
(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
(1-16)

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

I servizi web RESTful: quando usarli, e quali alternative esistono

Lezione 2: La semantica dei servizi RESTful 1

07/03/2025, ore 11:30 (2 ore)
Slides Restful

(2-1)

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

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

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

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

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

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

Esempio GET su collezioni: SELECT
(2-8)

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

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

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

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

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

Lezione 3: La semantica dei servizi RESTful 2

14/03/2025, ore 11:30 (2 ore)
Slides Restful

(3-1)

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

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

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

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

Esempio PUT su item: UPDATE globale su uno specifico record
(3-6)

Il payload del metodo PUT e l'header Content-Type
(3-7)

Esempio PUT su attributi: UPDATE di singoli attributi in uno specifico record
(3-8)

Esempio PUT su collezioni: sostituzione di un'intera collezione
(3-9)

PUT: stati HTTP di ritorno
(3-10)

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

Esempio PATCH su item: UPDATE parziale su uno specifico record
(3-12)

Estensione della semantica PUT in ambienti che non supportano la PATCH
(3-13)

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

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

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

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

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

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

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

DELETE: stati HTTP di ritorno
(3-21)

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-22)

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

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

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

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

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-27)

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

Operazioni di tipo RMI via RESTful
(3-29)

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

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

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

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

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

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

Esempio Usare il metodo POST come alternativa alla GET su collezione per definire filtri complessi

Lezione 4: La sicurezza nei servizi RESTful

21/03/2025, ore 11:30 (2 ore)

(4-1)

Sicurezza nelle API RESTful
(4-2)

Il ruolo del token di accesso nella sicurezza delle API
link https://datatracker.ietf.org/doc/html/rfc7519
(4-3)

Come scambiarsi il token di accesso: dai metodi rudimentali (query string, path) alla Bearer Authorization
(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

28/03/2025, ore 11:30 (2 ore)

(5-1)

Esempio Il caso di studio events
materiale REST_Specs
(5-2)

Introduzione al formato JSON
link https://www.json.org
(5-3)

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

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

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

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

Mappare metodi e payload sulle URL
(5-8)

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

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

Introduzione a JSON Schema

Lezione 6: JSON Schema

04/04/2025, 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

11/04/2025, 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)

Esempio Usare lo Swagger editor per creare una specifica OpenAPI
link https://editor-next.swagger.io/
(7-5)

OpenAPI: oggetto info
(7-6)

OpenAPI: oggetto tags
(7-7)

OpenAPI: oggetto externalDocs
(7-8)

OpenAPI: servers
(7-9)

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

OpenAPI: componenti di tipo schema
(7-11)

OpenAPI: componenti di tipo parameter
(7-12)

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

Lezione 8: OpenAPI /2

09/05/2025, ore 11:30 (2 ore)
Slides OpenAPI

(8-1)

OpenAPI: componenti di tipo response
(8-2)

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

OpenAPI: componenti di tipo requestBody
(8-4)

OpenAPI: componenti di tipo securityScheme
(8-5)

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

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

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

Parametri di livello path e metodo
(8-9)

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

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

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

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

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

Lezione 9: JAX-RS /1

16/05/2025, ore 11:30 (2 ore)
Materiale JAXRS_Examples

(9-1)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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