Tutorial su Spring Boot: creazione di applicazioni Java con Spring Boot

Sin dal suo rilascio nel 1995, Java è uno dei linguaggi di programmazione più popolari e più utilizzati. Il linguaggio orientato agli oggetti mostra i suoi punti di forza soprattutto nella realizzazione di applicazioni aziendali complesse (online o offline). In combinazione con il Java Runtime Environment (JRE), queste applicazioni si contraddistinguono soprattutto per la loro natura di multipiattaforma, che le rende disponibili a un pubblico particolarmente vasto.

Al fine di semplificare il lavoro con Java sono stati sviluppati negli ultimi decenni diversi framework che forniscono all'utente una struttura di base pronta all'uso per lo sviluppo di programmi Java. Uno dei più noti è il framework open source Spring, rilasciato nel 2003, che riduce significativamente la complessità delle specifiche standard Java ("J2EE" o "Java Platform") e del modello di componente Enterprise JavaBeans ("EJB"). Dal rilascio di Spring Boot, che semplifica ulteriormente la configurazione di nuovi progetti Spring, il framework si è dimostrato una scelta eccellente e di facile utilizzo per chi non vuole partire da zero nello sviluppo di una nuova applicazione Java.

In questo tutorial su Spring Boot imparerete quali sono i requisiti e i primi passi da compiere per utilizzare il framework modulare.

Cos'è Spring Boot?

Spring Boot è una soluzione "convention over configuration" per il framework Spring di Java, che è stato rilasciato nel 2012 e riduce la complessità di configurazione di nuovi progetti Spring. A questo scopo, Spring Boot definisce una configurazione di base che include le linee guida per l'uso del framework e tutte le librerie di terze parti rilevanti, rendendo quindi l'avvio di nuovi progetti il più semplice possibile. In questo modo, la creazione di applicazioni indipendenti e pronte per la produzione basate su Spring può essere notevolmente semplificata, motivo per cui la maggior parte delle nuove applicazioni Spring sono basate anche su Spring Boot.

Spring Boot offre i seguenti vantaggi:

  • possibilità di incorporare direttamente applicazioni web server/container come Apache Tomcat o Jetty, per cui non è necessario l'uso di file WAR (Web Application Archive);
  • configurazione Maven semplificata grazie ai POM "Starter" (Project Object Models);
  • configurazione automatica di Spring, ove possibile;
  • fornitura di caratteristiche non funzionali come metriche o configurazioni esternalizzate.

Con Spring Boot, l'azienda di sviluppo Pivotal Software ha dato al framework, rilasciato nel 2005, un approccio moderno e orientato al futuro. L'estensione beneficia della tecnologia di base del framework Spring, che è stata migliorata nel corso degli anni e ha svolto un ruolo importante anche in Spring Boot. Trovate informazioni dettagliate sul framework open source (Apache License 2.0) nel nostro dettagliato articolo sul popolare framework Java.

Tutorial su Spring Boot: requisiti, installazione e primi passi

Sin dal rilascio di Spring Boot, il software di Pivotal Software è considerato una delle migliori soluzioni per sviluppare microservizi in Java. Grazie ai circa 20 moduli del framework di base, che possono essere assemblati a piacere, Spring Boot è adatto anche per diversi altri scenari, anche se non può essere classificato specificamente come framework per applicazioni web, né come soluzione classica per applicazioni desktop.

Prima di approfondire la configurazione e la creazione di un nuovo progetto e la struttura iniziale di Spring Boot nel successivo tutorial (in italiano), ci occupiamo innanzitutto dei requisiti tecnici e dell'impostazione dei componenti di progetto richiesti.

Quali sono i requisiti di sistema per Spring Boot?

