Opanowanie Spring Framework 5, Część 1: Spring MVC

Spring MVC to tradycyjna biblioteka platformy Spring do tworzenia aplikacji internetowych w języku Java. Jest to jeden z najpopularniejszych frameworków internetowych do tworzenia w pełni funkcjonalnych aplikacji internetowych w języku Java i usług internetowych RESTful. W tym samouczku uzyskasz przegląd Spring MVC i dowiesz się, jak tworzyć aplikacje internetowe Java przy użyciu Spring Boot, Spring Initializr i Thymeleaf.

pobierz Pobierz kod Pobierz kod źródłowy dla przykładowych aplikacji w tym samouczku. Stworzony dla JavaWorld przez Stevena Hainesa

Spring Boot z Spring Initializr

Szybko prześledzimy naszą aplikację internetową Spring MVC za pomocą Spring Boot i Spring Initializr. Biorąc pod uwagę dane wejściowe dla typu aplikacji, która ma zostać zbudowana, Spring Initializr używa najczęstszych zależności i wartości domyślnych do konfigurowania i konfigurowania podstawowej aplikacji Spring Boot. Możesz także dodać niestandardowe zależności, a Spring Initializr uwzględni je i zarządza nimi, zapewniając zgodność wersji zarówno z oprogramowaniem innych firm, jak i Spring. Aplikacje Spring Boot działają samodzielnie, bez konieczności zapewniania środowiska wykonawczego.

W tym przypadku, ponieważ tworzymy aplikację internetową, Spring Boot automatycznie dołączy i skonfiguruje Tomcat jako część środowiska wykonawczego aplikacji. Możemy również dostosować aplikację, dodając sterownik bazy danych H2 do naszego pliku POM Maven. Spring Boot automatycznie utworzy osadzoną bazę danych i DataSourceinstancję w kontekście aplikacji. Po ustawieniu zależności Spring Boot zapewni domyślne konfiguracje aplikacji. Oczywiście możemy zmienić konfiguracje, jeśli chcemy, ale dzięki Spring Boot mamy przewagę: w pełni skonfigurowaną, działającą aplikację od razu po wyjęciu z pudełka.

Po wybraniu i skonfigurowaniu naszych zależności przekażemy te wybory do Spring Initializr, który dostarczy do pobrania plik ZIP zawierający podstawowy projekt Spring Boot.

Spring MVC z silnikiem bazy danych H2

Zaczniemy od stworzenia podstawowej aplikacji internetowej Spring MVC, która utrwala dane we wbudowanej bazie danych H2.

Krok 1. Skonfiguruj i skonfiguruj aplikację

Przejdź do Spring Initializr na start.spring.io i wybierz Generuj projekt Maven za pomocą Java i Spring Boot 2.0.X , gdzie X to najnowsza wersja Spring Boot (2.0.3 w chwili pisania tego tekstu). Upewnij się, że wybrałeś Spring Boot 2.x, aby można było zaimplementować Spring Web MVC 5. Spring Boot 1.4 i Spring Boot 1.5 zaimplementują Spring 4.

Wprowadź nazwę grupy w formacie zgodnym z adresem internetowym, na przykład com.geekcap.javaworld, i wprowadź nazwę artefaktu, na przykład spring5mvc-example. Rysunek 1 przedstawia moją konfigurację.

Steven Haines

Aby dodać zależności do aplikacji internetowej, możesz wprowadzić listę zależności oddzielonych przecinkami w polu tekstowym Wyszukaj zależności lub kliknąć opcję Przełącz na pełną wersję . Przejdziemy łatwiejszą drogą, klikając Przełącz na pełną wersję . Zależności są podzielone na grupy, takie jak Core, Web i Template Engines. W tym przykładzie zaznacz pola wyboru dla: Sieć -> Sieć, Silniki szablonów -> Tymeleaf, SQL -> JPA i SQL -> H2 . Oto, co każda z tych opcji doda do aplikacji:

  • Sieć: Spring MVC i Tomcat
  • Thymeleaf: silnik szablonów internetowych Thymeleaf
  • JPA: Spring JPA, Hibernate i Spring Data
  • H2: Wbudowana baza danych H2

Kiedy skończysz, kliknij przycisk Generuj projekt u dołu strony. Spring Initializr utworzy gotowy plik ZIP ze wszystkimi wymaganymi źródłami projektu, które możesz pobrać.

Krok 2. Zaimportuj projekt Spring Initializr do swojego IDE

Wyodrębnij plik ZIP z Spring Initializr, a następnie zaimportuj projekt do swojego ulubionego IDE. Na przykład, aby zaimportować projekt do IntelliJ, wybierz Plik -> Nowy projekt , jak pokazano na rysunku 2.

Steven Haines

Krok 3. Skonfiguruj Maven POM

Następnie przejdź do Importuj projekt z modułu zewnętrznego , wybierz Maven i naciśnij Dalej . Pamiętaj, aby wybrać zestaw SDK projektu Java 1.8, a następnie naciśnij przycisk Zakończ .

Aplikacja startowa Spring Boot

Przyjrzyjmy się teraz aplikacji startowej Spring Boot, która została wygenerowana przez nasze (minimalne) dotychczasowe wysiłki.

Na początek Listing 1 pokazuje plik POM Mavena.

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     

Zauważ, że plik POM POM wykorzystuje specjalną nadrzędny: spring-boot-starter-parent. Będziemy używać nadrzędnego POM do zarządzania wersjami wszystkich naszych zależności i zapewniania zgodności wersji. Repozytoria na końcu pliku POM odwołują się do repozytoriów migawek Springa i kamieni milowych . Potrzebujemy ich, ponieważ Spring Boot 2.x jest nadal kamieniem milowym w momencie pisania tego tekstu.

Zależności są dość minimalne, a większość z nich jest poprzedzona spring-boot-starter:

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

Każda z tych zależności początkowych wprowadza wszystkie wymagane zależności podrzędne. Rysunek 3 przedstawia częściowo rozszerzony widok zależności w IntelliJ.

Steven Haines

Plik POM zawiera następujące zależności:

  • spring-boot-starter-data-jpa zawiera dane Hibernate i Spring.
  • spring-boot-starter-thymeleaf zawiera silnik szablonów Thymeleaf.
  • spring-boot-starter-webzawiera spring-boot-starter-tomcatwbudowaną wersję Apache Tomcat.
  • spring-boot-starter-json zawiera biblioteki Jackson JSON.
  • spring-web and spring-webmvc zawiera Spring MVC.
  • spring-boot-starter-test obejmuje biblioteki testowe, takie jak JUnit i Mockito.

Gdy Spring Boot widzi te zależności w CLASSPATH, inicjuje automatyczną konfigurację. Na przykład, kiedy znajdzie spring-boot-starter-web, tworzy osadzoną wersję Tomcata, a kiedy znajdzie H2 i spring-boot-starter-jpatworzy osadzoną bazę danych H2 i Hibernację EntityManager. Następnie łączy się z EntityManagerSpring Data.

Spring Boot tworzy również pojedynczą klasę, której można użyć do uruchomienia aplikacji. Klasę przykładowej aplikacji przedstawiono na liście 2.

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

Dla naszej aplikacji zdefiniujemy prosty obiekt modelu a Widget, zapiszemy go we wbudowanej bazie danych H2 i zbudujemy kontroler do zarządzania widgetami. Zacznijmy od Widgetklasy, która jest pokazana na Listingu 3.