Sin dal suo rilascio nel 1995, Java è uno dei linguaggi di pro­gram­ma­zio­ne più popolari e più uti­liz­za­ti. Il lin­guag­gio orientato agli oggetti mostra i suoi punti di forza so­prat­tut­to nella rea­liz­za­zio­ne di ap­pli­ca­zio­ni aziendali complesse (online o offline). In com­bi­na­zio­ne con il Java Runtime En­vi­ron­ment (JRE), queste ap­pli­ca­zio­ni si con­trad­di­stin­guo­no so­prat­tut­to per la loro natura di mul­ti­piat­ta­for­ma, che le rende di­spo­ni­bi­li a un pubblico par­ti­co­lar­men­te vasto.

Al fine di sem­pli­fi­ca­re il lavoro con Java sono stati svi­lup­pa­ti negli ultimi decenni diversi framework che for­ni­sco­no al­l'u­ten­te una struttura di base pronta all'uso per lo sviluppo di programmi Java. Uno dei più noti è il framework open source Spring, ri­la­scia­to nel 2003, che riduce si­gni­fi­ca­ti­va­men­te la com­ples­si­tà delle spe­ci­fi­che standard Java ("J2EE" o "Java Platform") e del modello di com­po­nen­te En­ter­pri­se JavaBeans ("EJB"). Dal rilascio di Spring Boot, che sem­pli­fi­ca ul­te­rior­men­te la con­fi­gu­ra­zio­ne di nuovi progetti Spring, il framework si è di­mo­stra­to una scelta ec­cel­len­te e di facile utilizzo per chi non vuole partire da zero nello sviluppo di una nuova ap­pli­ca­zio­ne Java.

In questo tutorial su Spring Boot im­pa­re­re­te quali sono i requisiti e i primi passi da compiere per uti­liz­za­re il framework modulare.

Cos'è Spring Boot?

Spring Boot è una soluzione "con­ven­tion over con­fi­gu­ra­tion" per il framework Spring di Java, che è stato ri­la­scia­to nel 2012 e riduce la com­ples­si­tà di con­fi­gu­ra­zio­ne di nuovi progetti Spring. A questo scopo, Spring Boot definisce una con­fi­gu­ra­zio­ne 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 ap­pli­ca­zio­ni in­di­pen­den­ti e pronte per la pro­du­zio­ne basate su Spring può essere no­te­vol­men­te sem­pli­fi­ca­ta, motivo per cui la maggior parte delle nuove ap­pli­ca­zio­ni Spring sono basate anche su Spring Boot.

Spring Boot offre i seguenti vantaggi:

  • pos­si­bi­li­tà di in­cor­po­ra­re di­ret­ta­men­te ap­pli­ca­zio­ni web server/container come Apache Tomcat o Jetty, per cui non è ne­ces­sa­rio l'uso di file WAR (Web Appli­ca­tion Archive);
  • con­fi­gu­ra­zio­ne Maven sem­pli­fi­ca­ta grazie ai POM "Starter" (Project Object Models);
  • con­fi­gu­ra­zio­ne au­to­ma­ti­ca di Spring, ove possibile;
  • fornitura di ca­rat­te­ri­sti­che non fun­zio­na­li come metriche o con­fi­gu­ra­zio­ni ester­na­liz­za­te.

Con Spring Boot, l'azienda di sviluppo Pivotal Software ha dato al framework, ri­la­scia­to nel 2005, un approccio moderno e orientato al futuro. L'e­sten­sio­ne beneficia della tec­no­lo­gia di base del framework Spring, che è stata mi­glio­ra­ta nel corso degli anni e ha svolto un ruolo im­por­tan­te anche in Spring Boot. Trovate in­for­ma­zio­ni det­ta­glia­te sul framework open source (Apache License 2.0) nel nostro det­ta­glia­to articolo sul popolare framework Java.

Tutorial su Spring Boot: requisiti, in­stal­la­zio­ne e primi passi

Sin dal rilascio di Spring Boot, il software di Pivotal Software è con­si­de­ra­to una delle migliori soluzioni per svi­lup­pa­re mi­cro­ser­vi­zi in Java. Grazie ai circa 20 moduli del framework di base, che possono essere as­sem­bla­ti a piacere, Spring Boot è adatto anche per diversi altri scenari, anche se non può essere clas­si­fi­ca­to spe­ci­fi­ca­men­te come framework per ap­pli­ca­zio­ni web, né come soluzione classica per ap­pli­ca­zio­ni desktop.

