Web Applications II - Appunti completi (Kotlin, Spring Boot, Spring Security, Microservizi, Kafka)

Corso di Laurea Magistrale in Informatica

Appunti di Web Application II

Anno Accademico 2025/2026

Studente: Emmanuel Messina

Politecnico Di Torino

Indice

1 Introduzione a Kotlin 6

1.1 Dettagli del linguaggio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

1.2 Variabili . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

1.3 Funzioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

1.4 Costrutti logici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

1.5 Function Literals e Lambda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

1.6 Higher Order Functions e Closures . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

1.7 Classi e Oggetti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

1.8 Proprietà delle Classi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

1.9 Costruttori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

1.10 Backing Fields e Modificatori di Visibilità . . . . . . . . . . . . . . . . . . . . . . . . 16

1.11 Late-initialized Properties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

1.12 Delegated Properties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

1.13 Metodi delle Classi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

1.14 Confronto e ordinamento: Order Testing . . . . . . . . . . . . . . . . . . . . . . . . . 20

1.15 Oggetti unici: Singleton Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

1.16 Proprietà e metodi condivisi: Companion Objects . . . . . . . . . . . . . . . . . . . . 22

1.17 Estendere le classi senza ereditarietà: Extension Functions . . . . . . . . . . . . . . . 22

1.18 Ereditarietà e interfacce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

1.19 Data Class: classi per i dati . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

1.20 Enum Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

1.21 Sealed Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

1.22 Generics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

1.23 Scoped Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

1.24 Collezioni in Kotlin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

2 Gradle 35

2.1 Inizializzare un progetto Gradle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

2.2 Task standard di Gradle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

2.3 Plugin in Gradle: cosa sono e a cosa servono . . . . . . . . . . . . . . . . . . . . . . 41

2.4 Struttura di progetto: convenzioni e alternative . . . . . . . . . . . . . . . . . . . . . 43

2.5 Multi-module projects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

3 Annotazioni in Kotlin 50

3.1 Introduzione alle annotazioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

3.2 Dichiarare una nuova annotation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

3.3 Meta-annotations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

3.4 Annotare codice in pratica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

3.5 Scrivere compiler plugins e processori di annotazioni . . . . . . . . . . . . . . . . . . 53

3.6 Processing via Reflection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

3.7 Conclusioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

1

4 Introduzione all’Architettura Software 56

4.1 Il Processo di Progettazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

4.2 Approccio a Livelli (Tiered Approach) . . . . . . . . . . . . . . . . . . . . . . . . . . 57

4.3 Web Tier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

4.4 Architettura Completa di un’Applicazione Web Moderna . . . . . . . . . . . . . . . 59

5 Spring 62

5.1 Class Coupling e Inversion of Control . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

5.2 Dependency Injection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

5.3 Aspect Oriented Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

5.4 Application Context . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70

5.5 Autoconfiguration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

5.6 Gestione del ciclo di vita degli oggetti (Life-cycle management) . . . . . . . . . . . . 73

6 Spring MVC 80

6.1 La gestione delle connessioni nel modello tradizionale: la Servlet Stack . . . . . . . . 80

6.2 Spring MVC e il pattern Model-View-Controller . . . . . . . . . . . . . . . . . . . . 81

6.3 Esposizione di una risorsa web in Spring MVC . . . . . . . . . . . . . . . . . . . . . 83

6.4 Le espressioni di Thymeleaf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86

6.5 Gli Interceptors in Spring MVC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

6.6 Ricezione dei dati nei controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90

6.7 Serving REST content . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92

6.8 Gestire gli status code di una risposta . . . . . . . . . . . . . . . . . . . . . . . . . . 94

6.9 Implementare exception handlers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

6.10 Gestione dell’applicazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95

7 Open API 97

7.1 Introduzione a OpenAPI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97

7.2 Integrazione tra Spring Boot e OpenAPI . . . . . . . . . . . . . . . . . . . . . . . . . 97

