Padroneggiare il framework 5 di Spring, Parte 1: Spring MVC

Spring MVC è la libreria tradizionale del framework Spring per la creazione di applicazioni Web Java. È uno dei framework Web più popolari per la creazione di applicazioni Web Java completamente funzionali e servizi Web RESTful. In questo tutorial, otterrai una panoramica di Spring MVC e imparerai come creare applicazioni Web Java utilizzando Spring Boot, Spring Initializr e Thymeleaf.

scarica Scarica il codice Ottieni il codice sorgente per applicazioni di esempio in questo tutorial. Creato per JavaWorld da Steven Haines

Spring Boot con Spring Initializr

Affronteremo la nostra applicazione web Spring MVC con l'aiuto di Spring Boot e Spring Initializr. Dato l'input per il tipo di applicazione da creare, Spring Initializr utilizza le dipendenze e le impostazioni predefinite più comuni per impostare e configurare un'applicazione Spring Boot di base. Puoi anche aggiungere dipendenze personalizzate e Spring Initializr le includerà e le gestirà, garantendo la compatibilità della versione sia con software di terze parti che con Spring. Le applicazioni Spring Boot vengono eseguite autonomamente, senza richiedere di fornire un ambiente di runtime.

In questo caso, poiché stiamo creando un'applicazione web, Spring Boot includerà e configurerà automaticamente Tomcat come parte del runtime dell'app. Possiamo anche personalizzare l'app aggiungendo un driver di database H2 al nostro file POM Maven. Spring Boot creerà quindi automaticamente un database incorporato e DataSourceun'istanza nel contesto dell'applicazione. Una volta impostate le dipendenze, Spring Boot fornirà le configurazioni predefinite per l'applicazione. Ovviamente possiamo cambiare le configurazioni se lo vogliamo, ma grazie a Spring Boot abbiamo un vantaggio: un'applicazione funzionante e completamente configurata, pronta all'uso.

Una volta selezionate e configurate le nostre dipendenze, passeremo queste selezioni a Spring Initializr, che fornirà un file ZIP scaricabile contenente un progetto Spring Boot di base.

Spring MVC con motore di database H2

Inizieremo creando un'applicazione Web Spring MVC di base che mantiene i dati in un database incorporato H2.

Passaggio 1. Imposta e configura l'app

Passare a Spring Initializr su start.spring.io e selezionare Genera un progetto Maven con Java e Spring Boot 2.0.X , dove X è l'ultima versione di Spring Boot (2.0.3 al momento della stesura di questo documento). Assicurati di selezionare Spring Boot 2.x in modo da poter implementare Spring Web MVC 5. Spring Boot 1.4 e Spring Boot 1.5 implementeranno Spring 4.

Immettere un nome di gruppo con il formato corrispondente al proprio indirizzo Web, ad esempio com.geekcap.javaworld, e immettere un nome di artefatto, ad esempio spring5mvc-example. La figura 1 mostra la mia configurazione.

Steven Haines

Per aggiungere dipendenze all'app Web, puoi inserire un elenco di dipendenze separato da virgole nel campo di testo Cerca dipendenze o fare clic su Passa alla versione completa . Prenderemo la strada più semplice facendo clic su Passa alla versione completa . Le dipendenze sono suddivise in gruppi, come Core, Web e Template Engines. Per questo esempio, seleziona le caselle di controllo per: Web -> Web, Template Engines -> Thymeleaf, SQL -> JPA e SQL -> H2 . Ecco cosa aggiungerà ciascuna di queste selezioni all'applicazione:

  • Web: Spring MVC e Tomcat
  • Thymeleaf: motore di template web Thymeleaf
  • JPA: Spring JPA, Hibernate e Spring Data
  • H2: il database incorporato H2

Al termine, fai clic sul pulsante Genera progetto nella parte inferiore della pagina. Spring Initializr creerà un file ZIP già pronto con tutte le fonti di progetto richieste, che puoi scaricare.

Passaggio 2. Importa il progetto Spring Initializr nel tuo IDE

Estrai il file ZIP da Spring Initializr, quindi importa il progetto nel tuo IDE preferito. Ad esempio, per importare il progetto in IntelliJ, scegli File -> Nuovo progetto , come mostrato nella Figura 2.

Steven Haines

Passaggio 3. Imposta il tuo Maven POM

Quindi, vai a Importa progetto da modulo esterno , scegli Maven e premi Avanti . Assicurati di scegliere un SDK del progetto Java 1.8, quindi premi Fine .

L'app di avvio di Spring Boot

Ora diamo un'occhiata all'applicazione iniziale Spring Boot che è stata generata dai nostri (minimi) sforzi fino ad ora.

Per iniziare, il Listato 1 mostra il file POM di Maven.

Listato 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     

Si noti che il file POM utilizza uno speciale POM genitore: spring-boot-starter-parent. Useremo il POM genitore per gestire le versioni di tutte le nostre dipendenze e assicurarci che le versioni siano compatibili. I repository alla fine del file POM fanno riferimento agli snapshot Spring e ai repository milestone . Ne abbiamo bisogno perché Spring Boot 2.x è ancora una pietra miliare al momento della stesura di questo documento.

Le dipendenze sono piuttosto minime e la maggior parte è preceduta da spring-boot-starter:

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

Ognuna di queste dipendenze iniziali porta tutte le sotto-dipendenze di cui ha bisogno. La Figura 3 mostra la visualizzazione delle dipendenze parzialmente espansa in IntelliJ.

Steven Haines

Il file POM include le seguenti dipendenze:

  • spring-boot-starter-data-jpa include Hibernate e Spring Data.
  • spring-boot-starter-thymeleaf include il motore di template Thymeleaf.
  • spring-boot-starter-webinclude spring-boot-starter-tomcat, una versione incorporata di Apache Tomcat.
  • spring-boot-starter-json include le librerie Jackson JSON.
  • spring-web and spring-webmvc include Spring MVC.
  • spring-boot-starter-test include librerie di test come JUnit e Mockito.

Quando Spring Boot vede queste dipendenze in CLASSPATH, avvia la configurazione automatica. Ad esempio, quando trova spring-boot-starter-web, crea una versione incorporata di Tomcat e quando trova H2 e spring-boot-starter-jpacrea un database incorporato H2 e un Hibernate EntityManager. Quindi collega EntityManagera Spring Data.

Spring Boot crea anche una singola classe che può essere utilizzata per eseguire l'applicazione. La classe per l'applicazione di esempio è mostrata nel Listato 2.

Listato 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

Per la nostra applicazione, definiremo un semplice oggetto modello, a Widget, lo memorizzeremo in un database H2 incorporato e costruiremo un controller per gestire i widget. Cominciamo con la Widgetclasse, che è mostrata nel Listato 3.