Prima di ap­pro­fon­di­re la con­fi­gu­ra­zio­ne e la creazione di un nuovo progetto e la struttura iniziale di Spring Boot nel suc­ces­si­vo tutorial (in italiano), ci occupiamo in­nan­zi­tut­to dei requisiti tecnici e del­l'im­po­sta­zio­ne dei com­po­nen­ti di progetto richiesti.

Quali sono i requisiti di sistema per Spring Boot?

Spring Boot è basato in­te­ra­men­te su Java, motivo per cui il Java Runtime En­vi­ron­ment (Java Platform) è il com­po­nen­te software centrale per far fun­zio­na­re il framework. Poiché non viene eseguita soltanto l'ap­pli­ca­zio­ne, ma la si utilizza anche per lo sviluppo con Java, è ne­ces­sa­ria almeno la versione 8 (o 1.8) del co­sid­det­to Java De­ve­lo­p­ment Kit (JDK). Oltre al­l'am­bien­te runtime, contiene utili strumenti per la pro­gram­ma­zio­ne e il test di ap­pli­ca­zio­ni Java. È di­spo­ni­bi­le sia per Linux, sia per Windows e macOS, quindi potete scegliere li­be­ra­men­te il sistema operativo.

Na­tu­ral­men­te è ne­ces­sa­rio che sul vostro sistema sia in­stal­la­ta anche la versione attuale del framework Spring.

Sia Maven (3.3 o superiore) che Gradle (4.4 o superiore) possono essere uti­liz­za­ti come strumenti di co­stru­zio­ne (build tool).