7.3 Configurazione di OpenAPI in Spring Boot . . . . . . . . . . . . . . . . . . . . . . . 97

7.4 Configurazione del Bean OpenAPI . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98

7.5 Configurazione delle Proprietà . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99

7.6 Annotazioni per la Documentazione . . . . . . . . . . . . . . . . . . . . . . . . . . . 99

8 Service Layer 100

8.1 L’Architettura a Livelli e il Ruolo del Controller . . . . . . . . . . . . . . . . . . . . 100

8.2 Responsabilità e Vantaggi del Service Layer . . . . . . . . . . . . . . . . . . . . . . . 100

8.3 I Data Transfer Objects (DTOs) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101

8.4 Implementazione del Livello di Servizio . . . . . . . . . . . . . . . . . . . . . . . . . . 102

8.5 Validazione dei Dati in Ingresso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

8.6 Gestione degli Errori di Validazione per il Cliente . . . . . . . . . . . . . . . . . . . . 104

8.7 Aggiunta di Validatori Personalizzati . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

8.8 Principi di Progettazione e Test del Service Layer . . . . . . . . . . . . . . . . . . . . 105

8.9 Servizi e Transazioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106

8.10 Riepilogo e Principi Guida del Service Layer . . . . . . . . . . . . . . . . . . . . . . . 109

2

9 Logging 110

9.1 Livelli di Logging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110

9.2 Configurazione tramite application.properties . . . . . . . . . . . . . . . . . . . . . . 111

9.3 Struttura Base: Appender e Root Logger . . . . . . . . . . . . . . . . . . . . . . . . 112

9.4 Appender Multipli e Policy di Rotazione . . . . . . . . . . . . . . . . . . . . . . . . . 113

9.5 Logger Specifici e Additività . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113

9.6 Logging Asincrono . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114

9.7 Implementazione con Logback (AsyncAppender) . . . . . . . . . . . . . . . . . . . . 114

9.8 Best Practices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114

9.9 Mapped Diagnostic Context (MDC) . . . . . . . . . . . . . . . . . . . . . . . . . . . 115

10 Il Livello di Accesso ai Dati (Data Access Layer) 116

10.1 Database Relazionali e ORM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116

10.2 JPA: Jakarta (Java) Persistence API . . . . . . . . . . . . . . . . . . . . . . . . . . . 118

10.3 L’EntityManager e gli Stati delle Entità . . . . . . . . . . . . . . . . . . . . . . . . . 122

10.4 Spring Data JPA: L’Astrazione Definitiva . . . . . . . . . . . . . . . . . . . . . . . . 125

10.5 Implementazione dei Repository . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127

10.6 Configurazione di Spring Data JPA . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132

11 Spring Data JPA Nel Dettaglio 134

11.1 Requisiti Fondamentali delle Entità JPA . . . . . . . . . . . . . . . . . . . . . . . . . 134

11.2 Identificazione delle Entità (Primary Key) . . . . . . . . . . . . . . . . . . . . . . . . 135

11.3 Implementazione di equals e hashCode . . . . . . . . . . . . . . . . . . . . . . . . . . 137

11.4 La Classe EntityBase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137

11.5 Relazioni tra Entità . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139

11.6 Cascading Operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141

11.7 L’Importanza della Orphan Removal . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

11.8 Transazioni, Isolamento e Locking . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144

12 Integration Testing 150

12.1 Unit Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150

12.2 Mocks e Stubs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152

12.3 Integration Testing (Test di Integrazione) . . . . . . . . . . . . . . . . . . . . . . . . 153

13 Autenticazione e Autorizzazione nei Sistemi Distribuiti 157

13.1 Il Problema: Identità e Permessi nel Mondo Digitale . . . . . . . . . . . . . . . . . . 157

13.2 Identity Access Manager (IAM) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157

13.3 OAuth 2.0: Il Protocollo di Autorizzazione . . . . . . . . . . . . . . . . . . . . . . . . 158

