Spring Boot CRUD-Anwendung mit Thymeleaf

Spring Boot CRUD Anwendung mit Thymeleaf

1. Überblick

Die Implementierung vonDAO-Schichten, die CRUD-Funktionalität fürJPA-Entitäten bereitstellen, kann eine sich wiederholende, zeitaufwändige Aufgabe sein, die wir in den meisten Fällen vermeiden möchten. Glücklicherweise macht esSpring Boot einfach, CRUD-Anwendungen über eine Schicht von Standard-JPA-basierten CRUD-Repositorys zu erstellen.

In this tutorial, we’ll learn how to develop a CRUD web application with Spring Boot and Thymeleaf.

Weitere Lektüre:

Frühlingsanforderungsparameter mit Thymeleaf

Erfahren Sie, wie Sie Anforderungsparameter mit Spring und Thymeleaf verwenden.

Ändern des Thymeleaf-Vorlagenverzeichnisses in Spring Boot

Erfahren Sie mehr über die Speicherorte von Thymeleaf-Vorlagen.

2. Die Maven-Abhängigkeiten

In diesem Fall verlassen wir uns für die einfache Verwaltung von Abhängigkeiten, die Versionierung und die Plug-In-Konfiguration aufspring-boot-starter-parent. Daher müssen wir die Versionen der Projektabhängigkeiten nicht in unsererpom.xml-Datei angeben, außer um die Java-Version zu überschreiben:


    org.springframework.boot
    spring-boot-starter-parent
    2.0.6.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
    


    1.8

Wir müssen die Eigenschaft<java.version> überschreiben, da die vonspring-boot-starter-parent definierte Java-Standardversion 1.6 ist.

3. Die Domänenschicht

Nachdem alle Projektabhängigkeiten bereits vorhanden sind, implementieren wir jetzt eine naive Domänenschicht.

Der Einfachheit halber enthält diese Ebene eine einzelne Klasse, die für die Modellierung der Entitäten vonUserverantwortlich ist:

@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
}

Beachten Sie, dass wir die Klasse mit der Annotation@Entityversehen haben. Therefore, the JPA implementation, which is Hibernate, in this case, will be able to perform CRUD operations on the domain entities. Eine Einführung in den Ruhezustand finden Sie in unserem Tutorial zuHibernate 5 with Spring.

Außerdem haben wir die Feldername undemail mit der Einschränkung@NotBlank eingeschränkt. Dies impliziert, dass wir den Ruhezustand-Validator zum Validieren der beschränkten Felder verwenden können, bevor wir eine Entität in der Datenbank beibehalten oder aktualisieren.

Die Grundlagen hierzu finden Sie unterour associated tutorial on Bean Validation.

4. Die Repository-Schicht

Zu diesem Zeitpunkt führt unsere Beispielwebanwendung nichts aus. Aber das wird sich bald ändern.

Spring Data JPAallows us to implement JPA-based repositories (a fancy name for the DAO pattern implementation) with minimal fuss.

Spring Data JPA ist eine Schlüsselkomponente vonspring-boot-starter-data-jpa von Spring Boot, die es einfach macht, CRUD-Funktionen durch eine leistungsstarke Abstraktionsebene hinzuzufügen, die über einer JPA-Implementierung platziert wird. Mit dieser Abstraktionsschicht können wir auf die Persistenzschicht zugreifen, ohne unsere eigenen DAO-Implementierungen von Grund auf neu bereitstellen zu müssen.

Um unserer Anwendung grundlegende CRUD-Funktionen fürUser-Objekte bereitzustellen, müssen wir lediglich dieCrudRepository-Schnittstelle erweitern:

@Repository
public interface UserRepository extends CrudRepository {}

Und das ist es! Durch die Erweiterung derCrudRepository-Schnittstelle bietet Spring Data JPA Implementierungen für die CRUD-Methoden des Repositorys.

5. Die Controller-Schicht

Thanks to the layer of abstraction that spring-boot-starter-data-jpa places on top of the underlying JPA implementation, we can easily add some CRUD functionality to our web application through a basic web tier.

In unserem Fall reicht eine einzelne Controller-Klasse aus, um GET- und POST-HTTP-Anforderungen zu verarbeiten und sie dann Aufrufen der Implementierung vonUserRepositoryzuzuordnen.

Die Controller-Klasse basiert auf einigen der Hauptfunktionen von Spring MVC. Eine ausführliche Anleitung zu Spring MVC finden Sie in unserenSpring MVC tutorial.

