Come creare un progetto Spring Boot

Dunque avete deciso che Spring fa per voi e volete utilizzarlo nel vostro prossimo progetto web?

Ottima scelta!

Per di più avete anche poca voglia di sporcarvi le mani con noiose configurazioni che vi tolgono tempo ed energie?

Bravissimi!

Vediamo allora come creare la struttura base di un’ipotetica applicazione web, sfruttando Spring Boot e Spring Initializr.

Spring Boot, questo sconosciuto

Per chi non lo conoscesse già, Spring Boot è senza dubbio uno dei membri più interessanti della famiglia Spring. La prima milestone release risale al 2013; da allora il progetto è evoluto fino a diventare, a mio parere, l’unico modo ragionevole per lavorare con Spring.

Perché dico questo? Perché se vogliamo trovare un punto debole a Spring, non si può ignorare la complessità delle sue configurazioni.

Spring Boot nasce proprio per risolvere questo annoso problema. Il suo obiettivo dichiarato è quello di rendere semplice e rapida la creazione di progetti basati su Spring framework.

Come? Spring Boot mette a disposizione una serie di pacchetti denominati “starter packages” che includono tutte le dipendenze e le configurazioni necessarie per cominciare a lavorare fin da subito. Le configurazioni di default soddisfano le esigenze di sviluppo più frequenti. Ovviamente, se necessario, le impostazioni possono essere customizzate in base ai requisiti specifici del progetto.

C’è di più: i progetti Spring Boot sono, a tutti gli effetti, applicazioni standalone. La build genera un pacchetto eseguibile, che include una versione embedded del web container (di default, Tomcat). Questo non solo significa che non dobbiamo necessariamente installare Tomcat sulla nostra macchina di sviluppo, ma anche che non dobbiamo preoccuparci del deploy per vedere in azione il nostro progetto. Fantastico, no? :-)

Ora che abbiamo le idee abbastanza chiare su cos’è Spring Boot, direi che è giunto il momento di mettersi all’opera.

Generiamo il progetto

La creazione del progetto parte da start.spring.io, ovvero da Spring Initializr, un utilissimo tool che permette di gettare le fondamenta della nostra applicazione.

Tramite Spring Initializr, infatti, possiamo generare un progetto Spring Boot di partenza, con dipendenze e configurazioni di base.

Spring Initializr

La procedura è piuttosto semplice:

  1. Possiamo gestire le build del progetto con Maven o con Gradle. Scegliete il sistema che preferite (io userò Maven), quindi selezionate una versione di Spring Boot tra quelle proposte (vi consiglio di utilizzare sempre l’ultima stabile). Noterete inoltre che è possibile scegliere il linguaggio da utilizzare nel progetto: le opzioni disponibili sono Java, Groovy e Kotlin. Per questo tutorial utilizzerò Java.

  2. Inserite il Group ID, ovvero la radice del package principale del vostro progetto, e l’Artifact ID, cioè il nome del pacchetto jar che verrà generato dalla build. Io per esempio inserirò come group com.davioooh, mentre l’artifact sarà ciao-mondo.

  3. Aggiungete le dipendenze dell’applicazione: ricercate i pacchetti tramite l’apposito campo e selezionateli dall’elenco dei risultati per includerli nel progetto. Per una web application potrebbe essere utile il pacchetto Web, per lavorare con le classiche JSP o il pacchetto Thymeleaf per integrare l’omonimo motore di template. Inoltre potreste aver bisogno di uno dei moduli Spring Data per l’accesso ai dati.

  4. Per una configurazione più dettagliata del progetto, potete cliccare sul link “Switch to the full version”. Verrà visualizzata una sezione con la lista completa delle opzioni disponibili e un elenco dettagliato dei pacchetti che possiamo includere nel progetto.

  5. Quando siete sicuri di aver impostato tutto il necessario, fate click su “Generate Project” e scaricate l’archivio zip contenente i file del progetto.

Le versioni di Spring Boot dalla 1.4 in poi (basate su Spring framework 4.0) utilizzano API e funzionalità introdotte con Java 8. Come spiegato in questo articolo, però, Spring 4.0 implementa diversi escamotage per garantire la retrocompatibilità con versioni di Java più “stagionate”. Il mio consiglio, comunque, è quello di aggiornare il vostro ambiente di lavoro al JDK 8.

Fatto! Niente di più semplice…

Ora che abbiamo generato il progetto di partenza siamo pronti a lavorare. Prima però diamo un’occhiata al codice.

La struttura del progetto

Recuperate il progetto generato da Spring Initializr ed estraete il contenuto dell’archivio zip.

