Applicazione Spring Boot CRUD con Thymeleaf

1. Panoramica

L'implementazione di livelli DAO che forniscono funzionalità CRUD su entità JPA può essere un'attività ripetitiva e dispendiosa in termini di tempo che desideriamo evitare nella maggior parte dei casi. Fortunatamente, Spring Boot semplifica la creazione di applicazioni CRUD attraverso un livello di repository CRUD standard basati su JPA.

In questo tutorial impareremo come sviluppare un'applicazione web CRUD con Spring Boot e Thymeleaf .

2. Le dipendenze di Maven

In questo caso, faremo affidamento su spring-boot-starter-parent per una semplice gestione delle dipendenze, controllo delle versioni e configurazione dei plug-in. Di conseguenza, non avremo bisogno di specificare le versioni delle dipendenze del progetto nel nostro file pom.xml , fatta eccezione per l'override della versione Java:

 org.springframework.boot spring-boot-starter-parent 2.2.2.RELEASE    org.springframework.boot spring-boot-starter-web   org.springframework.boot spring-boot-starter-thymeleaf   org.springframework.boot spring-boot-starter-data-jpa   com.h2database h2   

3. Il livello di dominio

Con tutte le dipendenze del progetto già presenti, implementiamo ora uno strato di dominio ingenuo.

Per semplicità, questo livello includerà una singola classe che sarà responsabile della modellazione delle entità utente :

