Block Image

Spring Boot è un potente modulo di Spring che ci permette di usare il framework Spring in modo più facile e veloce.
In particolare, i principali vantaggi sono:

  1. creazioni di app in modo più agevole poiché ha già delle configurazioni preimpostate.
  2. ha integrato Tomcat, quindi elimina il bisogno di deployare l'app su un servlet container o application server

esterno (basta eseguire direttamente il jar per avviare l'app).

Prerequisiti

  1. Aver installato una jdk (useremo la versione 8 ma va bene anche una successiva).
  2. Aver installato maven (https://maven.apache.org/install.html).

Primo passo: andare sul sito Spring Initializr

Questo sito creerà per noi uno scheletro di un'app Spring Boot con tutto quello che ci serve (basta cercare le dipendenze che ci servono nella sezione 'Dependencies'). Clicchiamo su 'ADD DEPENDENCIES' ed aggiungiamo le dipendenze riportate dall'immagine.

Block Image

La dipendenza del database H2 ci consente di lavorare velocemente con un database in memory (cioè, una volta stoppata l'app, i dati saranno cancellati). Di default se non configuriamo alcun database nel file application.properties del progetto e abbiamo una dipendenza di H2, Spring Boot configurerà automaticamente un database H2 in memory.

Cliccate su 'Generate'. Verrà scaricato lo zip del progetto. Il progetto si presenta con questa struttura:

Block Image


Secondo passo: creimo una Entity che mapperà una tabella del Database

Creiamo un sottopackage entities e lì creiamo una classe Java che mapperà una tabella USER:

@Entity
public class User implements Serializable {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    
    private String surname;
    
    private String address;
    
    //getter, setter, equals and hashcode
}

Terzo passo: creimo un repository per l'entity User

public interface UserRepository extends JpaRepository<User,Long> {
}

Si, è un'interfaccia vuota, ma è tutto quello che ci serve! Spring infatti a runtime creerà una classe che estende SimpleJpaRepository che conterrà vari metodi come findAll (anche paginato), findById, save, delete.
In più, siccome abbiamo aggiunto in fase di creazione la dipendenza di Spring Data REST, ogni metodo del Repository sarà mappato come un servizio REST di livello 3 nella resource /users.

Nota: Spesso ho trovato in vari progetti interfacce repositories come questa annotate con @Repository. Chi fa ciò non conosce bene come funziona Spring.

Finito! Eseguiamo l'app

Avviamo l'app eseguendo il main oppure buildiamo il progetto con maven e usando il comando java -jar spring-boot-rest.jar sul jar. Il nostro web service REST è avviato sulla porta 8080! Inseriamo un utente facendo una chiamata POST a localhost:8080/users col seguente body JSON:

{
    "name": "John",
    "surname": "Mayer",
    "address": "via Roma"
}

La risposta HTTP che ci verrà fornita avrà lo status 201 (Created)col seguente body:

{
  "name": "John",
  "surname": "Mayer",
  "address": "via Roma",
  "_links": {
    "self": {
      "href": "http://localhost:8080/users/1"
    },
    "user": {
      "href": "http://localhost:8080/users/1"
    }
  }
}

Create un altro User alla stessa maniera, poi facciamo una chiamate GET a localhost:8080/users che ci restituirà la lista di tutti gli utente salvati nel database.

{
  "_embedded": {
    "users": [
      {
        "name": "John",
        "surname": "Mayer",
        "address": "via Roma",
        "_links": {
          "self": {
            "href": "http://localhost:8080/users/1"
          },
          "user": {
            "href": "http://localhost:8080/users/1"
          }
        }
      },
      {
        "name": "Massimo",
        "surname": "Esposito",
        "address": "via Napoli",
        "_links": {
          "self": {
            "href": "http://localhost:8080/users/2"
          },
          "user": {
            "href": "http://localhost:8080/users/2"
          }
        }
      }
    ]
  },
  "_links": {
    "self": {
      "href": "http://localhost:8080/users"
    },
    "profile": {
      "href": "http://localhost:8080/profile/users"
    }
  },
  "page": {
    "size": 20,
    "totalElements": 2,
    "totalPages": 1,
    "number": 0
  }
}

Possiamo provare a fare una chiamata GET a localhost:8080/users/1 per vedere solo le informazioni dell'Utente con id 1.

Proviamo ora a modificare l'indirizzo dell'utente con id 1 facendo una chiamata PUT a localhost:8080/users/1:

{
    "name": "John",
    "surname": "Mayer",
    "address": "via Milano"
}

Ora infine, proviamo ad eliminare l'utente 1 con una chiamata DELETE a localhost:8080/users/1.
Avremo come risposta un 204,poiché nella delete Spring non ci fornisce alcun Body di risposta.

Verifichiamo che l'utente sia stato effettivamente eliminato facendo di nuovo una chiamata GET su localhost:8080/users/1.
Avremo come risposta un 404 poiché la risorsa con id 1 non esiste più.

Conclusioni

Abbiamo creato un Web Service RESTful di livello 3 (cioè con Hypermedia-Driven) scrivendo codice solo per l'Entity.
I DAO e i servizi REST sono autogenerati da Spring per noi!

Potete trovare il progetto completo sul mio github a questo link: Spring Boot Rest

Articoli su Spring: Spring

Libri consigliati su Spring:

  • Pro Spring 5 (Spring da zero a hero): https://amzn.to/3KvfWWO
  • Pivotal Certified Professional Core Spring 5 Developer Exam: A Study Guide Using Spring Framework 5 (per certificazione Spring): https://amzn.to/3KxbJSC
  • Pro Spring Boot 2: An Authoritative Guide to Building Microservices, Web and Enterprise Applications, and Best Practices (Spring Boot del dettaglio): https://amzn.to/3TrIZic