Last Updated on 2 anni | Published: 13/03/2024
Spring Boot
Spring Boot è un progetto di Spring per rendere più veloce lo sviluppo di applicazioni web utilizza un sistema di autoconfigurazione attraverso classi, creando i bean necessari quando certe condizioni sono vere, che nella versione classica non è presente.
Le caratteristiche di Spring Boot possono essere le seguenti:
- Si evitano configurazioni XML complesse
- Si sviluppano facilmente applicazioni Spring pronte all’ uso
- Possibilità di incorporare direttamente applicazioni web server/container come Apache Tomcat.
Spring Boot è anche un framework modulare che fornisce una vasta gamma di moduli per soddisfare diverse esigenze nello sviluppo delle applicazioni.
Fornisce una serie di annotazioni utili per semplificare il processo di sviluppo. Ecco alcune delle annotazioni principali:
@SpringBootApplication: questa annotazione combina diverse annotazioni, tra cui @Configuration, @EnableAutoConfiguration e @ComponentScan. Essa indica che la classe corrente è una classe di configurazione per l’applicazione Spring Boot.
- @RestController: questa annotazione viene utilizzata sempre per gestire richieste HTTP. Essa semplifica la creazione di endpoint RESTful per l’applicazione. A differenza dei metodi annotati con @Controller, che restituiscono spesso Viste, @RestController utilizza implicitamente @ResponseBody che semplifica la scrittura di servizi web.
- @Autowired: questa annotazione viene utilizzata per l’iniezione di dipendenze. Essa permette di collegare automaticamente i bean che dipendono l’uno dall’altro.
- @Component: questa annotazione viene utilizzata per indicare che una classe è un bean. Essa semplifica la configurazione dei bean all’interno dell’applicazione Spring.
- @RequestMapping: questa annotazione viene utilizzata per mappare qualsiasi richiesta HTTP a un metodo del controller. Essa permette di specificare il percorso dell’endpoint RESTful.
- @GetMapping: utilizzata per mappare una richiesta HTTP GET ad un metodo della classe Controller.
- @PostMapping: utilizzata per mappare una richiesta HTTP POST ad un metodo del controller.
- @PutMapping: utilizzata per mappare una richiesta HTTP PUT ad un metodo del controller.
- @DeleteMapping: utilizzata per mappare una richiesta HTTP DELETE ad un metodo di un controller.
- @PathVariable: questa annotazione viene utilizzata per indicare che un parametro di un metodo del controller corrisponde ad una variabile di percorso nell’URL. Essa semplifica la gestione di parametri dinamici nell’URL.
- @RequestBody: questa annotazione viene utilizzata per indicare che un parametro di un metodo del controller corrisponde al corpo della richiesta HTTP. Essa semplifica la lettura dei dati inviati dal client nell’endpoint RESTful.
- @RequestParam: annotazione utilizzata per legare i parametri di richiesta HTTP ai parametri del metodo mappato nel Controller.
- @Bean: viene utilizzata per definire un bean all’interno dell’applicazione. Un bean è un oggetto che viene istanziato, configurato e gestito dal container di Spring e può essere utilizzato in altre parti dell’applicazione attraverso l’iniezione di dipendenze.
- @ComponentScan: è una delle annotazioni di base utilizzate in Spring Boot per configurare il contesto dell’applicazione. Viene utilizzata per indicare a Spring dove cercare i componenti, i bean e i servizi da gestire all’interno dell’applicazione.
- @Service: Questa annotazione viene utilizzata per identificare una classe come un servizio di Spring. I servizi sono un tipo di componente di Spring che viene utilizzato per implementare la logica di business dell’applicazione.
Spring Boot è anche un framework modulare che fornisce una vasta gamma di moduli per soddisfare diverse esigenze nello sviluppo delle applicazioni. Ecco una panoramica dei principali moduli di Spring Boot:
Questo è il modulo principale di Spring Boot e fornisce le funzionalità di base del framework. Include l’inversione di controllo (IoC), l’iniezione delle dipendenze e le utilità di configurazione automatica.
Spring Boot StarterI starter sono moduli pre-configurati che semplificano l’integrazione di funzionalità specifiche nelle applicazioni Spring Boot. Ogni starter include un set di dipendenze correlate per una funzionalità specifica. Ad esempio, spring-boot-starter-web include tutte le dipendenze necessarie per sviluppare un’applicazione web, mentre spring-boot-starter-data-jpa include le dipendenze per l’accesso ai dati utilizzando JPA (Java Persistence API).
Questo modulo fornisce funzionalità per monitorare e gestire le applicazioni Spring Boot in esecuzione. Include endpoint REST per la salute, le metriche, le informazioni sulla configurazione e altro ancora, che possono essere utilizzati per il monitoraggio e la gestione delle applicazioni in tempo reale.
Spring Boot DevToolsQuesto modulo fornisce strumenti di sviluppo per migliorare il processo di sviluppo delle applicazioni Spring Boot. Include funzionalità come il riavvio automatico dell’applicazione quando vengono apportate modifiche al codice sorgente e il supporto per l’aggiornamento automatico delle risorse statiche.
Spring Boot TestQuesto modulo fornisce supporto per i test unitari e di integrazione nelle applicazioni Spring Boot. Include annotazioni e utilità per scrivere e eseguire test in modo efficiente, come ad esempio @SpringBootTest per i test di integrazione e @MockBean per la creazione di mock di bean.
Questo modulo fornisce funzionalità di sicurezza per le applicazioni Spring Boot. Include supporto per l’autenticazione, l’autorizzazione, la protezione CSRF (Cross-Site Request Forgery) e altro ancora.
Spring Boot DataQuesto modulo fornisce supporto per l’accesso ai dati nelle applicazioni Spring Boot. Include supporto per i database relazionali e non relazionali, utilizzando tecnologie come JPA, JDBC (Java Database Connectivity), MongoDB, Redis e altri.
Spring Boot WebQuesto modulo fornisce supporto per lo sviluppo di applicazioni web nelle applicazioni Spring Boot. Include funzionalità per la gestione delle richieste HTTP, la creazione di API RESTful, la gestione dei template per la generazione dinamica del contenuto web e altro ancora
Definizione WAR - JAR
Quando si crea un nuovo progetto Spring Boot utilizzando Spring Initializr e si importa il progetto in Maven, è possibile scegliere tra due opzioni di packaging: War (Web Application Archive) e Jar (Java Archive).
La principale differenza tra un progetto Spring Boot War e uno Jar riguarda il modo in cui l’applicazione viene distribuita e avviata.
Un progetto Spring Boot con packaging War viene creato come un archivio di applicazione web.
War (Web Application Archive)
Un file War è essenzialmente un file compresso che contiene tutti i file necessari per eseguire un’applicazione web, inclusi file JSP, file HTML, immagini, fogli di stile, classi Java, librerie, file di configurazione e così via. Un file War viene distribuito su un server web o un contenitore servlet, come Apache Tomcat o Jetty.
L’avvio di un’applicazione War richiede un server web o un contenitore servlet per ospitare l’applicazione. Il server web viene configurato per gestire le richieste HTTP in arrivo e fornire l’applicazione web contenuta nel file War.
Jar(Java Archive)
D’altra parte, un progetto Spring Boot con packaging Jar viene creato come un file eseguibile di Java autonomo.
Un file Jar è un archivio compresso che contiene tutte le dipendenze e le risorse necessarie per eseguire un’applicazione Java, inclusi file di classe, librerie esterne, risorse, file di configurazione e così via.
Per la sua natura auto-contenuta può essere distribuito e avviato facilmente in diversi ambienti, come server, container Docker, cloud, ecc. Non c’è bisogno di configurazioni complesse o di installare software aggiuntivo sul server di destinazione.
I file Jar possono essere facilmente versionati. Puoi gestire diverse versioni della tua applicazione JAR per assicurarti che le versioni più recenti siano distribuite e eseguite correttamente.
Un file Jar può essere eseguito direttamente utilizzando il comando “java -jar” senza la necessità di un server web o un contenitore servlet.
Progetti WAR
Per organizzare progetti Spring Boot è possibile utilizzare Spring initializr, ovvero un portale online all’ indirizzo https://start.spring.io/ . Utilizzando Spring Initializr, l’utente può selezionare le dipendenze di cui ha bisogno per il proprio progetto, come ad esempio Spring Web e configurare le opzioni del progetto, come il nome, la descrizione e il tipo di progetto. Inoltre Spring Initializr consente di scegliere la versione di Spring Boot da utilizzare e il tipo di progetto da generare, come ad esempio un progetto basato su web o su dati. Una volta completate le selezioni, l’utente può scaricare il progetto generato sotto forma di file ZIP e importarlo nell’IDE di Eclipse progetto Maven per iniziare a sviluppare la propria applicazione Spring. Di seguito la creazione di un progetto ‘demo’ con le configurazioni di Spring Boot attraverso classi e non descrittori xml. A tal proposito viene introdotto il concetto di pattern MVC e quindi la definizione delle classi Controller, la configurazione di una view resolver per l’ utilizzo delle JSP e successivamente le classi Model ovvero l’ implementazione Business dell’ applicazione come potrebbe essere un DataBase MySql:
Quando si genera un progetto Spring Boot come file ZIP utilizzando Spring Initializr e poi lo si importa in Maven, la struttura del progetto dipenderà dalle opzioni selezionate durante la configurazione di Spring Initializr.
In genere, la struttura base di un progetto Spring Boot include diverse cartelle e file predefiniti:
- La cartella
src/main/javacontiene il codice sorgente dell’applicazione, suddiviso in pacchetti gerarchici. - La classe principale dell’applicazione viene solitamente creata in
src/main/javacon un nome scelto dall’utente. Questa classe di solito ha l’annotazione@SpringBootApplicatione contiene il metodomain()che avvia l’applicazione. - La cartella
src/main/resourcescontiene le risorse dell’applicazione, come file di configurazione, immagini e file di proprietà. - La cartella
src/test/javacontiene il codice sorgente per i test dell’applicazione, anch’esso suddiviso in pacchetti gerarchici. - La cartella
src/test/resourcescontiene le risorse necessarie per l’esecuzione dei test.
In una applicazione di Spring Boot MVC per impostazione predefinita, il componente scan per le classi controller è la cartella principale dell’applicazione (cioè la cartella che contiene la classe principale annotata con “@SpringBootApplication“). Questo significa che Spring Boot cercherà automaticamente le classi controller all’interno di questa cartella e delle sottocartelle.
Nell’ esempio sopra descritto invece è stata implementata una classe per configurare il context di Spring, infatti possiamo notare la presenza della classe AppConfig.class che assume il ruolo di configuratore per la presenza dell’ annotazione @Configuration.
Ovviamente Spring utilizza annotazioni per configurare il progetto tra cui @ComponentScan che appunto serve a scansionare il classpath dell’applicazione in cerca di classi contrassegnate come componenti Spring, come ad esempio classi contrassegnate con le annotazioni @Component, @Service, @Controller, @Repository, o altre annotazioni personalizzate.
La classe di configurazione implementa anche un @Bean per risolvere i nomi delle viste in percorsi fisici all’ interno dell’ applicazione e per generare le viste corrisponedenti, per questo Spring utilizza la classe InternalResourceViewResolver opportunamente configurata con i parametri necessari.
Infatti Il metodo viewResolver() è annotato come @Bean, il che indica a Spring di creare e gestire un bean di tipo InternalResourceViewResolver. Questo metodo imposta i parametri prefix e suffix dell’istanza di InternalResourceViewResolver. In particolare, prefix specifica il percorso in cui si trovano le viste JSP all’interno della cartella /viste/, mentre suffix specifica l’estensione dei file delle viste, in questo caso .jsp.
È importante notare che InternalResourceViewResolver è uno dei molti view resolver disponibili in Spring Framework, e la sua configurazione può variare a seconda delle esigenze specifiche dell’applicazione.
Nel contesto dell’ applicazione demo l’ annotazione @RequestParam() nel metodo mappato è utilizzata per recuperare i parametri URL della richiesta:
Questa applicazione di Spring Boot, progettata con il packaging WAR, dovrà essere eseguita sul server Tomcat, versione 10 per spring 6.xx (modulo 3.xx), installato in Eclipse.
Progetto WAR
Gestione dei @Component
L’annotazione @Component è una delle principali annotazioni di Spring ed è utilizzata per indicare che una classe è un componente di Spring. Un componente è una classe gestita da Spring e quindi è disponibile per l’iniezione delle dipendenze in altre parti dell’applicazione. In altre parole, un componente è un oggetto che viene creato, gestito e configurato da Spring e può essere utilizzato in modo trasparente in tutta l’applicazione.
Nell’ esempio di un progetto WAR, la classe Componenti è annotata come @Component e quindi può essere iniettata, infatti la classe @Controller inietta la dipendenza con @Autowired e quindi il suo oggetto per ottenere un ArrayList<String> e stamparlo sulla console prima di aprire una pagina. Non è riportata nell’ esempio la classe annotata come @Configuration in quanto ha la stessa implementazione dell’ esempio precedente.
Gestione Classe Model
E’ appropriato in questo articolo discutere della classe Model in quanto l’ oggetto ArrayList<String> dell’ esempio precedente dovrà essere stampato sulla pagina di return, inoltre questa implementazione dimostra come è strutturato un pattern MVC.
Il Model di Spring Boot è una classe utilizzata per passare dati tra il controller e la vista in un’applicazione web basata su Spring Boot. In altre parole, la classe Model consente di aggiungere oggetti a una vista in modo che possano essere visualizzati dall’utente finale.
Di seguito l’ implementazione della classe @Controller e la pagina.jsp che stampa l’ attributo recuperato attraverso la libreria JSTL ( vedi il POM)
Download progetto: WAR Componente
-
componente.zip
(zip, 77KB)
-
Spring Boot 3.x utilizza Jakarta EE anziché Java EE. In particolare, tutte le classi javax.servlet sono state spostate sotto il namespace jakarta.servlet nella nuova versione.
Per risolvere il problema, devi includere le dipendenze Jakarta EE corrette, specialmente per JSP e JSTL, nel tuo progetto.
<dependency>
<groupId>org.glassfish.web</groupId>
<artifactId>jakarta.servlet.jsp.jstl</artifactId>
</dependency>
<dependency>
<groupId>jakarta.servlet.jsp.jstl</groupId>
<artifactId>jakarta.servlet.jsp.jstl-api</artifactId>
</dependency>
Gestione dei @Bean
Nell’ articolo precedente abbiamo visto come sia possibile definire una classe come @Component. Per quanto riguarda l’ annotazione @Bean è utilizzata per definire un bean singolo il cui controllo completo è affidato allo sviluppatore, questo significa che lo sviluppatore può creare un bean con qualsiasi nome e configurazione e Spring lo gestirà nel suo contesto.
La principale differenza tra @Component e @Bean è che il primo viene utilizzato per classi che devono essere gestite da Spring senza dover dichiarare esplicitamente un metodo di produzione, mentre @Bean viene utilizzato per metodi specifici di una classe di configurazione che producono bean.
Tuttavia, entrambi vengono utilizzati per definire i bean in una applicazione Spring Boot. Mostriamo un semplice esempio per un progetto WAR:
Anche nell’ esempio sopra descritto i metodi mappati dalla classe @Controller utilizzano un oggetto della classe Model per gestire gli attributi di persistenza, come ad esempio oggetti della classe Auto.
Download progetto: WAR Bean
-
bean.zip
(zip, 76KB)
-
Classi @Service
La annotazione @Service di Spring è utilizzata per identificare una classe come un componente del livello di servizio all’interno di un’applicazione Spring. Questo livello è responsabile per l’elaborazione della logica di business (database MySql) e l’implementazione delle funzionalità dell’applicazione.
Quando viene applicata la annotazione @Service a una classe, Spring riconosce questa classe come un componente gestito dal framework e la tratta in modo speciale. La classe annotata viene istanziata come un bean Spring e può essere iniettata come dipendenza in altre classi all’interno dell’applicazione. Questa pratica di sviluppo favorisce una migliore separazione dei compiti e facilita il testing, in quanto i componenti di servizio possono essere facilmente sostituiti con mock per i test.
Inoltre, la annotazione @Service può essere combinata con altre annotazioni di Spring, come @Transactional, per abilitare il controllo transazionale sulle operazioni di servizio. Ciò significa che le operazioni eseguite all’interno di un metodo di un componente annotato con @Service possono essere eseguite all’interno di una transazione, garantendo la coerenza dei dati e il rollback in caso di errore.
In conclusione, l’annotazione @Service di Spring è una pratica comune nell’ambito dello sviluppo di progetti enterprise con Spring Framework. Aiuta a identificare e gestire in modo efficiente i componenti del livello di servizio, favorendo una struttura modulare e testabile dell’applicazione.
Ecco un semplice esempio di un progetto WAR che utilizza l’ annotazione @Service con un ArrayList :
Progetto WAR
Gestione dei Form
In Spring Boot la gestione dei form è una delle funzionalità essenziali per sviluppare applicazioni web interattive. Quando un utente invia dati attraverso un form HTML, questi dati devono essere ricevuti e elaborati dal lato server. Spring Boot semplifica questo processo fornendo meccanismi di gestione dei form attraverso la gestione dei dati (Data Binding) e l’elaborazione dei form (Form Handling).
Di seguito viene mostrato come gestire il binding di un form HTML ad una classe Studenti usando JSP in un progetto di Spring Boot con packaging WAR
Nel POM tra le tante dipendenze che occorrono vi è ovviamente anche la dipendenza per la JSTL.
JPA Persistence - Jakarta EE
JPA è una specifica, ovvero un insieme di interfacce e regole che definiscono come mappare gli oggetti Java a database relazionali. In pratica, JPA fornisce un’astrazione per gestire la persistenza dei dati, permettendo agli sviluppatori di lavorare con oggetti Java mentre JPA si occupa di tradurre le operazioni in comandi SQL per il database.
JPA quindi è uno standard e non un’implementazione concreta. Non contiene codice eseguibile, ma solo la definizione delle API e delle regole che le implementazioni devono seguire.
JPA è stato introdotto come parte di Java EE (Java Platform, Enterprise Edition), che è stato il principale standard per lo sviluppo di applicazioni enterprise in Java
Jakarta EE è un framework open-source per lo sviluppo di applicazioni enterprise in Java. È il successore di Java EE (Java Enterprise Edition), e dopo che Oracle ha trasferito la gestione di Java EE alla Eclipse Foundation, il nome è stato cambiato in Jakarta EE, che include una serie di specifiche, di cui JPA è solo una parte. Altre specifiche comuni includono Jakarta Servlet, Jakarta CDI (Context and Dependency Injection), Jakarta Faces, ecc. Jakarta EE funge da piattaforma che coordina e integra tutte queste tecnologie, offrendo un ambiente completo per lo sviluppo di applicazioni enterprise scalabili.
La relazione che esiste tra Jakarta EE e JPA è che quest’ ultima è una delle specifiche di persistenza dati inclusa in Jakarta EE.
Spring Data
Spring Data JPA è un modulo di Spring Framework che semplifica notevolmente l’interazione tra le applicazioni Java e i database relazionali, come MySQL o PostgreSQL, attraverso Java Persistence API (JPA). È particolarmente utile per chi vuole costruire applicazioni con un livello di persistenza (ossia salvare e recuperare dati dal database) senza dover scrivere molto codice.
Perché usare Spring Data JPA
Sebbene JPA fornisca già una buona astrazione per lavorare con i database, richiede comunque di scrivere alcune configurazioni e codice ripetitivo. Spring Data JPA semplifica ulteriormente questo processo offrendo:- Gestione automatica delle operazioni CRUD: Spring Data JPA genera automaticamente il codice per le operazioni di base come Create, Read, Update e Delete. Non devi scrivere codice per queste operazioni.
- Query dinamiche basate sui nomi dei metodi: Puoi creare query semplicemente definendo metodi in un’interfaccia. Spring Data JPA capirà automaticamente cosa deve fare.
- Astrazione e modularità: Spring Data JPA ti permette di lavorare a un livello più alto, senza dover scrivere codice SQL o gestire direttamente le connessioni al database.
Come funziona Spring Data JPA
Per capire come funziona Spring Data JPA, vediamo i concetti chiave:– Entità (Entity)
Un’entità è una classe Java che rappresenta una tabella del database. Ogni campo della classe rappresenta una colonna nella tabella. Con l’annotazione@Entity, dici a JPA che questa classe rappresenta una tabella nel database. 
In questo esempio Studente è una tabella MySql mappata con la classe che deve avere lo stesso nome della tabella, mentre gli attributi della classe sono esattamente i nomi dei campi della tabella. Continuiamo con l’ annotazione @Entity per vedere quelle più comuni che gli appartengono:
@Table
Viene utilizzata per specificare il nome della tabella a cui l’entità deve essere mappata. Se non la si specifica, il nome della tabella sarà uguale al nome della classe.
@Id
Indica che un campo della classe rappresenta la chiave primaria della tabella.
@GeneratedValue
Specifica come viene generato il valore della chiave primaria (vedi la sezione precedente per maggiori dettagli):
GenerationType.AUTO: Delegato al fornitore del persistere (di solito Hibernate), che decide la strategia migliore.GenerationType.IDENTITY: Lascia che il database gestisca la generazione della chiave primaria.GenerationType.SEQUENCE: Usa una sequenza specifica (supportato da database come PostgreSQL, Oracle).GenerationType.TABLE: Usa una tabella specifica per generare l’ID.
@Column
Serve per specificare dettagli sulla colonna del database, come il nome, la lunghezza, se può essere nullo, ecc. Anche se non è obbligatoria, si usa quando è necessario un controllo più preciso sulla mappatura.
@OneToOne
Indica una relazione uno a uno tra due entità.
@JoinColumn
Specifica la colonna che rappresenta la chiave esterna in una relazione.
@OneToMany
Indica una relazione uno a molti, dove un’entità può essere associata a molte istanze di un’altra entità.
mappedBy
Indica quale campo nella classe correlata gestisce la relazione (in questo caso, il campo studente nella classe Corso). @ManyToOne
Indica una relazione molti a uno, dove molte entità possono essere associate a una sola istanza di un’altra entità. 
@ManyToMany
Indica una relazione molti a molti, dove molte entità possono essere associate a molte altre entità. Questa relazione viene generalmente gestita da una tabella di giunzione.
@JoinTable:
Specifica la tabella di giunzione che gestisce la relazione.
joinColumns:
Specifica la colonna che rappresenta la chiave esterna dell’entità corrente.
inverseJoinColumns:
Specifica la colonna che rappresenta la chiave esterna dell’altra entità.
Vediamo passo passo come creare un’applicazione Spring Boot in formato WAR con Spring Web, Spring Data JPA, e un database MySQL. L’applicazione avrà un form HTML per inserire i dati di uno studente (con id, nome, cognome, città e data di nascita), che verranno salvati in una tabella del database MySQL.
Passi per creare il progetto:
- Crea il progetto Spring Boot con Spring Initializr.
- Configura il file pom.xml per il packaging in WAR e le dipendenze.
- Configura il database MySQL in application.properties.
- Crea l’entità JPA Student.
- Crea il repository JPA per Student.
- Crea il controller per gestire il form
- Crea il form HTML per inserire i dati dello studente.
- Compilazione, esecuzione e test dell’applicazione.
In Spring Data JPA, usiamo un’interfaccia per il repository per sfruttare l’approccio basato su proxies dinamici. I motivi principali possono essere:
- L’interfaccia rappresenta un’astrazione per le operazioni CRUD (Create, Read, Update, Delete). Con Spring Data JPA, non abbiamo bisogno di implementare queste operazioni manualmente, perché Spring le fornisce automaticamente.
- Spring Data JPA fornisce implementazioni di base per le operazioni di persistenza (come
save(),findAll(),deleteById(), ecc.), quindi non è necessario scrivere codice di accesso ai dati ripetitivo.
In un’applicazione Spring Boot che utilizza Spring Data JPA per connettersi a un database MySQL, le informazioni di connessione al database vengono configurate all’interno del file application.properties
L’opzione spring.jpa.hibernate.ddl-auto=update è una proprietà di configurazione di Spring Boot e Hibernate che controlla il comportamento di gestione dello schema del database durante l’avvio dell’applicazione.
ddl-auto è una proprietà che specifica a Hibernate come comportarsi rispetto alla creazione e aggiornamento delle tabelle e dello schema del database. Il termine DDL si riferisce a “Data Definition Language”, che è un insieme di comandi SQL utilizzati per definire o modificare la struttura di un database (come creare, modificare o cancellare tabelle).
Le possibili opzioni per ddl-auto sono:
none: Hibernate non modifica lo schema del database.validate: Verifica che lo schema esistente nel database corrisponda al mapping definito nelle entità Java. Non modifica lo schema, ma genera errori se ci sono discrepanze.update: Hibernate aggiorna lo schema del database senza cancellare i dati esistenti. Aggiunge o modifica tabelle, colonne, ecc.create: Crea lo schema del database ex novo a ogni avvio dell’applicazione. Elimina le tabelle esistenti e le ricrea (quindi si perdono i dati).create-drop: Comecreate, ma elimina le tabelle quando l’applicazione viene chiusa.
Funzionalità di spring.jpa.hibernate.ddl-auto=update
Quando imposti ddl-auto=update, Hibernate fa quanto segue:
- Aggiorna lo schema del database in base alle entità definite nel codice Java.
- Non cancella o altera tabelle o colonne esistenti se non necessario.
- Aggiunge nuove colonne o tabelle, se sono state aggiunte nuove proprietà o entità nella tua applicazione.
Progetti JAR - Spring Boot
Vediamo quali passaggi occorrono per realizzare un semplice progetto JAR con un entry point GET e testarlo:
Innanzitutto attraverso Spring Initializr, allo stesso modo dei progetti di tipo War, selezioniamo le dipendenze che ci occorrono come ad esempio Spring Web, si assegna un Group ed Artifact generando alla fine il progetto JAR ZIP da importare in Eclipse come Existing Maven Projects.
- Eclipse fornisce un’integrazione diretta con Maven tramite il plugin “m2e“, che consente di gestire i progetti Maven direttamente dall’IDE.
- Per eseguire una clean, install oppure altro con Maven in Eclipse, è sufficiente fare clic destro sul progetto Maven e selezionare “Run As” oppure selezionare il progetto ed utilizzare il run/run as della barra degli strumenti:
Selezionando Java Application dal menu Run As sarà possibile eseguire l’ applicazione, ovvero il file JAR prodotto:
Quando esegui un’applicazione Spring Boot come un JAR eseguibile, il concetto di “server” è integrato nell’applicazione stessa. Questo è possibile grazie a un’implementazione embedded server fornita da Spring Boot.
Spring Boot avvia il server web incorporato (ad es. Tomcat) e inizializza l’applicazione Spring Boot. Una volta che il server è avviato, è pronto per gestire le richieste HTTP in arrivo.
In riferimento all’ esempio sopra descritto per effettuare un test è possibile utilizzare Chrome oppure Postman con url
localhost:8080/stringa
Progetti JAR - Component
Di seguito un esempio di Spring Boot con l’ uso di una classe @Component, la classe che è un Bean, il progetto utilizza la @RestController per esporre un endpoint REST:
La @RestController dichiara la classe come un controller REST e le route restituiscono i dati ottenuti dalla classe Servizi iniettata attraverso @Autowired
localhost:8080/saluto
localhost:8080/corso
Progetti JAR - Service
Esempio Spring Boot per evidenziare la gestine dei @Service:
Progetto JAR - CRUD ArrayList
Progetto Spring Boot per gestire un CRUD su un ArrayList di utenti che è un’ottima idea per comprendere i concetti di base di Spring Boot e come sviluppare servizi RESTful.
Download progetto: JAR ArrayService
-
restarray.zip
(zip, 83KB)
-
Per testare gli endpoint del progetto ArrayService possiamo utilizzare una varietà di strumenti e approcci. Un modo comune è quello di utilizzare Postman che è uno strumento di sviluppo API ed offre un ambiente completo per la creazione, il test, la documentazione e la condivisione di API.
Prima di utilizzare Postman per testare i servizi REST, è necessario che l’applicazione Spring Boot sia in esecuzione. Postman è uno strumento che consente di inviare richieste HTTP agli endpoint definiti nella tua applicazione, ma affinché le richieste possano essere elaborate correttamente, il server deve essere in esecuzione e pronto per rispondere alle richieste in ingresso.
- Apri Postman e crea una nuova richiesta POST per l’URL del tuo endpoint di inserimento degli utenti (ad esempio,
http://localhost:8080/in). - Assicurati che l’opzione “Body” sia impostata su “raw” e seleziona il formato del corpo della richiesta (di solito JSON).
- Nel corpo della richiesta, fornisci i dettagli dell’utente che desideri inserire, ad esempio:
{
“nome”: “Mario”,
“cognome”: “Rossi”
}
Spring Boot supporta annotazioni come @PutMapping e @DeleteMapping. Queste annotazioni sono utilizzate per mappare le richieste HTTP PUT e DELETE a metodi nei controller, semplificando la gestione di tali richieste. Ecco una implementazione dei metodi mappati:
Illustriamo un progetto che include anche l’ annotazione @Configuration che è utilizzata per segnalare che una classe contiene definizioni di Bean e configurazioni di Spring. Come vedremo risulterà invece essere utile per definire bean che sono necessari in tutta l’ applicazione:
Spring Data - JPA
Progetto JAR Spring Boot che implementa la JPA per inserire e recuperare dati da una tabella Auto in un database MySQL. Vediamo i passaggi per la realizzazione pratica:
- Crea il Progetto Spring Boot.
- Configura le Dipendenze in
pom.xml. - Configura il Database MySQL.
- Crea l’Entity
Auto. - Crea il Repository JPA per
Auto. - Crea il Service per gestire la logica di inserimento e recupero delle
Auto. - Crea il Controller per esporre i servizi REST.
- Esegui il progetto.
Per quanto riguarda il POM la configurazione è inizialmente automatica in quanto in fase di creazione progetto vengono aggiunte le dipendenze, nello specifico Spring Web e Spring Data, ovviamente per lavorare in MySQL è necessario il connettore, la cui dipendenza è la seguente:
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.33</version>
</dependency>
Nel file src/main/resources/application.properties, configura il collegamento al database MySQL. Dovrai inserire i dettagli della connessione al tuo database.
spring.application.name=auto
# Configurazione connessione MySQL
spring.datasource.url=jdbc:mysql://localhost:3306/noleggioauto
spring.datasource.username=root
spring.datasource.password=root
# Dialetto e strategy per JPA
#spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect
Di seguito la classe Auto che rappresenta l’ entità (tabella ) auto
Per gestire l’ accesso ai dati è necessario creare una interfaccia che estende la classe JpaRepository la quale viene utilizzata per eseguire operazioni di base sul database come creazione, lettura, aggiornamento e cancellazione (CRUD) senza dover scrivere manualmente query SQL.
Metodi principali di JpaRepository
L’interfaccia JpaRepository fornisce molti metodi predefiniti che possono essere utilizzati direttamente senza scrivere query personalizzate. Di seguito i metodi principali:
Metodi CRUD
Questi metodi eseguono le classiche operazioni CRUD:save(S entity): Salva o aggiorna un’entità nel database.saveAll(Iterable<S> entities): Salva o aggiorna più entità in una sola operazione.findById(ID id): Cerca un’entità per il suo ID.existsById(ID id): Verifica se esiste un’entità con un determinato ID.findAll(): Restituisce tutte le entità di un determinato tipo.findAllById(Iterable<ID> ids): Restituisce tutte le entità con gli ID forniti.count(): Conta il numero di entità presenti.deleteById(ID id): Elimina un’entità per ID.delete(T entity): Elimina un’entità specifica.deleteAll(): Elimina tutte le entità.
Metodi per ordinamento e paginazione
Spring Data JPA fornisce metodi utili per ordinare i risultati o suddividerli in pagine:findAll(Sort sort): Restituisce tutte le entità ordinate in base a un criterio specificato.findAll(Pageable pageable): Restituisce le entità paginando i risultati.
Metodi specifici JPA
flush(): Scrive le modifiche attualmente presenti nel contesto di persistenza nel database.saveAndFlush(S entity): Salva un’entità e poi esegue unflushdel contesto di persistenza.deleteInBatch(: Elimina un gruppo di entità in un’unica query.Iterable<T> entities)
La logica del Business per inserire e recuperare i dati verrà implementata in una classe annotata come @Service
findBy[NomeProprietà]([TipoParametro])
- findBy: Cerca record.
- countBy: Conta i record corrispondenti.
- deleteBy: Elimina record corrispondenti.
- existsBy: Controlla se esiste un record corrispondente.
Possiamo anche combinare più condizioni con parole chiave come:
- And: per combinare più condizioni
- (es.
findByMarcaAndModello).
- (es.
- Or: per specificare condizioni alternative
- (es.
findByMarcaOrModello).
- (es.
- OrderBy: per ordinare i risultati
- (es.
findByMarcaOrderByModelloAsc).
- (es.
GreaterThan: Cerca elementi con un valore maggiore.LessThan: Cerca elementi con un valore minore.Between: Cerca elementi il cui valore è compreso tra due valori.IsNull/IsNotNull: Cerca elementi con un valorenullonon null.Like/NotLike: Cerca elementi usando il pattern SQLLIKE.Containing: Cerca elementi che contengono una stringa.StartingWith: Cerca elementi il cui campo inizia con una stringa.EndingWith: Cerca elementi il cui campo finisce con una stringa.IgnoreCase: Ignora la distinzione tra maiuscole e minuscole.
Un esempio pratico per il progetto Auto:
Per esporre le API REST e quindi inserire, ricercare, modificare ed eliminare Auto andiamo ad implementare la classe @RestController
Avviamo l’ applicazione ed attraverso Postman possiamo testare la nostra API REST
Di seguito un progetto che implementa una semplice API REST in Spring Boot per gestire libri utilizzando Spring Data JPA e MySQL. Il progetto prevede l’inserimento, la ricerca, la modifica e la cancellazione di libri da una tabella “libri”. Oltre ai metodi nativi forniti da JpaRepository, includerò anche due query custom con JPQL utilizzando l’annotazione @Query.
Vediamo i passaggi per la realizzazione pratica:
- Crea il progetto Spring Boot
- Configura il file
application.propertiesper connettersi a MySQL - Crea l’entità
Libro - Crea il repository con metodi personalizzati
- Crea una classe di Servizio per gestire la logica del business
- Crea il controller per le operazioni CRUD
- Testa l’API con Postman
Progetto generato con Spring Initializr ed importato in Maven per essere implementato. Di seguito la classe Libri che rappresenta la tabella (libri) in MySQL
L’ interfaccia LibriRepository che estende JpaRepository contiene le query method (metodi derivati ) e query personalizzate con JPQL (Java Persistence Query Language) oltre ai metodi predefiniti, utilizzati direttamente senza scrivere query.
Optional<E> è una classe introdotta in Java 8 che rappresenta un contenitore opzionale per valori che possono essere presenti o assenti.
In questo contesto, quando si utilizza il metodo come findById in Spring Data JPA, questi restituiscono un oggetto Optional<E>, dove E è il tipo dell’entità. Questo ti permette di gestire in modo più sicuro i risultati che potrebbero essere assenti (come nel caso in cui non si trovi un libro con l’ID specificato).
Di seguito la classe di LibriServizi annotata come @Service che implementa la logica del business per gestire la tabella libri. Possiamo notare che attraverso l’ annotazione @Autowired viene iniettata l’ interfaccia JPA per utilizzare i relativi metodi.
Download progetto: API Rest Biblioteca
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut elit tellus, luctus nec ullamcorper mattis, pulvinar dapibus leo.
JAR - Java Desktop e Servizi Rest
Se abbiamo un progetto Spring Boot che implementa un servizio REST, sarà un’applicazione Java (o un’applicazione desktop Java) che interagirà con questi servizi, puoi utilizzare librerie HTTP come Apache, HttpClient o HttpURLConnection.
Il progetto che contiene i servizi REST è ‘Servizi‘, presente in questo articolo, mentre il progetto Java Desktop che interagirà con tali servizi è il seguente:
I blog often and I truly appreciate your content. The article has truly peaked my interest.
I am going to book mark your website and keep checking for
new details about once per week. I opted in for your RSS feed
too.