Spring Boot CRUD-applicatie met Thymeleaf

1. Overzicht

De implementatie van DAO-lagen die CRUD-functionaliteit bieden op JPA-entiteiten kan een repetitieve, tijdrovende taak zijn die we in de meeste gevallen willen vermijden. Gelukkig maakt Spring Boot het eenvoudig om CRUD-applicaties te maken via een laag standaard JPA-gebaseerde CRUD-repositories.

In deze zelfstudie leren we hoe u een CRUD-webtoepassing ontwikkelt met Spring Boot en Thymeleaf.

2. De afhankelijkheden van Maven

In dit geval vertrouwen we op spring-boot-starter-parent voor eenvoudig afhankelijkheidsbeheer, versiebeheer en plug-inconfiguratie. Als gevolg hiervan hoeven we de versies van de projectafhankelijkheden in onze pom.xml bestand, behalve voor het overschrijven van de Java-versie:

 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. De domeinlaag

Nu alle projectafhankelijkheden al aanwezig zijn, gaan we nu een naïeve domeinlaag implementeren.

Eenvoudigheidshalve zal deze laag één enkele klasse bevatten die verantwoordelijk zal zijn voor het modelleren Gebruiker entiteiten:

@Entity openbare klasse Gebruiker {@Id @GeneratedValue (strategie = GenerationType.AUTO) privé lang ID; @NotBlank (message = "Naam is verplicht") private String naam; @NotBlank (message = "E-mail is verplicht") private String e-mail; // standard constructors / setters / getters / toString}

Houd er rekening mee dat we de klas hebben geannoteerd met de @Entiteit annotatie. Daarom is de JPA-implementatie, die Hibernate is, in in dit geval kunnen CRUD-bewerkingen op de domeinentiteiten worden uitgevoerd. Bezoek onze tutorial over Hibernate 5 met Spring voor een inleidende gids voor Hibernate.

Bovendien hebben we de naam en e-mail velden met de @RTLnieuws beperking. Dit houdt in dat we Hibernate Validator kunnen gebruiken voor het valideren van de beperkte velden voordat een entiteit in de database wordt behouden of bijgewerkt.

Bekijk voor de basisprincipes onze bijbehorende tutorial over Bean Validation.

4. De gegevensopslaglaag

Op dit moment doet onze voorbeeldwebtoepassing niets. Maar dat gaat veranderen.

Spring Data JPA stelt ons in staat om op JPA gebaseerde repositories te implementeren (een mooie naam voor de DAO-patroonimplementatie) met een minimum aan gedoe.

Spring Data JPA is een belangrijk onderdeel van Spring Boot's spring-boot-starter-data-jpa dat maakt het eenvoudig om CRUD-functionaliteit toe te voegen via een krachtige abstractielaag die bovenop een JPA-implementatie is geplaatst. Deze abstractielaag stelt ons in staat om toegang te krijgen tot de persistentielaag zonder dat we onze eigen DAO-implementaties vanaf het begin hoeven aan te bieden.

Om onze applicatie te voorzien van basis CRUD-functionaliteit op Gebruiker objecten alles wat we hoeven te doen is het uitbreiden van de CrudRepository koppel:

@Repository openbare interface UserRepository breidt CrudRepository uit {}

En dat is het! Door gewoon het CrudRepository interface, zal Spring Data JPA implementaties leveren voor de CRUD-methoden van de repository voor ons.

5. De controllerlaag

Dankzij de abstractielaag dat spring-boot-starter-data-jpa bovenop de onderliggende JPA-implementatie, kunnen we eenvoudig wat CRUD-functionaliteit aan onze webapplicatie toevoegen via een standaard weblaag.

In ons geval is een enkele controller-klasse voldoende voor het afhandelen van GET- en POST-HTTP-verzoeken en deze vervolgens toe te wijzen aan oproepen naar onze UserRepository implementatie.

De controllerklasse is gebaseerd op enkele van de belangrijkste kenmerken van Spring MVC. Bekijk onze Spring MVC-tutorial voor een gedetailleerde gids over Spring MVC.

Laten we beginnen met de controller showSignUpForm () en Voeg gebruiker toe() methoden.

De eerste zal het aanmeldingsformulier voor de gebruiker weergeven, terwijl de laatste een nieuwe entiteit in de database zal behouden na validatie van de beperkte velden.

Als de entiteit de validatie niet doorstaat, wordt het aanmeldingsformulier opnieuw weergegeven. Anders wordt, nadat de entiteit is opgeslagen, de lijst met persistente entiteiten bijgewerkt in de bijbehorende weergave:

@Controller public class UserController {@GetMapping ("/ signup") public String showSignUpForm (User user) {return "add-user"; } @PostMapping ("/ adduser") public String addUser (@Valid User user, BindingResult-resultaat, modelmodel) {if (result.hasErrors ()) {return "add-user"; } userRepository.save (gebruiker); retourneer "redirect: / index"; } // aanvullende CRUD-methoden}

We hebben ook een mapping nodig voor de /inhoudsopgave URL:

@GetMapping ("/ index") public String showUserList (Modelmodel) {model.addAttribute ("gebruikers", userRepository.findAll ()); retourneer "index"; }

Binnen de UserController we zullen ook de showUpdateForm () methode die verantwoordelijk is voor het ophalen van de Gebruiker entiteit die overeenkomt met het geleverde ID kaart uit de database.

Als de entiteit bestaat, wordt deze als een modelattribuut doorgegeven aan de weergave van het updateformulier, zodat het formulier kan worden gevuld met de waarden van de naam en e-mail velden:

@GetMapping ("/ edit / {id}") public String showUpdateForm (@PathVariable ("id") lange id, modelmodel) {User user = userRepository.findById (id) .orElseThrow (() -> nieuwe IllegalArgumentException (" Ongeldige gebruikers-ID: "+ id)); model.addAttribute ("gebruiker", gebruiker); retourneer "update-user"; } 

Eindelijk hebben we de updateUser () en Verwijder gebruiker() methoden binnen de UserController klasse.

De eerste zal de bijgewerkte entiteit in de database behouden, terwijl de laatste de gegeven entiteit zal verwijderen.

In beide gevallen wordt de lijst met permanente entiteiten dienovereenkomstig bijgewerkt:

@PostMapping ("/ update / {id}") public String updateUser (@PathVariable ("id") lange id, @Valid User user, BindingResult-resultaat, modelmodel) {if (result.hasErrors ()) {user.setId (ID kaart); retourneer "update-user"; } userRepository.save (gebruiker); retourneer "redirect: / index"; } @GetMapping ("/ delete / {id}") openbare String deleteUser (@PathVariable ("id") lange id, modelmodel) {User user = userRepository.findById (id) .orElseThrow (() -> nieuwe IllegalArgumentException ( "Ongeldige gebruikers-ID:" + id)); userRepository.delete (gebruiker); retourneer "redirect: / index"; }

6. De weergavelaag

Op dit punt hebben we een functionele controllerklasse geïmplementeerd die CRUD-bewerkingen uitvoert op Gebruiker entiteiten. Toch ontbreekt er nog een component in dit schema: de view-laag.

Onder de src / main / resources / templates map moeten we de HTML-sjablonen maken die nodig zijn voor het weergeven van het aanmeldingsformulier, het updateformulier en het weergeven van de lijst met persistente Gebruiker entiteiten,

Zoals vermeld in de inleiding, gebruiken we Thymeleaf als de onderliggende sjabloonengine voor het parseren van de sjabloonbestanden.

Hier is het relevante gedeelte van het add-user.html het dossier:

 Naam E-mail 

Merk op hoe we het @{/Voeg gebruiker toe} URL-expressie om het formulier te specificeren actie attribuut en het ${} variabele expressies voor het insluiten van dynamische inhoud in de sjabloon, zoals de waarden van de naam en e-mail velden en de post-validatiefouten.

Gelijkwaardig aan add-user.html, hier is hoe de update-user.html sjabloon ziet eruit:

 Naam E-mail 

Eindelijk hebben we de index.html bestand dat de lijst met persistente entiteiten weergeeft, samen met de links voor het bewerken en verwijderen van bestaande:

Nog geen gebruikers!

Gebruikers

NaamE-mailBewerkVerwijderen
BewerkVerwijderen

Voeg een nieuwe gebruiker toe

Eenvoudigheidshalve zien de sjablonen er nogal skeletachtig uit en bieden ze alleen de vereiste functionaliteit zonder onnodige cosmetica toe te voegen.

Om de sjablonen een verbeterde, opvallende look te geven zonder al te veel tijd aan HTML / CSS te besteden, kunnen we eenvoudig een gratis Twitter Bootstrap UI-kit gebruiken, zoals Shards.

7. Het uitvoeren van de applicatie

Laten we tot slot het startpunt van de toepassing definiëren. Zoals de meeste Spring Boot-applicaties, kunnen we dit doen met een gewoon oud hoofd() methode:

@SpringBootApplication openbare klasse Toepassing {openbare statische leegte hoofd (String [] args) {SpringApplication.run (Application.class, args); }}

Laten we nu op "Uitvoeren" klikken in onze IDE, dan onze browser openen en ernaar verwijzen // localhost: 8080.

Als de build met succes is gecompileerd we zouden een basis CRUD-gebruikersdashboard moeten zien met links voor het toevoegen van nieuwe entiteiten en voor het bewerken en verwijderen van bestaande.

8. Conclusie

In deze tutorial hebben we geleerd hoe we een eenvoudige CRUD-webtoepassing kunnen bouwen met Spring Boot en Thymeleaf.

Zoals gewoonlijk zijn alle codevoorbeelden die in het artikel worden getoond, beschikbaar op GitHub.