Se volete uti­liz­za­re un server web per eseguire la vostra ap­pli­ca­zio­ne Java su base servlet potete scegliere tra tre opzioni: Apache Tomcat (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 cor­ri­spon­den­ti file JAR (Java Archive) o WAR (Web Ap­pli­ca­tion Archive) nel percorso della classe (Classpath). Java utilizza questo percorso nel file system per cercare i file ese­gui­bi­li. I file di archivio per Spring Boot possono essere creati in due modi diversi:

  • potete in­stal­la­re e uti­liz­za­re Maven o Gradle per con­fi­gu­ra­re il framework del progetto, comprese le di­pen­den­ze ne­ces­sa­rie, in­te­ra­men­te da soli,
  • oppure accedere al servizio web Spring Ini­tia­li­zr, creare la con­fi­gu­ra­zio­ne di Spring Boot e sca­ri­car­la poi come modello di progetto finito.

La par­ti­co­la­ri­tà di que­st'ul­ti­ma soluzione è che è possibile creare i file JAR at­tra­ver­so un'in­ter­fac­cia web che è molto facile da usare e sem­pli­fi­ca enor­me­men­te il processo. Poiché l'I­ni­tia­li­zr utilizza anche Maven o Gradle per generare i file, il risultato non dif­fe­ri­sce da quello che ottenete con la procedura manuale. Per questo tutorial su Java o Spring Boot abbiamo quindi deciso di uti­liz­za­re il Web Assistant, a cui potete accedere mediante l'in­di­riz­zo start.spring.io.

N.B.

Se scegliete di usare lo Spring Ini­tia­li­zr è ne­ces­sa­rio in­stal­la­re anche Java e Maven o Gradle per poter lavorare alla vostra ap­pli­ca­zio­ne Spring Boot.

Una volta aperto lo Spring Ini­tia­li­zr, è possibile definire una serie di proprietà spe­ci­fi­che per la vostra prima ap­pli­ca­zio­ne Spring Boot: per prima cosa definite il sistema di co­stru­zio­ne se­le­zio­nan­do "Maven Project" o "Gradle Project". Nella seconda riga potete scegliere il lin­guag­gio classico di Java o in al­ter­na­ti­va un altro lin­guag­gio della famiglia Java, come Kotlin o Groovy. È inoltre possibile definire la versione Spring Boot sot­to­stan­te, i metadati del progetto (compresa la versione Java) e tutte le di­pen­den­ze rilevanti (database, funzioni di sicurezza, in­ter­fac­ce web, servizi cloud, ecc.). Infine, cliccate su "Generate Project" per creare i file di progetto.

Immagine: Spring Initializr: creazione di un progetto Spring Boot basato su Maven
Il formato WAR amplia quello JAR con diversi com­po­nen­ti web, come il file di con­fi­gu­ra­zio­ne XML web.xml, che descrive il processo di de­ploy­ment.
Consiglio

Se volete creare il vostro progetto Spring Boot da soli con Maven o Gradle, potete con­sul­ta­re le guide al­l'in­stal­la­zio­ne nei manuali ufficiali online.

Come eseguire il progetto Spring Boot creato

Dallo Spring Ini­tia­li­zr potete scaricare i file di progetto generati sotto forma di archivio ZIP che dovete poi de­com­pri­me­re. Nella cartella de­com­pres­sa troverete, tra le altre cose, il ri­spet­ti­vo file di con­fi­gu­ra­zio­ne: se avete se­le­zio­na­to Gradle per la gestione della com­pi­la­zio­ne, il file sarà build.gradle; per i progetti Maven, invece, dovreste trovare il file pom.xml. In que­st'ul­ti­mo caso, che si applica anche alla procedura del nostro tutorial su Spring Boot, il contenuto del file di con­fi­gu­ra­zio­ne è simile a questo:

Immagine: Parte del file di configurazione Maven pom.xml
Il file di con­fi­gu­ra­zio­ne di Maven è ca­rat­te­riz­za­to dalla tipica struttura XML, preceduto da im­por­tan­ti metadati.

Con l'aiuto del ri­spet­ti­vo software di com­pi­la­zio­ne, è possibile creare dai file di archivio un'ap­pli­ca­zio­ne Spring Boot ese­gui­bi­le. Se uti­liz­za­te Maven, aprite il terminale o il prompt dei comandi ed eseguite il seguente comando nella cartella di de­sti­na­zio­ne (la cartella dei file Spring Boot):

mvn clean install
Immagine: Prompt dei comandi di Windows: generazione del file JAR con Maven
Maven funziona secondo il modello "con­ven­tion over con­fi­gu­ra­tion", motivo per cui le im­po­sta­zio­ni di base, come il formato di output JAR, vengono applicate au­to­ma­ti­ca­men­te durante il processo di com­pi­la­zio­ne, a meno che non si for­ni­sca­no istru­zio­ni spe­ci­fi­che.

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'e­la­bo­ra­zio­ne del comando sono andati a buon fine ricevete il messaggio "BUILD SUCCESS". Il file ese­gui­bi­le 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":

Immagine: File JAR generato nella cartella "target" di Maven su Windows 10
La creazione dei file di archivio può ri­chie­de­re alcuni minuti, a seconda di quante di­pen­den­ze avete pre­ce­den­te­men­te aggiunto nello Spring Ini­tia­li­zr.

Per eseguirla uti­liz­zan­do Java digitate il seguente comando:

java -jar demo-0.0.1-SNAPSHOT.jar
Immagine: Inizializzazione dell'applicazione Spring Boot
Per avviare l'ap­pli­ca­zio­ne Spring Boot è ne­ces­sa­rio eseguire il codice indicato nella cartella del file JAR (target).

Il nome del file JAR, in corsivo nel­l'e­sem­pio di codice a fini espli­ca­ti­vi, deve essere so­sti­tui­to di con­se­guen­za se diverso da quello qui men­zio­na­to. Guardando l'output nella riga di comando è possibile vedere se l'ap­pli­ca­zio­ne Spring Boot è stata avviata con successo. Verranno avviati anche eventuali server web integrati, come Tomcat. Potete in­di­riz­zar­lo con il browser di vostra scelta spe­ci­fi­can­do 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 nel­l'in­te­gra­zio­ne di fonti di dati in qualsiasi database SQL o NoSQL. Non è quindi ne­ces­sa­rio scrivere alcun codice ag­giun­ti­vo per creare una nuova fonte di dati, basta ag­giun­ge­re le di­pen­den­ze e i dettagli di con­fi­gu­ra­zio­ne richiesti. Ciò è reso possibile dal­l'in­ter­fac­cia di database JDBC (Java Database Con­nec­ti­vi­ty), per la quale è ne­ces­sa­rio creare prima un record di avvio nel file di con­fi­gu­ra­zio­ne, se non avete aggiunto la di­pen­den­za durante la creazione del progetto con Spring Ini­tia­li­zr (lo stesso vale per l'ag­giun­ta di ulteriori di­pen­den­ze).

Gli utenti Maven devono ag­giun­ge­re 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 ri­spet­ti­vo file di con­fi­gu­ra­zio­ne può essere aperto con qualsiasi editor di codice di­spo­ni­bi­le in commercio. L'im­por­tan­te è che il file venga salvato nuo­va­men­te in formato XML o Gradle dopo che sono state apportate le modifiche.