Spring Boot è basato interamente su Java, motivo per cui il Java Runtime Environment (Java Platform) è il componente software centrale per far funzionare il framework. Poiché non viene eseguita soltanto l'applicazione, ma la si utilizza anche per lo sviluppo con Java, è necessaria almeno la versione 8 (o 1.8) del cosiddetto Java Development Kit (JDK). Oltre all'ambiente runtime, contiene utili strumenti per la programmazione e il test di applicazioni Java. È disponibile sia per Linux, sia per Windows e macOS, quindi potete scegliere liberamente il sistema operativo.

Naturalmente è necessario che sul vostro sistema sia installata anche la versioneattuale del framework Spring.

Sia Maven (3.3 o superiore) che Gradle (4.4 o superiore) possono essere utilizzati come strumenti di costruzione (build tool).

Se volete utilizzare un server web per eseguire la vostra applicazione Java su base servlet potete scegliere tra tre opzioni: ApacheTomcat (da 9.0), Jetty (da 9.4) e Undertow (da 2.0).

Come creare il vostro primo progetto Spring Boot

Spring Boot funziona come qualsiasi libreria standard di Java in cui dovete includere i corrispondenti file JAR (Java Archive) o WAR (Web Application Archive) nel percorso della classe (Classpath). Java utilizza questo percorso nel file system per cercare i file eseguibili. I file di archivio per Spring Boot possono essere creati in due modi diversi:

  • potete installare e utilizzare Maven o Gradle per configurare il framework del progetto, comprese le dipendenze necessarie, interamente da soli,
  • oppure accedere al servizio web Spring Initializr, creare la configurazione di Spring Boot e scaricarla poi come modello di progetto finito.

La particolarità di quest'ultima soluzione è che è possibile creare i file JAR attraverso un'interfaccia web che è molto facile da usare e semplifica enormemente il processo. Poiché l'Initializr utilizza anche Maven o Gradle per generare i file, il risultato non differisce da quello che ottenete con la procedura manuale. Per questo tutorial su Java o Spring Boot abbiamo quindi deciso di utilizzare il Web Assistant, a cui potete accedere mediante l'indirizzo start.spring.io.

N.B.

Se scegliete di usare lo Spring Initializr è necessario installare anche Java e Maven o Gradle per poter lavorare alla vostra applicazione Spring Boot.

Una volta aperto lo Spring Initializr, è possibile definire una serie di proprietà specifiche per la vostra prima applicazione Spring Boot: per prima cosa definite il sistema di costruzione selezionando "Maven Project" o "Gradle Project". Nella seconda riga potete scegliere il linguaggio classico di Java o in alternativa un altro linguaggio della famiglia Java, come Kotlin o Groovy. È inoltre possibile definire la versione Spring Boot sottostante, i metadati del progetto (compresa la versione Java) e tutte le dipendenze rilevanti (database, funzioni di sicurezza, interfacce web, servizi cloud, ecc.). Infine, cliccate su "Generate Project" per creare i file di progetto.

Consiglio

Se volete creare il vostro progetto Spring Boot da soli con Maven o Gradle, potete consultare le guide all'installazione nei manuali ufficiali online.

Come eseguire il progetto Spring Boot creato

Dallo Spring Initializr potete scaricare i file di progetto generati sotto forma di archivio ZIP che dovete poi decomprimere. Nella cartella decompressa troverete, tra le altre cose, il rispettivo file di configurazione: se avete selezionato Gradle per la gestione della compilazione, il file sarà build.gradle; per i progetti Maven, invece, dovreste trovare il file pom.xml. In quest'ultimo caso, che si applica anche alla procedura del nostro tutorial su Spring Boot, il contenuto del file di configurazione è simile a questo:

Con l'aiuto del rispettivo software di compilazione, è possibile creare dai file di archivio un'applicazione Spring Boot eseguibile. Se utilizzate Maven, aprite il terminale o il prompt dei comandi ed eseguite il seguente comando nella cartella di destinazione (la cartella dei file Spring Boot):

mvn clean install

Per i progetti Gradle, invece, il comando è il seguente:

gradle clean build