Nella directory scompattata troverete diverse cosette…

  • La cartella src con il codice sorgente del progetto. Al suo interno troviamo due directory principali: main, che contiene le classi dell’applicazione vera e propria e test, in cui eventualmente andremo a mettere le classi per gli unit test.

  • Il file pom.xml, per chi non lo conoscesse, viene utilizzato da Maven per reperire le dipendenze del progetto. Inoltre contiene impostazioni necessarie per effettuare la build dell’applicazione.

  • I file mvnv, mvnv.cmd e la directory .mvn costituiscono il Maven Wrapper, un piccolo tool che permette di compilare e lanciare il progetto senza bisogno di un’installazione di Maven già presente sul pc.

  • Infine il file .gitignore, utile nel caso in cui decidessimo di gestire il versioning del nostro progetto con Git.

POM e gestione delle dipendenze

Abbiamo già detto che il file pom.xml (Project Object Model) permette di definire gli aspetti legati alla compilazione e alla produzione del pacchetto per il deploy dell’applicazione.

Vediamo un esempio:

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.davioooh</groupId>
  <artifactId>hello-world</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>hello-world</name>
  <description>Demo project for Spring Boot</description>

  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.6.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
  </parent>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <java.version>1.8</java.version>
  </properties>

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

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

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>

</project>

Come potete notare, nelle prime righe del file ritroviamo i parametri precedentemente impostati in Spring Initializr, in particolare groupId e artifactId.

Troviamo inoltre un campo che indica la versione dell’applicazione, ed un tag, packaging, che definisce il tipo di pacchetto generato dalla build (per un progetto Spring Boot, generalmente, il formato è il jar).

La sezione dependencies, infine, include la lista dei pacchetti (le dipendenze) necessari alla compilazione dell’applicazione. Anche in questo caso riconoscerete le opzioni selezionate inizialmente.

Configurazioni generali

Un elemento fondamentale di un progetto Spring Boot è il file application.properties, presente nella directory resources. Questo file permette di definire le principali configurazioni di un progetto Spring Boot (qui trovate una reference aggiornata delle proprietà disponibili).

Inizialmente il file risulta vuoto, dunque i soli parametri applicati saranno quelli di default.

Le classi principali

Esaminiamo ora le due classi principali presenti nel progetto appena generato.

La prima, HelloWorldApplication, è il vero cuore dell’applicazione. Si tratta di una classe eseguibile: lo si intuisce dalla presenza del metodo main. Il che potrebbe lasciare un po’ spiazzati se siamo abituati a lavorare con le classiche applicazioni web Java.

Come accennato, però, i progetti Spring Boot, non richiedono necessariamente il deploy in un container “esterno” (necessità che può sorgere in fase di rilascio). L’applicazione è totalmente autosufficiente e può essere lanciata come una qualsiasi console application.

package com.davioooh.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);
  }
}

Prima cosa da notare è l’annotazione a livello di classe @SpringBootApplication che ingloba le funzionalità di tre diverse annotazioni già presenti in Spring 4.0, in particolare:

  • abilita le auto-configurazioni per le componenti Spring del progetto;

  • abilita la definizione di configurazioni all’interno della classe annotata;

  • abilita la scansione e la registrazione delle classi annotate come @Component presenti all’interno del package corrente e/o dei suoi “figli”.

La classe SpringApplication viene utilizzata all’interno del metodo main per lanciare l’applicazione dopo aver caricato le configurazioni. Queste ultime possono essere definite nel file application.properties, nella stessa classe CiaoMondoApplication o in altre classi di configurazione presenti all’interno del progetto.

La seconda classe da tenere in considerazione è HelloWorldApplicationTests. Classe speculare a CiaoMondoApplication, viene utilizzata per definire casi di test per l’applicazione.

Se avete osservato bene il file pom.xml, avrete notato infatti che tra le dipendenze è presente anche un certo spring-boot-starter-test (incluso di default). Si tratta di una collezione di strumenti per il testing della nostra applicazione che comprende anche la famosa libreria JUnit, utile per definire ed automatizzare test di unità per le classi del nostro progetto.

package com.davioooh.helloworld;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class HelloWorldApplicationTests {

  @Test
  public void contextLoads() {
  }

}

Anche in questa classe notiamo la presenza di alcune interessanti annotazioni:

  • @RunWith fa parte della libreria JUnit e definisce il runner per l’esecuzione dei test e la notifica dei risultati;

  • @SpringBootTest carica le configurazioni di Spring Boot necessarie all’esecuzione di diverse tipologie di test;

  • @Test è un’altra annotazione di JUnit che serve a definire i metodi eseguibili come test case.

In conclusione

Come avete visto, creare un progetto Spring Boot è davvero semplice. Grazie a Spring Initializr si riesce ad essere operativi in pochi minuti con una struttura di partenza completa e standardizzata.

A questo punto non vi rimane altro da fare che cominciare a sviluppare il vostro nuovo progetto. Buon lavoro! ;-)

A presto,

David

(foto di Katemangostar)