Primo progetto SpringBoot

Requisiti

Prima di procedere occorre installare:

1. Software Development Kit.

Questo comprende tutti gli strumenti per compilare Java. Un sito dove scaricarlo è il seguente: https://www.openlogic.com/openjdk-downloads

La versione da installare per queste lezioni è la 21. Su Linux Ubuntu/Debian si può installare anche tramite apt

sudo apt update
sudo apt install openjdk-21-jre

2. Maven

Apache Maven è un software che gestisce la configurazione, le dipendenze, compilazione, esecuzione e deploy per applicazioni Java. Si installa seguendo queste istruzioni https://maven.apache.org/install.html Su Linux:

sudo apt install maven

3. VS Code

Queste lezioni sono per l’IDE di riferimento utilizzato su cipiaceinfo.it, ovvero Visual Studio Code. Dopo averlo installato (https://code.visualstudio.com/) occorre installare i seguenti plugin:

• Java Extension Pack
• Spring Boot extension Pack

Il primo contiene un insieme di estensioni per gestire progetti Java, come la verifica del codice, l’autocompletamento, l’inserimento automatico di import, ecc. Il secondo invece serve per gestire i progetti Spring Boot ed integra Initializr dentro Vs Code.

Primo progetto

Per creare un progetto con Initializr.

1. Lanciare la Palette dei comandi (Ctr+shift+P) e scrivere “initializr”. Avviare “Spring Initializr: Create a Maven project…”.
2. Specificare la versione di SpringBoot (va bene 4.0.1 o comunque ultima versione)
3. Specificare il linguaggio Java
4. Scegliere il GroupId, ovvero l’identificativo univoco del progetto per Maven, di norma è il package base del progetto Java, qui useremo “it.cipiaceinfo”
5. Scegliere l’ArtifactId, ovvero il nome del file Jar. Mettiamo “helloworld”
6. A questo punto verrà proposto il package base del progetto “it.cipiaceinfo.helloworld”
7. Il sistema indica che tipo di pacchetto creare, Jar o War. I pacchetti Jar sono completi e contengono anche il Web Server. I pacchetti War invece sono installati su server già esistenti. Per i nostri progetti useremo Jar.
8. Specificare la versione di Java. Mettiamo la 21.
9. Il sistema chiede ora quali dipendenze (librerie) preinstallare. Selezionare “Spring web”, in futuro ne metteremo anche altre.
10. Infine viene richiesta la cartella dove creare il progetto. Selezionarla e confermare.
11. Aprire il progetto.

Verrà aperto un nuovo progetto con una struttura delle cartelle che riportiamo qui:

Vediamo le singole cartelle:

• .mvn e .vscode sono cartelle di servizio nascoste;
• src e la relativa alberatura contegono i sorgenti
• target conterrà gli eseguibili compilati
• i files .git* sono configurazioni per Git
• HELP.md è un documento markdown di descrizione
• mvnw e mvnw.cmd sono script per eseguire il progetto (linux/mac e windows)
• pom.xml è il file principale di configurazione

Pom.xml

Vediamo come è fatto il pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>4.0.2-SNAPSHOT</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>it.cipiaceinfo</groupId>
	<artifactId>helloworld</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>helloworld</name>
	<description>Demo project for Spring Boot</description>
	<url/>
	<licenses>
		<license/>
	</licenses>
	<developers>
		<developer/>
	</developers>
	<scm>
		<connection/>
		<developerConnection/>
		<tag/>
		<url/>
	</scm>
	<properties>
		<java.version>21</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-webmvc</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-webmvc-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
	<repositories>
		<repository>
			<id>spring-snapshots</id>
			<name>Spring Snapshots</name>
			<url>https://repo.spring.io/snapshot</url>
			<releases>
				<enabled>false</enabled>
			</releases>
		</repository>
	</repositories>
	<pluginRepositories>
		<pluginRepository>
			<id>spring-snapshots</id>
			<name>Spring Snapshots</name>
			<url>https://repo.spring.io/snapshot</url>
			<releases>
				<enabled>false</enabled>
			</releases>
		</pluginRepository>
	</pluginRepositories>

</project>

Come si può vedere il file rispecchia la struttura appena data. I campi di descrizione, nome, versione sono tutti editabili. C’è poi la sezione dependencies che contiene alcune dipendenze di progetto ma che possono essere modificate in base alle esigenze specifiche, come vedremo nei progetti.

Application.properties

Apriamo ora /src/resources/application.properties.

spring.application.name=helloworld

Questo file contiene invece configurazioni necessarie all’applicazione Java, come il nome dell’applicazione, le credenziali di accesso al database, la porta del server o altro ancora.

Mentre pom.xml serve per configurare il progetto ed è utilizzato da Maven, application.properties è usato da Springboot per la configurazione applicativa a runtime, e viene di norma installato nel pacchetto Jar o fornito esternamente. La configurazione infatti dipende dall’ambiente di esecuzione dell’applicazione (su server di produzione si usa un db differente con credenziali specifiche).

Vale quindi il principio che le configurazioni sono separate dalla codebase.

Il sorgente Java

Il sorgente java ha la seguente struttura:

src
|-it
|--cipiaceinfo
|---helloworld
|test
|--it
|---cipiaceinfo
|----helloworld
|-resources

La cartella src/test/it/cipiaceinfo/helloworld contiene le classi per eseguire i test unitari (test automatici di ogni funzionalità del progetto). Questa parte esula lo scopo di queste lezioni e la lasceremo vuota.

La cartella src/it/cipiaceinfo/helloworld contiene invece i sorgenti veri e propri dell’applicazione. Nello specifico è presente una sola classe, HelloWorldApplication.

package it.cipiaceinfo.helloworld;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class HelloworldApplication {

	public static void main(String[] args) {
		SpringApplication.run(HelloworldApplication.class, args);
	}

}

Come possiamo vedere è presente l’annotazione @SpringBootApplication.

Cosa è una annotazione? E’ una informazione aggiuntiva che viene data al compilatore ed a SpringBoot per indicare una serie di azioni che devono svolgere in fase di compilazione. Nello specifico questa annotazione attiva la Dependency Injection, cioè lo scan delle classi per definire le dipendenze tra gli oggetti e l’analisi della configurazione dell’applicazione (application.properties).

Modifichiamo il codice aggiungendo alla fine del metodo main:

System.out.println("Hello world");

Ed avviamo il progetto.

Per avviare il progetto, solo la prikma volta, bisogna cercare “Java Projects” nelle schede dell’Explorer (colonna a sinistra), e avviare il progetto cliccando sul pulsante di “debug”. Le volte successive si può lanciare il debug dalla sezione debug (il plugin crea una configurazione di debug che VS Code non crea automaticamente).

Se tutto funziona correttamente, verranno prodotti dei log di avvio dal terminale ed al termine verrà stampato “Hello World” dal terminale.

Deploy

Per eseguire il deploy eseguire da linea di comando:

mvn clean package

Verrà creato nella cartella target il file helloworld-0.0.1-SNAPSHOT.jar

Per eseguirlo:

java -jar helloworld-0.0.1-SNAPSHOT.jar

Che una volta partito stamperà anch’esso “Hello world”.

Come si può notare l’applicazione resta attiva, perché in realtà, avendo incluso la dipendenza “Starter-Web-mvc” Springboot ha incluso nel pacchetto anche l’intero web server Apache Tomcat, anche se non abbiamo attivato nessun servizio nella Web Application.

Per chiudere è sufficiente ctrl+c.

Conclusioni

In questa lezione introduttiva, abbiamo installato gli strumenti di sviluppo e creato il primo progetto SpringBoot. Nel progetto abbiamo visto i due principali files di configurazione (pom.xml e application.properties), l’alberatura dei sorgenti ed infine abbiamo visto il processo di debug e deploy.

Ora abbiamo tutto quello che ci serve per realizzare il primo vero Web Service.