In entrambi i casi, se la creazione dei file di archivio e l'elaborazione del comando sono andati a buon fine ricevete il messaggio "BUILD SUCCESS". Il file eseguibile viene salvato nella cartella "target" (Maven) o nella cartella "build/libs" (Gradle). Nel nostro caso, il nome del file JAR è "demo-0.0.1-SNAPSHOT.jar":

Per eseguirla utilizzando Java digitate il seguente comando:

java -jar demo-0.0.1-SNAPSHOT.jar

Il nome del file JAR, in corsivo nell'esempio di codice a fini esplicativi, deve essere sostituito di conseguenza se diverso da quello qui menzionato. Guardando l'output nella riga di comando è possibile vedere se l'applicazione Spring Boot è stata avviata con successo. Verranno avviati anche eventuali server web integrati, come Tomcat. Potete indirizzarlo con il browser di vostra scelta specificando il seguente indirizzo:

http://localhost:8080

Come collegare Spring Boot al database e alla fonte di dati

Spring Boot fornisce un aiuto prezioso nella creazione e nell'integrazione di fonti di dati in qualsiasi database SQL o NoSQL. Non è quindi necessario scrivere alcun codice aggiuntivo per creare una nuova fonte di dati, basta aggiungere le dipendenze e i dettagli di configurazione richiesti. Ciò è reso possibile dall'interfaccia di database JDBC (Java Database Connectivity), per la quale è necessario creare prima un record di avvio nel file di configurazione, se non avete aggiunto la dipendenza durante la creazione del progetto con Spring Initializr (lo stesso vale per l'aggiunta di ulteriori dipendenze).

Gli utenti Maven devono aggiungere le seguenti righe al file pom.xml:

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

Gli utenti Gradle, invece, devono inserire il seguente record nel file build.gradle:

compile('org.springframework.boot:spring-boot-starter-jdbc')
N.B.

Il rispettivo file di configurazione può essere aperto con qualsiasi editor di codice disponibile in commercio. L'importante è che il file venga salvato nuovamente in formato XML o Gradle dopo che sono state apportate le modifiche.

Nel secondo passo, aggiungete la dipendenza per il sistema di gestione del database richiesto al rispettivo file di configurazione della compilazione. In questo tutorial su Spring Boot colleghiamo la nostra applicazione con un database MySQL che vogliamo utilizzare per la nostra applicazione e che abbiamo già installato in precedenza.

Il file pom.xml dei progetti Maven richiede per questo il seguente record nuovo:

<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
</dependency>

Nella configurazione Gradle è necessario aggiungere la seguente riga per stabilire la connessione al database MySQL:

compile('mysql:mysql-connector-java')

Aggiungete quindi alcune proprietà al file PROPERTIES "application". Trovate questo file al percorso \src\main\resources nella cartella del progetto Spring Boot. Aprite questo file di testo e inserite le seguenti righe di configurazione:

spring.datasource.driverClassName = com.mysql.jdbc.Driver
spring.datasource.url = jdbc:mysql://localhost:3306/PRODUCTSERVICE?autoreconnect = true
spring.datasource.username = root
spring.datasource.password = root
spring.datasource.tomcat.testOnBorrow = true
spring.datasource.tomcat.testWhileIdle = true
spring.datasource.tomcat.timeBetweenEvictionRunsMillis = 60000
spring.datasource.tomcat.minEvictableIdleTimeMillis = 30000
spring.datasource.tomcat.validationQuery = SELECT 1
spring.datasource.tomcat.max-active = 15
spring.datasource.tomcat.max-idle = 10
spring.datasource.tomcat.max-wait = 8000

Ora potete utilizzare MySQL come di consueto per creare un database con le tabelle di dati desiderate, sempre che non l'abbiate già fatto. I neofiti possono trovare informazioni dettagliate sull'utilizzo del sistema di gestione del database relazionale nel nostro tutorial completo su MySQL.

Come generare il certificato SSL/TLS e abilitare l’HTTPS

Per impostazione predefinita, un'applicazione Spring Boot creata utilizza il protocollo HTTP non protetto e la porta TCP 8080 per connettersi al suo server web. Per impostare invece l'HTTPSprotetto e la portaTCP 443 sono necessari un certificato SSL TLS e le proprietà appropriate nel file PROPERTIES "application".

Il primo può essere ottenuto da un'autorità di certificazione o creandoun certificato autofirmato utilizzando l'ambiente runtime di Java che, grazie al Management Utility Key Tool, uno strumento a riga di comando, permette di creare facilmente file PKCS12 (certificato X.509 e chiave privata compresi) per server come Tomcat, Exchange, IIS, ecc. Ad esempio, se utilizzate un server Tomcat, digitate il seguente comando nel prompt dei comandi o nel terminale per generare il file keystore per l'applicazione Spring Boot:

keytool -genkeypair -alias tomcat -storetype PKCS12 -keyalg RSA -keysize 2048 -keystore keystore.p12 -validity 3650

Per personalizzare il certificato è necessario assegnare una password individuale e fornire alcune informazioni personali, sulla vostra azienda e la rispettiva sede.

Il file keystore viene quindi automaticamente posizionato nella directory in cui è stato eseguito il comando (in questo tutorial su Spring Boot nella propria directory utente). Copiate il file "keystore" nella directory della vostra applicazione Spring Boot e aggiungete le seguenti righe al file PROPERTIES "application" già richiesto per l'integrazione del database:

server.port = 443
server.ssl.key-store = C:/demo/keystore.p12
server.ssl.key-store-password = springboot
server.ssl.key-store-type = PKCS12
server.ssl.key-alias = tomcat

Infine, create un nuovo file JAR eseguibile che si connetta a Tomcat via HTTPS come da configurazione, usando il seguente comando:

mvn -Dmaven.test.skip=true -DskipTests=true clean install

Come semplificare il debug dell'applicazione Spring Boot con Spring Cloud Sleuth e Zipkin

Eseguire test costanti è uno dei compiti più importanti nello sviluppo di software, perché solo in questo modo è possibile rilevare e correggere tutti gli errori di programmazione. Tuttavia, la valutazione dei file di log è solitamente molto complessa, rendendo spesso il processo di debug molto dispendioso in termini di tempo, specialmente per i microservizi. Al termine di questo tutorial su Spring Boot vogliamo presentare le soluzioni di tracciamento Spring Cloud Sleuth e Zipkin per monitorare l'applicazione di Spring Boot.

Utilizzando le due applicazioni di tracciamento è possibile tracciare facilmente tutte le richieste attraverso un controller REST precedentemente impostato e visualizzare l'esecuzione temporale in qualsiasi momento.

Primo passaggio: aggiungere Spring Cloud Sleuth al progetto

Per prima cosa dovete includere il modulo Sleuth nell'applicazione Spring Boot impostando la dipendenza nel file di configurazione della compilazione. Per fare questo, aggiungete il seguente contenuto al file pom.xml se utilizzate Maven:

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-sleuth</artifactId>
  <version>${spring-cloud-sleuth.version}</version>
  <type>pom</type>
  <scope>import</scope>
</dependency>

In caso di progetti Gradle inserite invece la seguente riga nel file di configurazione:

compile('org.springframework.cloud:spring-cloud-starter-sleuth')

Secondo passaggio: aggiungere i log Sleuth nel file di classe del controller REST

Il controller REST della vostra applicazione Spring Boot deve ora essere configurato in modo da elaborare i file di log di Sleuth come desiderato. A questo scopo, aggiungete il seguente testo di configurazione al file .class del controller, tenendo conto che il nome del pacchetto (qui spring-boot-tutorial) corrisponde al dominio del <groupId> nel file pom.xml:

package spring-boot-tutorial.sleuth;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@SpringBootApplication
@RestController
public class SleuthappApplication {
	private static final Logger LOG = Logger.getLogger(SleuthappApplication.class.getName());
	public static void main(String[] args) {
		SpringApplication.run(SleuthappApplication.class, args);
	}
	@RequestMapping("/")
	public String index() {
		LOG.log(Level.INFO, "Index API is calling");
		return "Sleuth: Spring-Boot-Tutorial-Test!";
	}
}

Terzo passaggio: elencare il nome dell'applicazione Spring nelle proprietà

Per assicurarsi che il nome dell'applicazione Spring Boot sia visualizzato correttamente in Zipkin è necessario specificare il nome nel file PROPERTIES "application". Se salvate la configurazione su un server di configurazione Spring Cloud, fate lo stesso nel file PROPERTIES "bootstrap":

spring.application.name = Spring-Boot-Tutorial-App

Quarto passaggio: aggiungere Zipkin al progetto

Zipkin aiuta a monitorare e gestire i log di Sleuth. Il software open source è costituito da un'interfaccia utente e da una componente server. Per entrambe è necessario aggiungere le dipendenze al rispettivo file di configurazione della compilazione. Gli utenti Maven inseriscono le seguenti righe nel file pom.xml:

<dependency>
  <groupId>io.zipkin.java</groupId>
  <artifactId>zipkin-server</artifactId>
</dependency>
<dependency>
  <groupId>io.zipkin.java</groupId>
  <artifactId>zipkin-autoconfigure-ui</artifactId>
<scope>runtime</scope>
</dependency>

Nella configurazione Gradle le nuove righe si presentano, invece, così:

compile('io.zipkin.java:zipkin-autoconfigure-ui')
compile('io.zipkin.java:zipkin-server')

Quinto passaggio: consentire all'applicazione di agire come server Zipkin

Il passo successivo è quello di assicurare che il vostro progetto Spring Boot possa agire come un server Zipkin. A tale scopo, create un file con il nome zipkin.properties e aggiungete le seguenti righe:

spring.application.name=zipkin
server.port=9411
logging.level.org.springframework.web=debug

Attivate quindi il componente server nel file Java del progetto:

package spring-boot-tutorial.zipkin;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import zipkin.server.EnableZipkinServer;

@SpringBootApplication
@EnableZipkinServer
public class ZipkinappApplication {
  public static void main(String[] args) {
    SpringApplication.run(ZipkinappApplication.class, args);
  }
}

Se create il file JAR eseguibile nel solito modo ed eseguite in seguito l'applicazione, potete raggiungere il server Zipkin all'indirizzo localhost/zipkin.

Sesto passaggio: aggiungere la dipendenza Spring Cloud e Zipkin

Aggiungete un'ultima dipendenza al file di configurazione della compilazione per collegare Sleuth e Zipkin.

Maven:

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-sleuth-zipkin</artifactId>
</dependency>

Gradle:

compile('org.springframework.cloud:spring-cloud-sleuth-zipkin')

Settimo passaggio: configurare l'esportazione dei log Sleuth sul server Zipkin

Aggiungete l'oggetto AlwaysSampler (Bean) al file Java dell'applicazione Spring Boot per consentire l'esportazione automatica dei log di Sleuth sul server Zipkin:

@Bean
public AlwaysSampler defaultSampler() {
	return new AlwaysSampler();
}

Ottavo passaggio: specificare l'URL di base del server Zipkin nel file PROPERTIES "application"

Nell'ultimo passaggio, specificate l'URL di base del server Zipkin nelle proprietà dell'applicazione aprendo nuovamente il file PROPERTIES del progetto Spring Boot e aggiungendo la seguente riga:

spring.zipkin.baseUrl = http://localhost:9411/zipkin/

Abbiamo una proposta per te:
Web hosting a partire da 1 €/mese!

Dominio gratis
Certificato SSL Wildcard incluso
Assistenza clienti 24/7
A partire da 1 €/mese IVA escl. per un anno,
poi 8 €/ mese IVA escl.