Beginnen wir mit den MethodenshowSignUpForm() undaddUser()des Controllers.

Ersteres zeigt das Benutzeranmeldeformular an, während letzteres eine neue Entität in der Datenbank beibehält, nachdem die eingeschränkten Felder validiert wurden.

Wenn die Entität die Validierung nicht besteht, wird das Anmeldeformular erneut angezeigt. Andernfalls wird nach dem Speichern der Entität die Liste der persistierten Entitäten in der entsprechenden Ansicht aktualisiert:

@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);
        model.addAttribute("users", userRepository.findAll());
        return "index";
    }

    // additional CRUD methods
}

Innerhalb vonUserController hat swe auch dieshowUpdateForm()-Methode, die für das Abrufen derUser-Entität verantwortlich ist, die mit den angegebenenid aus der Datenbank übereinstimmt.

Wenn die Entität vorhanden ist, wird sie als Modellattribut an die Aktualisierungsformularansicht übergeben. Daher kann das Formular mit den Werten der Feldername undemail gefüllt werden:

@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";
}

Schließlich haben wir die MethodenupdateUser() unddeleteUser() innerhalb der KlasseUserController.

Das erste Objekt behält die aktualisierte Entität in der Datenbank bei, während das letzte Objekt die angegebene Entität entfernt.

In beiden Fällen wird die Liste der beständigen Entitäten entsprechend aktualisiert:

@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);
    model.addAttribute("users", userRepository.findAll());
    return "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);
    model.addAttribute("users", userRepository.findAll());
    return "index";
}

6. Die Ansichtsebene

Zu diesem Zeitpunkt haben wir eine funktionale Controller-Klasse implementiert, die CRUD-Operationen fürUser-Entitäten ausführt. Even so, there’s still a missing component in this schema: the view layer.

Unter dem Ordnersrc/main/resources/templatesmüssen die HTML-Vorlagen erstellt werden, die zum Anzeigen des Anmeldeformulars, des Aktualisierungsformulars und zum Rendern der Liste der persistiertenUser-Entitäten erforderlich sind.

Wie in der Einführung angegeben, verwenden wir Thymeleaf als zugrunde liegende Vorlagen-Engine zum Parsen der Vorlagendateien.

Hier ist der relevante Abschnitt deradd-user.html-Datei:


    Name
    
    
    Email

Notice how we’ve used the @\{/adduser} URL expression to specify the form’s action attribute and the $\{} variable expressions for embedding dynamic content in the template, such as the values of the name and email fields and the post-validation errors.

Ähnlich wie beiadd-user.html sieht die Vorlage vonupdate-user.htmlfolgendermaßen aus:


    Name
    
    
    Email

Schließlich haben wir dieindex.html-Datei, in der die Liste der persistierten Entitäten zusammen mit den Links zum Bearbeiten und Entfernen vorhandener Entitäten angezeigt wird:


    No users yet!
        
            Users
            
                
                    
                        Name
                        Email
                        Edit
                        Delete
                    
                
                
                
                    
                    
                    Edit
                    Delete
                
            
        
    
    Add a new user

Name	Email	Edit	Delete
		Edit	Delete

Der Einfachheit halber sehen die Vorlagen eher skelettartig aus und bieten nur die erforderliche Funktionalität, ohne unnötigecosmeticshinzuzufügen.

Um den Vorlagen ein verbessertes, auffälliges Aussehen zu verleihen, ohne zu viel Zeit mit HTML / CSS zu verbringen, können wir problemlos ein kostenlosesTwitter Bootstrap UI-Kit wieShards verwenden.

7. Ausführen der Anwendung

Definieren wir abschließend den Einstiegspunkt der Anwendung. Wie die meisten Spring Boot-Anwendungen können wir dies mit einer einfachen altenmain()-Methode tun:

@SpringBootApplication
public class Application {

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

Klicken Sie jetzt in unserer IDE auf "Ausführen", öffnen Sie unseren Browser und zeigen Sie aufhttp://localhost:8080.

Wenn der Buildwe should see a basic CRUD user dashboard with links for adding new entities and for editing and removing existing ones. erfolgreich kompiliert hat

8. Fazit

In diesem Tutorial haben wir gelernt, wie man eine grundlegende CRUD-Webanwendung mit Spring Boot und Thymeleaf erstellt.

Wie üblich sind alle im Artikel gezeigten Codebeispiele überon GitHub verfügbar.

TOC

Spring Boot CRUD-Anwendung mit Thymeleaf