Hello, Spring!

Corsi / Informatica / Java / Programmazione / Spring / Web Applications

Questo è un articolo del ciclo Programmare Web App. Si tratta di un articolo pensato e scritto come supporto e integrazione alle mie lezioni, per cui non ha alcuna pretesa di essere esaustivo sull’argomento. Buona lettura.

In questo articolo illustrerò come preparare l’ambiente e scrivere la prima Web Application con il framework Spring.


Spring è un popolare framework Java che può essere usato per molteplici applicazioni, non solo Web Application, anche se oggi scriveremo proprio quest’ultima.

Prima di iniziare assicuriamoci di avere un ambiente Java JDK installato. Quasi sicuramente avrete installata una JRE, ma per programmare in Java occorre l’opportuna JDK. Quindi, assicuriamoci di avere un IDE compatibile e prestante. Mi permetto di suggerirne alcuni:

  • Visual Studio Code
  • Eclipse
  • Spring IDE
  • NetBeans

Quindi andiamo sulla pagina di Spring Initializr e componiamo subito la nostra prima Web App. Dopo aver cliccato sul link qui sopra scriviamo “Web” nello spazio indicato nella figura qui sotto, premiamo invio e scarichiamo dal sito il file demo.zip.

Fig. 1: Spring Initializr

Scompattiamo il file appena scaricato in una cartella a piacimento e apriamo il contenuto con il nostro IDE.

Fig. 2: il file demo.zip appena sfornato

Possiamo subito notare come all’interno del file ci sia un’intera struttura di file e directory. La struttura e i nomi delle cartelle non sono casuali ma hanno un senso preciso che si chiarirà con il proseguire delle lezioni. Ora voglio porre l’attenzione su due file: pom.xml e DemoApplication.java.

Il primo è un descrittore di progetto di Maven e come tale contiene tutta la descrizione del nostro progetto: il nome, il tipo di pacchetto da produrre, la versione, la versione di Java cui fare riferimento, alcune istruzioni per la compilazione, ma soprattutto contiene le dipendenze del nostro progetto. Ovvero di quali (e di quale versione) librerie esterne il nostro progetto fa uso.

Il framework Spring, in ultima analisi, è una “normalissima” libreria Java (un file .jar) e come tale può essere aggiunta al nostro progetto e gestita attraverso Maven. Ma questo non è l’unico legame: l’intero file pom.xml è “figlio” di org.springframework.boot.spring-starter-parent. Una dipendenza che determina la particolare struttura di file e directory.

Il file DemoApplication.java, invece, è l’inizio del nostro progetto. Esso contiene il metodo public static void main, che notoriamente è il punto di ingresso di un codice Java. Anche questo caso non fa eccezione, ma l’annotation @SpringBootApplication e la riga:

SpringApplication.run(DemoApplication.class, args);

di fatto “inglobano” il nostro codice in una applicazione più grande (SpringApplication) che ci fornisce tutte le funzionalità aggiuntive che sembrano venire fuori per magia. Ovviamente non c’è magia, ma la comprensione di come funziona Spring sotto il tappeto la lascio per un post successivo.

La Prima Web App

Il progetto demo.zip scaricato precedentemente è un progetto già completo e funzionante, ma al momento è inutilizzabile perché non ha mappato nemmeno una Request e quindi non esistono URL sui quali la nostra applicazione può rispondere.

Per ovviare a questo inconveniente creiamo un nuovo package e una nuova classe: com.example.demo.controller.DemoController. 

package com.example.demo.controller;

import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class DemoController {
    @GetMapping("/")    
    public ResponseEntity<String> home() {        
       return ResponseEntity.ok("<!DOCTYPE html><html><body>Hello, Spring</body></html>");    
    }
}

Dopo aver aggiunto questa classe compiliamo il tutto e facciamo partire l’applicazione:

$ mvn package
$ java -jar target/demo-0.0.1-SNAPSHOT.jar

Quindi navighiamo con un browser sull’indirizzo: http://localhost:8080

Fig. 3: Il risultato atteso dal codice esposto

Cerchiamo ora brevemente di capire la classe DemoController: la classe è etichettata come @Controller e questa annotation permette al framework di riconoscere la classe come un componente del sistema, che deve essere analizzato in fase di avvio dell’applicazione.

La classe presenta un unico metodo, chiamato home(), che restituisce un oggetto di tipo ResponseEntity<String>. L’annotazione @GetMapping in cima al metodo comunica al framework che questo è il metodo da eseguire a fronte di una Request sul percorso indicato. In questo caso è indicato il percorso / (il carattere slash), che corrisponde alla “root” di una Web application.

Come abbiamo visto dalle lezioni precedenti, una web application applica una Response ad ogni Request e in questo caso la produzione della Response è implicita nell’oggetto ResponseEntity, dove è stato specificato che il contenuto (il body) della Response sarà una Stringa. Per semplicità di lettura, infine, invece che instanziare e restuitire un nuovo oggetto nel controller, ho fatto uso del metodo statico ok, che produce una Response con status 200, che corrisponde appunto ad una comunicazione andata a buon fine.

Con questo è tutto. Buon lavoro e arrivederci alla prossima lezione!

Comments are closed.