@Entity public class User { @Id @GeneratedValue(strategy = GenerationType.AUTO) private long id; @NotBlank(message = "Name is mandatory") private String name; @NotBlank(message = "Email is mandatory") private String email; // standard constructors / setters / getters / toString }

Tieni presente che abbiamo annotato la classe con l' annotazione @Entity . Pertanto, l'implementazione JPA, che è Hibernate, in questo caso, sarà in grado di eseguire operazioni CRUD sulle entità di dominio. Per una guida introduttiva a Hibernate, visita il nostro tutorial su Hibernate 5 con Spring.

Inoltre, abbiamo vincolato i campi nome e email con il vincolo @NotBlank . Ciò implica che possiamo usare Hibernate Validator per convalidare i campi vincolati prima di persistere o aggiornare un'entità nel database.

Per le basi su questo, controlla il nostro tutorial associato sulla convalida dei fagioli.

4. Il livello del repository

A questo punto, la nostra applicazione web di esempio non fa nulla. Ma le cose stanno per cambiare.

Spring Data JPA ci consente di implementare repository basati su JPA (un nome di fantasia per l'implementazione del pattern DAO) con il minimo sforzo .

Spring Data JPA è un componente chiave di spring-boot-starter-data-jpa di Spring Boot che semplifica l'aggiunta di funzionalità CRUD attraverso un potente livello di astrazione posto sopra un'implementazione JPA. Questo livello di astrazione ci consente di accedere al livello di persistenza senza dover fornire le nostre implementazioni DAO da zero.

Per fornire alla nostra applicazione la funzionalità CRUD di base sugli oggetti utente , tutto ciò che dobbiamo fare è estendere l' interfaccia di CrudRepository :

@Repository public interface UserRepository extends CrudRepository {}

E questo è tutto! Estendendo semplicemente l' interfaccia CrudRepository , Spring Data JPA fornirà implementazioni per i metodi CRUD del repository per noi.

5. Il livello del controller

Grazie al livello di astrazione che spring-boot-starter-data-jpa pone in cima all'implementazione JPA sottostante, possiamo facilmente aggiungere alcune funzionalità CRUD alla nostra applicazione web attraverso un livello web di base .

Nel nostro caso, una singola classe controller sarà sufficiente per gestire le richieste GET e POST HTTP e quindi mapparle alle chiamate alla nostra implementazione UserRepository .

La classe controller si basa su alcune delle caratteristiche principali di Spring MVC. Per una guida dettagliata su Spring MVC, controlla il nostro tutorial Spring MVC.

Cominciamo con i metodi showSignUpForm () e addUser () del controller .

Il primo visualizzerà il modulo di iscrizione dell'utente, mentre il secondo manterrà una nuova entità nel database dopo aver convalidato i campi vincolati.

Se l'entità non supera la convalida, verrà visualizzato nuovamente il modulo di registrazione. Altrimenti, una volta che l'entità è stata salvata, l'elenco delle entità persistenti verrà aggiornato nella vista corrispondente:

@Controller public class UserController { @GetMapping("/signup") public String showSignUpForm(User user) { return "add-user"; } @PostMapping("/adduser") public String addUser(@Valid User user, BindingResult result, Model model) { if (result.hasErrors()) { return "add-user"; } userRepository.save(user); return "redirect:/index"; } // additional CRUD methods }

Avremo anche bisogno di una mappatura per l' URL / index :

@GetMapping("/index") public String showUserList(Model model) { model.addAttribute("users", userRepository.findAll()); return "index"; }

All'interno del UserController avremo anche la showUpdateForm () metodo che è responsabile per il recupero della User entità che corrisponde in dotazione id dal database.

Se l'entità esiste, verrà trasmessa come attributo del modello alla visualizzazione del modulo di aggiornamento, quindi il modulo può essere popolato con i valori dei campi nome e posta elettronica :

@GetMapping("/edit/{id}") public String showUpdateForm(@PathVariable("id") long id, Model model) { User user = userRepository.findById(id) .orElseThrow(() -> new IllegalArgumentException("Invalid user Id:" + id)); model.addAttribute("user", user); return "update-user"; } 

Infine, abbiamo i metodi updateUser () e deleteUser () all'interno della classe UserController .

Il primo manterrà l'entità aggiornata nel database, mentre l'ultimo rimuoverà l'entità data.

In entrambi i casi, l'elenco delle entità persistenti verrà aggiornato di conseguenza:

@PostMapping("/update/{id}") public String updateUser(@PathVariable("id") long id, @Valid User user, BindingResult result, Model model) { if (result.hasErrors()) { user.setId(id); return "update-user"; } userRepository.save(user); return "redirect:/index"; } @GetMapping("/delete/{id}") public String deleteUser(@PathVariable("id") long id, Model model) { User user = userRepository.findById(id) .orElseThrow(() -> new IllegalArgumentException("Invalid user Id:" + id)); userRepository.delete(user); return "redirect:/index"; }

6. Il livello di visualizzazione

A questo punto, abbiamo implementato una classe controller funzionale che esegue operazioni CRUD su entità utente . Anche così, c'è ancora un componente mancante in questo schema: il livello di visualizzazione.

Nella cartella src / main / resources / templates dobbiamo creare i modelli HTML richiesti per visualizzare il modulo di registrazione, il modulo di aggiornamento e il rendering dell'elenco delle entità utente persistenti ,

Come affermato nell'introduzione, utilizzeremo Thymeleaf come motore del modello sottostante per l'analisi dei file del modello.

Ecco la sezione pertinente del file add-user.html :

 Name   Email    

Nota come abbiamo utilizzato l' espressione URL @ {/ adduser} per specificare l' attributo di azione del modulo e le espressioni della variabile $ {} per incorporare contenuto dinamico nel modello, come i valori dei campi nome e email e la convalida successiva errori .

Simile a add-user.html , ecco come appare il modello update-user.html :

 Name   Email    

Infine, abbiamo il file index.html che mostra l'elenco delle entità persistenti insieme ai collegamenti per la modifica e la rimozione di quelle esistenti:

No users yet!

Users

Name Email Edit Delete
Edit Delete

Add a new user

Per semplicità, i modelli sembrano piuttosto scheletrici e forniscono solo le funzionalità richieste senza aggiungere cosmetici non necessari.

Per dare ai modelli un aspetto migliore e accattivante senza spendere troppo tempo su HTML / CSS, possiamo facilmente utilizzare un kit di interfaccia utente Bootstrap Twitter gratuito, come Shards.

7. Esecuzione dell'applicazione

Infine, definiamo il punto di ingresso dell'applicazione. Come la maggior parte delle applicazioni Spring Boot, possiamo farlo con un semplice vecchio metodo main () :

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

Ora, premiamo "Esegui" nel nostro IDE, quindi apri il nostro browser e indirizzalo a // localhost: 8080 .

Se la build è stata compilata con successo , dovremmo vedere un dashboard utente CRUD di base con collegamenti per l'aggiunta di nuove entità e per la modifica e la rimozione di quelle esistenti.

8. Conclusione

In questo tutorial, abbiamo imparato come creare un'applicazione web CRUD di base con Spring Boot e Thymeleaf.

Come al solito, tutti gli esempi di codice mostrati nell'articolo sono disponibili su GitHub.