1.

Riferimenti:
https://nttdataitalia.percipio.com/courses/8f421b0f-8b43-4e5d-b870-6bfe9b41f8c7/videos/a3b78fb3-
d50c-4425-86ef-2097f508300c

Spring Boot Microservices: Getting Started, Spring Boot 2.3.2

2. Vantaggi di springboot
Springboot è bello perchè specificando quattro opzioni ti prepara il progetto semilavorato su cui
aggiungere il codice che serve

- pro: facile per mettere in piedi un semilavorato

- contro: non puoi decidere dipendenze, versioni etc delle librerie

3. Setup springboot
Per mettere in piedi springboot:

- installare jdk (1.7 o successive) e definire la JAVA_HOME

- installare maven (download e extract zip) e aggiungere il folder bin al PATH

4. Esempi di progetti in Eclipse

Di seguito una guida passo passo usando Eclipse come ambiente di sviluppo.

a. Setup iniziale a riga di comando

Per mettere in piedi un progettino maven:

- spostarsi nella cartella del workspace di eclipse e stabilire

groupId: il gruppo di progetti a cui appartiene la nostra app, solitamente è il domain al contrario

e costituisce anche il nome del package dove finisce tutto il codice

artifactId: il nome del nostro progetto, nonchè il nome del jar che otterremo dopo la build

- dopdichè digitare il comando mvn archetype:generate per generare il progetto

mvn archetype:generate -DgroupId=com.skillsoft.springboot \

-DartifactId=SpringBootHelloApp \

-DarchetypeArtifacId=maven-archetype-quickstart \

-DinteractiveMode=false
- se l'esecuzione produce una "build success" troverete una sottocartella SpringBootHelloApp che
contiene il ns progetto, ossia

pom.xml

folder src contenente main/<package usato>/App.java (classe stub del progetto)

folder test

A questo punto possiamo importare il progetto in eclipse come progetto maven esistente.

b. Modifiche per ottenere la nostra prima Hello World

Il pom.xml generato da maven si presenta come segue:

Notare che la versione della nostra app (servirà in futuro) viene specificata nell’apposito tag:
<version>1.0.-SNAPSHOT</version>

Con poche semplici modifiche otterremo la nostra prima app springboot:

Aggiungeremo un nuovo tag “parent”, figlio del tag principale “project” specificando che il progetto di
partenza è spring-boot-starter-parent e gli daremo la versione 2.3.1.RELEASE: in pratica diciamo a
maven che accettiamo tutte le dipendenze di default del progetto di partenza 'parent': al variare della
versione del progetto di partenza cambieranno le versioni dei package dipendenti

Aggiungeremo alle dependecies già presenti un nuovo tag <dependency> contenente

<artifactId> spring-boot-starter

<groupId> org.springframewoork.boot

Queste le poche e semplici modifiche per creare una app con le sole librerie core core di spring:
Nota: <packaging>jar</packaging> specifica che verrà prodotto un jar, ossia una app standalone
autocontenuta

Adesso modifichiamo App.java per aggiungere logica minima:

Aggiungiamo le seguenti annotation:

@SpringBootConfiguration <-- utilizzeremo la configurazione per una application, ci

aspetteremo nella classe un metodo public static void main
 @EnableAutoConfiguration <-- configurerà tutto quello che serve in automatico e in modo
trasparente (containers bean etc)

@ComponentScan <-- cercherà nel package corrente e nei sotto package le eventuali necessità
di 'injectable beans'

Nella public static void main( String[] args ) scriveremo

SpringApplication.run(App.class, args) per eseguire questa classe con springboot

System.out.println("Hello World!") ci permetterà di capire che l’applicazione è partita e ha girato

correttamente

A questo punto, facendo click dx sul pom.xml -> “maven” -> “update project” carichiamo dipendenze e
librerie necessarie, facendo click dx su app.java -> run As -> java application eseguiremo l'applicazione

L'output disegnerà il logo di spring, la versione e in fondo "Hello World!"

Nota alle annotation fin qui usate: usando @SpringBootApplication include in un sol colpo
@SpringBootConfiguration @EnableAutoConfiguration e @ComponentScan

