Mastering Spring Framework 5, Teil 1: Spring MVC

Spring MVC ist die traditionelle Bibliothek des Spring Frameworks zum Erstellen von Java-Webanwendungen. Es ist eines der beliebtesten Webframeworks zum Erstellen voll funktionsfähiger Java-Webanwendungen und RESTful-Webdienste. In diesem Tutorial erhalten Sie einen Überblick über Spring MVC und erfahren, wie Sie Java-Webanwendungen mit Spring Boot, Spring Initializr und Thymeleaf erstellen.

download Code herunterladen In diesem Tutorial erhalten Sie den Quellcode für Beispielanwendungen. Erstellt für JavaWorld von Steven Haines

Spring Boot mit Spring Initializr

Wir werden unsere Spring MVC-Webanwendung mithilfe von Spring Boot und Spring Initializr schnell nachverfolgen. Angesichts der Eingabe für den zu erstellenden Anwendungstyp verwendet Spring Initializr die häufigsten Abhängigkeiten und Standardeinstellungen, um eine grundlegende Spring Boot-Anwendung einzurichten und zu konfigurieren. Sie können auch benutzerdefinierte Abhängigkeiten hinzufügen, die von Spring Initializr aufgenommen und verwaltet werden, um die Versionskompatibilität mit Software von Drittanbietern und Spring sicherzustellen. Spring Boot-Anwendungen werden eigenständig ausgeführt, ohne dass Sie eine Laufzeitumgebung bereitstellen müssen.

In diesem Fall wird Spring Cat, da wir eine Webanwendung erstellen, Tomcat automatisch als Teil der Laufzeit der App einschließen und konfigurieren. Wir können die App auch anpassen, indem wir unserer Maven POM-Datei einen H2-Datenbanktreiber hinzufügen. Spring Boot erstellt dann automatisch eine eingebettete Datenbank und DataSourceInstanz im Anwendungskontext. Sobald die Abhängigkeiten festgelegt sind, stellt Spring Boot Standardkonfigurationen für die Anwendung bereit. Natürlich können wir die Konfigurationen ändern, wenn wir möchten, aber dank Spring Boot haben wir einen Vorsprung: eine vollständig konfigurierte, funktionierende Anwendung, die sofort einsatzbereit ist.

Sobald wir unsere Abhängigkeiten ausgewählt und konfiguriert haben, übergeben wir diese Auswahl an Spring Initializr, das eine herunterladbare ZIP-Datei mit einem Spring Boot-Basisprojekt bereitstellt.

Spring MVC mit H2-Datenbankmodul

Wir beginnen mit der Erstellung einer einfachen Spring MVC-Webanwendung, die Daten in einer eingebetteten H2-Datenbank speichert.

Schritt 1. Richten Sie die App ein und konfigurieren Sie sie

Navigieren Sie zu Spring Initializr unter start.spring.io und wählen Sie Maven-Projekt mit Java und Spring Boot 2.0.X generieren aus , wobei X die neueste Spring Boot-Version ist (2.0.3 zum Zeitpunkt dieses Schreibens). Stellen Sie sicher, dass Sie Spring Boot 2.x auswählen, damit Sie Spring Web MVC 5 implementieren können. Spring Boot 1.4 und Spring Boot 1.5 implementieren Spring 4.

Geben Sie einen Gruppennamen mit dem Format ein, das Ihrer Webadresse entspricht, z. B. com.geekcap.javaworld, und geben Sie einen Artefaktnamen ein, z spring5mvc-example. Abbildung 1 zeigt meine Konfiguration.

Steven Haines

Um der Web-App Abhängigkeiten hinzuzufügen, können Sie entweder eine durch Kommas getrennte Liste von Abhängigkeiten in das Textfeld Nach Abhängigkeiten suchen eingeben oder auf Zur Vollversion wechseln klicken . Wir gehen den einfacheren Weg, indem wir auf Zur Vollversion wechseln klicken . Die Abhängigkeiten sind in Gruppen unterteilt, z. B. Core-, Web- und Template-Engines. Aktivieren Sie in diesem Beispiel die Kontrollkästchen für: Web -> Web, Template Engines -> Thymeleaf, SQL -> JPA und SQL -> H2 . Jede dieser Auswahlen wird der Anwendung Folgendes hinzufügen:

  • Web: Spring MVC und Tomcat
  • Thymeleaf: Thymeleaf-Webvorlagen-Engine
  • JPA: Spring JPA-, Hibernate- und Spring-Daten
  • H2: Die eingebettete H2-Datenbank