Nel secondo passo, ag­giun­ge­te la di­pen­den­za per il sistema di gestione del database richiesto al ri­spet­ti­vo file di con­fi­gu­ra­zio­ne della com­pi­la­zio­ne. In questo tutorial su Spring Boot col­le­ghia­mo la nostra ap­pli­ca­zio­ne con un database MySQL che vogliamo uti­liz­za­re per la nostra ap­pli­ca­zio­ne e che abbiamo già in­stal­la­to in pre­ce­den­za.

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 con­fi­gu­ra­zio­ne Gradle è ne­ces­sa­rio ag­giun­ge­re la seguente riga per stabilire la con­nes­sio­ne al database MySQL:

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

Ag­giun­ge­te quindi alcune proprietà al file PRO­PER­TIES "ap­pli­ca­tion". 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 con­fi­gu­ra­zio­ne:

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 uti­liz­za­re MySQL come di consueto per creare un database con le tabelle di dati de­si­de­ra­te, sempre che non l'abbiate già fatto. I neofiti possono trovare in­for­ma­zio­ni det­ta­glia­te sul­l'u­ti­liz­zo del sistema di gestione del database re­la­zio­na­le nel nostro tutorial completo su MySQL.

Come generare il cer­ti­fi­ca­to SSL/TLS e abilitare l’HTTPS

Per im­po­sta­zio­ne pre­de­fi­ni­ta, un'ap­pli­ca­zio­ne Spring Boot creata utilizza il pro­to­col­lo HTTP non protetto e la porta TCP 8080 per con­net­ter­si al suo server web. Per impostare invece l'HTTPS protetto e la porta TCP 443 sono necessari un cer­ti­fi­ca­to SSL TLS e le proprietà ap­pro­pria­te nel file PRO­PER­TIES "ap­pli­ca­tion".

Il primo può essere ottenuto da un'au­to­ri­tà di cer­ti­fi­ca­zio­ne o creando un cer­ti­fi­ca­to au­to­fir­ma­to uti­liz­zan­do l'am­bien­te runtime di Java che, grazie al Ma­na­ge­ment Utility Key Tool, uno strumento a riga di comando, permette di creare fa­cil­men­te file PKCS12 (cer­ti­fi­ca­to X.509 e chiave privata compresi) per server come Tomcat, Exchange, IIS, ecc. Ad esempio, se uti­liz­za­te un server Tomcat, digitate il seguente comando nel prompt dei comandi o nel terminale per generare il file keystore per l'ap­pli­ca­zio­ne Spring Boot:

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

Per per­so­na­liz­za­re il cer­ti­fi­ca­to è ne­ces­sa­rio assegnare una password in­di­vi­dua­le e fornire alcune in­for­ma­zio­ni personali, sulla vostra azienda e la ri­spet­ti­va sede.

Il file keystore viene quindi au­to­ma­ti­ca­men­te po­si­zio­na­to 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 ap­pli­ca­zio­ne Spring Boot e ag­giun­ge­te le seguenti righe al file PRO­PER­TIES "ap­pli­ca­tion" già richiesto per l'in­te­gra­zio­ne 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 ese­gui­bi­le che si connetta a Tomcat via HTTPS come da con­fi­gu­ra­zio­ne, usando il seguente comando:

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

Come sem­pli­fi­ca­re il debug del­l'ap­pli­ca­zio­ne Spring Boot con Spring Cloud Sleuth e Zipkin

Eseguire test costanti è uno dei compiti più im­por­tan­ti nello sviluppo di software, perché solo in questo modo è possibile rilevare e cor­reg­ge­re tutti gli errori di pro­gram­ma­zio­ne. Tuttavia, la va­lu­ta­zio­ne dei file di log è so­li­ta­men­te molto complessa, rendendo spesso il processo di debug molto di­spen­dio­so in termini di tempo, spe­cial­men­te per i mi­cro­ser­vi­zi. Al termine di questo tutorial su Spring Boot vogliamo pre­sen­ta­re le soluzioni di trac­cia­men­to Spring Cloud Sleuth e Zipkin per mo­ni­to­ra­re l'ap­pli­ca­zio­ne di Spring Boot.