Ecco dunque la versione finale di app.java:

c. Modifiche per ottenere la nostra prima MVC application che

usa spring boot e tomcat
Iniziamo modificando anzitutto il pom.xml

Tra le dependancies specificheremo con groupId org.spring.framework.boot due artifacts:

<artifactId>spring-boot-starter-web</artifactId>

vuol dire: applicazione web che userà spring mvc, Jackson per lavorare con JSON

<artifactId>spring-boot-starter-tomcat</artifactId>

vuol dire: container tomcat, non è obbligatorio, potremmo anche non metterlo e implicitamente verrà
usato tomcat

La nostra App.java resta identica alla precedente.

A questo punto, facendo click dx sul pom.xml -> “maven” -> “update project” carichiamo dipendenze e
librerie necessarie, facendo click dx su app.java -> run As -> java application eseguiremo l'applicazione:

Complichiamo le cose aggiungendo un nuovo package e una nuova classe:

<package usato>.control.HelloController.java

usiamo l’annotation @RestController per specificare che stiamo mettendo in piedi una Rest API
definiamo tre metodi public String ...() ciascuno con la sua @RequestMapping(value="/path...", method
= RequestMethod.GET ) che fanno ciascuno una return di una stringa costante

Eseguiamo ancora una volta la nostra java application: verrà fatto lo startup del server tomcat che avrà
dentro l'app da noi sviluppata, non sarà necessario creare un war, e con un browser andando su
localhost:8080 otterremo risposta dal metodo di default index()

Se nel pom togliamo <artifactId>spring-boot-starter-tomcat</artifactId> continuerà a funzionare uguale

d. Modifiche per ottenere la nostra prima MVC application che

usa spring boot e jetty o undertow

a partire dal precedente pom.xml facciamo le seguenti modifiche:

 escludiamo esplicitamente le dependencies tomcat usando il tag “exclusions”

 dichiariamo tra le dependecies l'artifactId spring-boot-starter-jetty
Rieseguendo l’applicazione nell'output della console vedremo che il server che parte è jetty

Stesso ragionamento se invece di jetty vogliamo usare undertow application server:

escludiamo in modo esplicito tomcat e dichiariamo la dipendenza con undertow

e. Da applicazione web standalone ad applicazione web

deployabile su altro server
Rispetto al pom.xml visto in precedenza le modifiche sono le seguenti:

 cambiare il tag packaging da jar a war

 dependencies standard spring-boot-starter-web e spring-boot-starter-tomcat MA con un
<scope>provided</scope> per dire a springboot che l'application server non sarà Tomcat ma
sarà esterno
 aggiungere una sezione <build> che istruirà maven nella creazione del war usando il plugin
spring-boot-maven-plugin
Anche la nostra classe app.java cambia: dovrà estendere SpringBootServletInitializer e dovrà essere
fatto l'override del metodo “configure” in modo da poter essere registrata come 'configuration class'.

Il metodo main resta invariato.

La classe HelloController.java uguale ai precedenti esempi

A questo punto se proviamo l'esecuzione come applicazione java avremo lo stesso output dell'esempio
di applicazione con tomcat embedded, se invece facciamo il Maven Build (mvn clean verify) otterremo
un war deployabile su un application server esterno.

Il war prodotto dalla build di maven lo troveremo nella cartella target e può essere copiato nella cartella
webapps di una installazione qualsiasi di tomcat.

Notare che la risorsa sull'application server cambierà: bisognerà aggiungere alla url anche il nome del
war in questione!

f. Usare lo Spring Initializer per produrre lo scheletro di una

webapp
Adesso che abbiamo un minimo di familiarità con springboot capiamo come costruire una applicazione
con microservizi che ci servono

Spring Initializer è un tool web based che ci permette di generare la struttura base di un'applicazione per
spring boot.

Andare su http://start.spring.io per accedere all'nterfaccia che non scriverà il codice per noi ma farà solo
il setup di dipendenze etc per il nostro progetto:

nella parte sx sceglieremo linguaggio Java, versione di spring boot, groupId, artifactId, name,
description, packaging, java version e gli altri metadata del progetto