Wenn Sie fertig sind, klicken Sie unten auf der Seite auf die Schaltfläche Projekt generieren . Spring Initializr erstellt eine vorgefertigte ZIP-Datei mit allen erforderlichen Projektquellen, die Sie herunterladen können.

Schritt 2. Importieren Sie das Spring Initializr-Projekt in Ihre IDE

Extrahieren Sie die ZIP-Datei aus Spring Initializr und importieren Sie das Projekt in Ihre bevorzugte IDE. Um das Projekt beispielsweise in IntelliJ zu importieren, wählen Sie Datei -> Neues Projekt (siehe Abbildung 2).

Steven Haines

Schritt 3. Richten Sie Ihr Maven POM ein

Navigieren Sie anschließend zu Projekt aus externem Modul importieren , wählen Sie Maven und klicken Sie auf Weiter . Stellen Sie sicher, dass Sie ein Java 1.8-Projekt-SDK auswählen und dann auf Fertig stellen klicken .

Die Spring Boot Starter App

Schauen wir uns nun die Spring Boot-Starteranwendung an, die durch unsere (minimalen) Anstrengungen bisher generiert wurde.

Zu Beginn zeigt Listing 1 die Maven POM-Datei.

Listing 1. Maven pom.xml

   4.0.0 com.geekcap.javaworld spring5mvc-example 0.0.1-SNAPSHOT jar spring5mvc-example Demo project for Spring Boot  org.springframework.boot spring-boot-starter-parent 2.0.3.RELEASE     UTF-8 UTF-8 1.8    org.springframework.boot spring-boot-starter-data-jpa   org.springframework.boot spring-boot-starter-thymeleaf   org.springframework.boot spring-boot-starter-web   com.h2database h2 runtime   org.springframework.boot spring-boot-starter-test test      org.springframework.boot spring-boot-maven-plugin     

Beachten Sie, dass die POM-Datei ein spezielles übergeordnetes POM verwendet : spring-boot-starter-parent. Wir verwenden das übergeordnete POM, um die Versionen aller unserer Abhängigkeiten zu verwalten und sicherzustellen, dass die Versionen kompatibel sind. Die Repositorys am Ende der POM-Datei verweisen auf die Spring- Snapshot- und Meilenstein- Repositorys. Wir brauchen diese, da Spring Boot 2.x zum Zeitpunkt dieses Schreibens noch ein Meilenstein ist.

Die Abhängigkeiten sind recht gering und den meisten geht Folgendes voraus spring-boot-starter:

  • spring-boot-starter-data-jpa
  • spring-boot-starter-thymeleaf
  • spring-boot-starter-web
  • spring-boot-starter-test

Jede dieser Starterabhängigkeiten bringt alle erforderlichen Unterabhängigkeiten ein. Abbildung 3 zeigt die teilweise erweiterte Abhängigkeitsansicht in IntelliJ.

Steven Haines

Die POM-Datei enthält die folgenden Abhängigkeiten:

  • spring-boot-starter-data-jpa Enthält Ruhezustand und Federdaten.
  • spring-boot-starter-thymeleaf Enthält die Thymeleaf Template Engine.
  • spring-boot-starter-webenthält spring-boot-starter-tomcateine eingebettete Version von Apache Tomcat.
  • spring-boot-starter-json enthält die Jackson JSON-Bibliotheken.
  • spring-web and spring-webmvc beinhaltet Spring MVC.
  • spring-boot-starter-test umfasst das Testen von Bibliotheken wie JUnit und Mockito.