13.4 OpenID Connect (OIDC) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163

13.5 Architettare Sistemi Complessi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165

14 Spring Security 167

14.1 L’Importanza Fondamentale della Sicurezza nelle Applicazioni Web . . . . . . . . . . 167

14.2 Il Meccanismo di Difesa CORS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169

14.3 L’Approccio Dichiarativo di Spring Security . . . . . . . . . . . . . . . . . . . . . . . 171

14.4 Il Flusso OIDC Authorization Code . . . . . . . . . . . . . . . . . . . . . . . . . . . 179

14.5 Configurazione dell’OAuth2 Client . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184

3

14.6 Accesso al Principal e Gestione dei Dati Utente . . . . . . . . . . . . . . . . . . . . . 187

14.7 Autenticazione e Gestione delle Sessioni . . . . . . . . . . . . . . . . . . . . . . . . . 187

14.8 Sicurezza a Livello di Servizio (Method Security) . . . . . . . . . . . . . . . . . . . . 188

14.9 Adattamento del Flusso Authorization Code per le SPA . . . . . . . . . . . . . . . . 188

14.9.1 Flusso di Autenticazione SPA nel Dettaglio . . . . . . . . . . . . . . . . . . . 189

14.10Login e Logout nel Frontend . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191

14.11Protezione CSRF (Cross-Site Request Forgery) . . . . . . . . . . . . . . . . . . . . . 191

14.12Configurazione CORS (Cross-Origin Resource Sharing) . . . . . . . . . . . . . . . . . 192

14.13Content Security Policy (CSP) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193

15 Architetture Event Driven e Message Brokers 196

15.1 Il superamento del paradigma sincrono . . . . . . . . . . . . . . . . . . . . . . . . . . 196

15.2 Eventi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197

15.3 Gestione dei Comandi e degli Eventi nel Broker . . . . . . . . . . . . . . . . . . . . . 198

15.4 RabbitMQ: Architettura e Protocolli . . . . . . . . . . . . . . . . . . . . . . . . . . . 199

15.5 Integrazione di RabbitMQ in Spring Boot . . . . . . . . . . . . . . . . . . . . . . . . 200

15.6 Scalabilità Orizzontale e Fanout Exchange . . . . . . . . . . . . . . . . . . . . . . . . 202

15.7 Apache Kafka: Piattaforma di Event Streaming . . . . . . . . . . . . . . . . . . . . . 203

15.8 Integrazione di Apache Kafka in Spring Boot . . . . . . . . . . . . . . . . . . . . . . 207

15.9 Confronto tra Message Brokers: Kafka vs RabbitMQ . . . . . . . . . . . . . . . . . . 210

15.10Kafka Connect: Integrazione Dati Scalabile . . . . . . . . . . . . . . . . . . . . . . . 211

16 Microservizi 215

16.1 Il Passaggio dal Monolite ai Microservizi . . . . . . . . . . . . . . . . . . . . . . . . . 215

16.2 Architettura a Microservizi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215

16.3 Caratteristiche e Struttura dei Servizi . . . . . . . . . . . . . . . . . . . . . . . . . . 218

16.4 Razionale e Problematiche dei Microservizi . . . . . . . . . . . . . . . . . . . . . . . 220

16.5 Design Pattern per Microservizi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221

16.6 Pattern Outbox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224

16.7 Gestione delle Transazioni Distribuite: Le Sagas . . . . . . . . . . . . . . . . . . . . 227

16.8 Strategie di Migrazione e Composizione . . . . . . . . . . . . . . . . . . . . . . . . . 229

16.9 Il Pattern CQRS (Command Query Responsibility Segregation) . . . . . . . . . . . . 229

17 MongoDB 231

17.1 Gestione dei dati: Il Modello Relazionale e i suoi Limiti . . . . . . . . . . . . . . . . 231

17.2 Modelli di Consistenza Distribuita . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232

17.3 MongoDB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233