nella parte destra aggiungeremo le dipendenze che ci servono, comparirà un dialog che ci permetterà di
scegliere le caratteristiche della nostra app; nel nostro caso scegliamo "spring web" e clicchiamo infine
su "generate" che farà partire il download di un file zip che conterrà la cartella springinitializr con la
struttura base del mio progetto.

A questo punto stessa procedura eclipse per import maven project.

La struttura del progetto sarà molto simile a quella vista nel caso del war (paragrafo e):

pom.xml
 classe springinitializrapplication.java (invece della app.java)

A questo punto creeremo al solito il package ...controller con dentro la nostra classe HalloController.java
dentro cui inseriremo il codice visto negli esempi precedenti.

Nota: @GetMapping semplifica l'annotation @RequestMapping

A questo punto possiamo fare il run dell'application per far partire l'application server embedded

g. Il message internationalization con spring boot

In questo paragrafo vediamo come è possibile utilizzare una configurazione specifica per le lingue.

In pom.xml: aggiungiamo nelle dependecies spring-boot-starter-thymeleaf. Thymeleaf è un componente

(template engine html5) per fare le render all'utente dei dati utilizzando i message.properties per
quanto riguarda le scritte da visualizzare all'utente

Springinitializrapplication.java resta invariata

MessageController.java contiene al solito

l’annotation @Controller per specificare che la classe controllerà le risposte che arrivano dal
web per determinati paths

un metodo public String index() con annotation @GetMappings(value = "/home") che fa una
return della stringa "home": la stringa ritornata non è un messaggio per l'utente ma una "logical
view name". thymeleaf mappa questo name con una view fisica che starà dentro
src/main/resources/templates
src/main/resources/templates/home.html conterrà

tag html: <html xmlns:th="http://www.thymeleaf.org"> usa il motore thymeleaf

tag <h4 th:text="#{title}"/> visualizza valore contenuto nella variabile title

tag <p th:text="#{message}"/> visualizza valore contenuto nella variabile message

tali variabili sono definite nel messages.properties (vedi dopo)

src/main/resources/messages.properties conterrà

title=Hallo!

message=Wellcome to msg internationalization demo

Il file in questione usa il default locale (che dovrebbbe essere English US), per altre lingue utilizzeremo
un parametro "lang" nella url http://.../home?lang=french ma non essendo configurato un file per il
francese prenderà cmq quello di default

A questo punto adesso creiamo tra i src un package ...config e una nuova classe
InternationalizationService che estende WebMvcController che si occuperà di gestire
l'internationalization:
@Configuration significa che la classe dichiara uno o più bean methods:

bean localeresolver serve per determinare il default locale application

bean localechangeinterceptor serve per intercettare il parametro lang e impostarlo prima che
venga fatta la render

il bean localechangeinterceptor va aggiunto (add) nel registro degli interceptor facendo override
del metodo addInterceptors

A questo punto possiamo creare il file src/main/resources/messages_french.properties oppure il file

src/main/resources/messages_latin.properties etc che verranno usati qualora lang è french oppure latin
(rif url chiamata da browser http://.../home?lang=french)

5. Spring tools suite (STE) plugin di Eclipse

Cercare nel marketplace spring tools 4

Dopo l'installazione avremo in file->new->other filtrando per "spring" 2 nuovi wizard

import spring getting started content

spring starter project <- quello che ci serve per costruire una nuova app con springboot

Spring starter project produce una dialog con

service url http://start.spring.io visto in precedenza

name (del progetto), location, java version, packaging (jar, war...), type (maven), group, artifact,
package

(group.artifact), ...

cliccando next ci farà scegliere versione di springboot, le dependencies (es. spring web,
thymeleaf...) del pom

il tasto finish ci genererà il progetto vuoto con il pom già configurato e la classe
stsspringbootapplication di partenza

con il suo void main già preconfezionato.

(...)

notare nell'html la possibilità di inserire delle anchor tags

<a th:href="@{/hello}">Hello page</a> che thymeleaf tradurrà in link corretti

6. Altri esempi su alcune features di spring boot