Wenn Spring Boot diese Abhängigkeiten im CLASSPATH sieht, wird die automatische Konfiguration eingeleitet. Wenn es beispielsweise findet spring-boot-starter-web, erstellt es eine eingebettete Version von Tomcat, und wenn es H2 findet , erstellt es eine eingebettete spring-boot-starter-jpaH2-Datenbank und einen Ruhezustand EntityManager. Anschließend werden die EntityManagerDaten in Spring Data verdrahtet.

Spring Boot erstellt auch eine einzelne Klasse, mit der die Anwendung ausgeführt werden kann. Die Klasse für die Beispielanwendung ist in Listing 2 dargestellt.

Listing 2. Spring5mvcExampleApplication.java

 package com.geekcap.javaworld.spring5mvcexample; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class Spring5mvcExampleApplication { public static void main(String[] args) { SpringApplication.run(Spring5mvcExampleApplication.class, args); } } 

This class leverages the SpringApplication.run() method, passing in the class to run (Spring5mvcExampleApplication in this example). The @SpringBootApplication annotation includes the following annotations:

  • @Configuration informs Spring that the Spring5mvcExampleApplication class contains configuration information. (This annotation can be used to create beans that will get registered with the Spring context.)
  • @EnableAutoConfiguration tells Spring to automatically configure resources from dependencies found in the CLASSPATH, such as H2 and Tomcat.
  • @ComponentScan tells Spring to scan packages in the CLASSPATH under the current package (com.geekcap.javaworld.spring5mvcexample) for Spring-annotated components such as @Service and @Controller.

Spring scans the CLASSPATH and automatically creates components such as the embedded Tomcat server and H2 database. It then populates the Spring context with the application components found in the package scan. In essence, Spring Boot makes it very easy to select and configure the services, components, controllers, entities, and so forth that you need for your application. Once you've done that, Spring will automatically find them, make them available in the Spring context, and autowire everything together.

We've got our Spring Boot starter project setup and ready to go. In the next section we'll create the Spring MVC components for our Java web application.

What is the Spring context?

The Spring context is a registry of all available Spring beans. Classes are identified as Spring beans by annotating them with specific Spring annotations. Examples include @Service, which identifies a business service, @Controller, which identifies a Spring MVC controller (i.e., handles web requests), and @Entity, which is a JPA annotation used to identify classes that are mapped to database tables.

Once these beans are annotated they need to be registered with the Spring context, which Spring Boot does by performing a package scan of all classes in packages in your project. As the Spring context is being built, it implements the inversion-of-control (IoC) design pattern through dependency injection: when a Spring bean needs a dependency, such as a service or repository, the bean can either define a constructor that accepts the dependent bean or it can leverage the @Autowired annotation to tell Spring that it needs that dependency. Spring resolves all dependencies and "autowires" the application together.

Dependency Injection is a powerful design pattern because, rather than creating and managing dependencies inside your code--which can be messy and leads to tightly coupled classes--you can instead delegate control to the Spring container. Your class simply tells the container what dependencies it needs to run and the container provides the appropriate dependencies to your class at runtime.

About Spring MVC 5

Spring MVC implements the popular Model-View-Controller pattern, which you've probably seen in other web frameworks. The Model-View-Controller pattern separates concerns into three categories:

  • Model represents your domain objects.
  • View renders your model to a view, such as to an HTML page.
  • Controller sits between your view and model and translates change requests in the view into changes in the model, and vice versa. In practical terms, the controller accepts incoming requests, potentially updates the model, and sends your model objects to a "view" to render back to the client.

In Spring MVC, controllers are identified by the @Controller annotation and accompanied by a @RequestMapping annotation. The annotation defines the HTTP verb (standard HTTP commands like GET, POST, PUT, and DELETE) and URI for which the request-mapping method will be applied. Spring 4 introduced shortcut request mappings, which make things even easier. We'll use these mappings--@GetMapping, @PostMapping, @PutMapping, @PatchMapping, and @DeleteMapping--for our example application.

The model in Spring MVC

Für unsere Anwendung definieren wir ein einfaches Modellobjekt a Widget, speichern es in einer eingebetteten H2-Datenbank und erstellen einen Controller zum Verwalten von Widgets. Beginnen wir mit der WidgetKlasse, die in Listing 3 gezeigt wird.