17.4 Struttura dei Dati: Documenti, Collezioni e Database . . . . . . . . . . . . . . . . . 236

17.5 Modellazione dei Dati Strutturati . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236

17.6 Operazioni CRUD in MongoDB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238

17.7 Proiezioni nelle Query . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241

17.8 Aggregazioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242

17.9 Indici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244

17.10Transazioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245

17.11MongoDB in Spring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246

4

Emmanuel Messina - Web Application II 2025/2026

18 Redis 253

18.1 Introduzione a Redis e Architettura . . . . . . . . . . . . . . . . . . . . . . . . . . . 253

18.2 Integrazione con Spring Boot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255

18.3 Redis come Sistema di Caching Distribuito . . . . . . . . . . . . . . . . . . . . . . . 256

18.4 Redis come Server Pub/Sub . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258

18.5 Redis come Coda di Eventi (Event Queue) . . . . . . . . . . . . . . . . . . . . . . . . 259

19 Spring AI 264

19.1 Introduzione allo Sviluppo di Applicazioni Intelligenti con Spring AI . . . . . . . . . 264

19.2 Configurazione del Progetto (Setup) . . . . . . . . . . . . . . . . . . . . . . . . . . . 265

19.3 Flusso di Interazione dei Componenti . . . . . . . . . . . . . . . . . . . . . . . . . . . 267

19.4 L’Astrazione di Alto Livello: ChatClient API . . . . . . . . . . . . . . . . . . . . . . 271

19.5 Embeddings e EmbeddingModel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274

Premessa Prima di iniziare a studiare da questi appunti è necessario che tu sappia che, nonostante

si sia cercato di fare gli appunti nel miglior modo possibile sia per ripassare al meglio e sia per poter

creare un materiale utile per altri studenti, che ci potrebbero ugualmente essere imprecisioni, errori

di scrittura o altro. In caso di problemi si prega di contattarmi via mail: s333951@studenti.polito.it,

su instagram: @emmanuelmessina00 oppure sul canale telegram: CLICCA QUI. Se vuoi

sostenere il lavoro svolto, puoi offrirmi un caffè (1 euro) qui: CLICCA QUI.

5

Emmanuel Messina - Web Application II 2025/2026

1 Introduzione a Kotlin

Kotlin è un linguaggio di programmazione tipizzato staticamente. È un linguaggio ispirato alla

programmazione funzionale. È un linguaggio multi target, Kotlin può essere infatti compilato su

JVM, Android, Browser, nativamente. Tra i development tools abbiamo IntelliJ IDEA, Android

Studio, Eclipse, CLI.

1.1 Dettagli del linguaggio

Kotlin è un linguaggio tipizzato staticamente, possiamo quindi assegnare un tipo alle variabili, ai

parametri delle funzioni e ritornare valori di un certo tipo. Il compilatore attraverso un’interfaccia

cerca di dedurre errori il prima possibile. Kotlin è un linguaggio introdotto come alternativa a Java.

In Java esistono due categorie di tipi:

• Tipi primitivi: int, short, long, byte, float, double, char, boolean.

– Sono tipi a valore, memorizzati direttamente nello stack o nei campi di un oggetto.

– Non sono oggetti, quindi non hanno metodi.

• Classi wrapper (boxed types): Integer, Short, Long, Byte, Float, Double, Character,

Boolean.

– Sono oggetti veri e propri, con metodi e comportamento da reference type.

– Servono quando, ad esempio, devi inserire un numero in una collezione (List, Map) che

accetta solo oggetti.

Questa distinzione crea duplicazioni e incoerenze:

• Devi passare da un tipo primitivo al corrispondente boxed e viceversa (autoboxing/unboxing).

• Alcuni comportamenti cambiano: ad esempio il confronto == per gli oggetti confronta i

riferimenti, mentre per i primitivi confronta il valore.

• Nelle funzioni generiche non puoi usare direttamente un tipo primitivo come parametro