Uti­liz­zan­do le due ap­pli­ca­zio­ni di trac­cia­men­to è possibile tracciare fa­cil­men­te tutte le richieste at­tra­ver­so un con­trol­ler REST pre­ce­den­te­men­te impostato e vi­sua­liz­za­re l'e­se­cu­zio­ne temporale in qualsiasi momento.

Primo passaggio: ag­giun­ge­re Spring Cloud Sleuth al progetto

Per prima cosa dovete includere il modulo Sleuth nel­l'ap­pli­ca­zio­ne Spring Boot im­po­stan­do la di­pen­den­za nel file di con­fi­gu­ra­zio­ne della com­pi­la­zio­ne. Per fare questo, ag­giun­ge­te il seguente contenuto al file pom.xml se uti­liz­za­te 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 con­fi­gu­ra­zio­ne:

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

Secondo passaggio: ag­giun­ge­re i log Sleuth nel file di classe del con­trol­ler REST

Il con­trol­ler REST della vostra ap­pli­ca­zio­ne Spring Boot deve ora essere con­fi­gu­ra­to in modo da elaborare i file di log di Sleuth come de­si­de­ra­to. A questo scopo, ag­giun­ge­te il seguente testo di con­fi­gu­ra­zio­ne al file .class del con­trol­ler, tenendo conto che il nome del pacchetto (qui spring-boot-tutorial) cor­ri­spon­de 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 del­l'ap­pli­ca­zio­ne Spring nelle proprietà

Per as­si­cu­rar­si che il nome del­l'ap­pli­ca­zio­ne Spring Boot sia vi­sua­liz­za­to cor­ret­ta­men­te in Zipkin è ne­ces­sa­rio spe­ci­fi­ca­re il nome nel file PRO­PER­TIES "ap­pli­ca­tion". Se salvate la con­fi­gu­ra­zio­ne su un server di con­fi­gu­ra­zio­ne Spring Cloud, fate lo stesso nel file PRO­PER­TIES "bootstrap":

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

Quarto passaggio: ag­giun­ge­re Zipkin al progetto

Zipkin aiuta a mo­ni­to­ra­re e gestire i log di Sleuth. Il software open source è co­sti­tui­to da un'in­ter­fac­cia utente e da una com­po­nen­te server. Per entrambe è ne­ces­sa­rio ag­giun­ge­re le di­pen­den­ze al ri­spet­ti­vo file di con­fi­gu­ra­zio­ne della com­pi­la­zio­ne. Gli utenti Maven in­se­ri­sco­no 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 con­fi­gu­ra­zio­ne Gradle le nuove righe si pre­sen­ta­no, invece, così:

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

Quinto passaggio: con­sen­ti­re al­l'ap­pli­ca­zio­ne di agire come server Zipkin

Il passo suc­ces­si­vo è quello di as­si­cu­ra­re che il vostro progetto Spring Boot possa agire come un server Zipkin. A tale scopo, create un file con il nome zipkin.pro­per­ties e ag­giun­ge­te le seguenti righe:

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

Attivate quindi il com­po­nen­te 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 ese­gui­bi­le nel solito modo ed eseguite in seguito l'ap­pli­ca­zio­ne, potete rag­giun­ge­re il server Zipkin al­l'in­di­riz­zo http://localhost:9411/zipkin.

Sesto passaggio: ag­giun­ge­re la di­pen­den­za Spring Cloud e Zipkin

Ag­giun­ge­te un'ultima di­pen­den­za al file di con­fi­gu­ra­zio­ne della com­pi­la­zio­ne 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: con­fi­gu­ra­re l'e­spor­ta­zio­ne dei log Sleuth sul server Zipkin

Ag­giun­ge­te l'oggetto Al­ways­Sam­pler (Bean) al file Java del­l'ap­pli­ca­zio­ne Spring Boot per con­sen­ti­re l'e­spor­ta­zio­ne au­to­ma­ti­ca dei log di Sleuth sul server Zipkin:

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

Ottavo passaggio: spe­ci­fi­ca­re l'URL di base del server Zipkin nel file PRO­PER­TIES "ap­pli­ca­tion"

Nel­l'ul­ti­mo passaggio, spe­ci­fi­ca­te l'URL di base del server Zipkin nelle proprietà del­l'ap­pli­ca­zio­ne aprendo nuo­va­men­te il file PRO­PER­TIES del progetto Spring Boot e ag­giun­gen­do la seguente riga:

spring.zipkin.baseUrl = http://localhost:9411/zipkin/
Vai al menu prin­ci­pa­le