Maîtriser le framework Spring 5, Partie 1: Spring MVC

Spring MVC est la bibliothèque traditionnelle du framework Spring pour la création d'applications Web Java. C'est l'un des frameworks Web les plus populaires pour la création d'applications Web Java entièrement fonctionnelles et de services Web RESTful. Dans ce didacticiel, vous aurez une vue d'ensemble de Spring MVC et apprendrez à créer des applications Web Java à l'aide de Spring Boot, Spring Initializr et Thymeleaf.

télécharger Téléchargez le code Obtenez le code source des exemples d'applications dans ce didacticiel. Créé pour JavaWorld par Steven Haines

Spring Boot avec Spring Initializr

Nous allons accélérer notre application Web Spring MVC à l'aide de Spring Boot et Spring Initializr. Compte tenu du type d'application à créer, Spring Initializr utilise les dépendances et les valeurs par défaut les plus courantes pour installer et configurer une application Spring Boot de base. Vous pouvez également ajouter des dépendances personnalisées et Spring Initializr les inclura et les gérera, garantissant la compatibilité des versions avec les logiciels tiers et Spring. Les applications Spring Boot s'exécutent de manière autonome, sans que vous ayez à fournir un environnement d'exécution.

Dans ce cas, puisque nous construisons une application Web, Spring Boot inclura et configurera automatiquement Tomcat dans le cadre de l'exécution de l'application. Nous pouvons également personnaliser l'application en ajoutant un pilote de base de données H2 à notre fichier Maven POM. Spring Boot créera alors automatiquement une base de données intégrée et une DataSourceinstance dans le contexte de l'application. Une fois les dépendances définies, Spring Boot fournira des configurations par défaut pour l'application. Bien sûr, nous pouvons changer les configurations si nous le voulons, mais grâce à Spring Boot, nous avons une longueur d'avance: une application entièrement configurée et opérationnelle dès la sortie de la boîte.

Une fois que nous avons sélectionné et configuré nos dépendances, nous transmettrons ces sélections à Spring Initializr, qui fournira un fichier ZIP téléchargeable contenant un projet Spring Boot de base.

Spring MVC avec moteur de base de données H2

Nous allons commencer par créer une application Web Spring MVC de base qui persiste les données dans une base de données intégrée H2.

Étape 1. Installer et configurer l'application

Accédez à Spring Initializr à start.spring.io et sélectionnez Générer un projet Maven avec Java et Spring Boot 2.0.X , où X est la dernière version de Spring Boot (2.0.3 au moment de la rédaction de cet article). Assurez-vous de sélectionner Spring Boot 2.x afin de pouvoir implémenter Spring Web MVC 5. Spring Boot 1.4 et Spring Boot 1.5 implémenteront Spring 4.

Entrez un nom de groupe au format correspondant à votre adresse Web, tel que com.geekcap.javaworld, et entrez un nom d'artefact, tel que spring5mvc-example. La figure 1 montre ma configuration.

Steven Haines

Pour ajouter des dépendances à l'application Web, vous pouvez soit entrer une liste de dépendances séparées par des virgules dans le champ de texte Rechercher les dépendances , soit cliquer sur Passer à la version complète . Nous emprunterons la voie la plus simple en cliquant sur Passer à la version complète . Les dépendances sont divisées en groupes, tels que les moteurs Core, Web et Template. Pour cet exemple, cochez les cases pour: Web -> Web, moteurs de modèles -> Thymeleaf, SQL -> JPA et SQL -> H2 . Voici ce que chacune de ces sélections ajoutera à l'application:

  • Web: Spring MVC et Tomcat
  • Thymeleaf: moteur de template Web Thymeleaf
  • JPA: Spring JPA, Hibernate et Spring Data
  • H2: La base de données embarquée H2

Lorsque vous avez terminé, cliquez sur le bouton Générer un projet en bas de la page. Spring Initializr créera un fichier ZIP prêt à l'emploi avec toutes les sources de projet requises, que vous pouvez télécharger.

Étape 2. Importez le projet Spring Initializr dans votre IDE

Extrayez le fichier ZIP de Spring Initializr, puis importez le projet dans votre IDE préféré. Par exemple, pour importer le projet dans IntelliJ, choisissez Fichier -> Nouveau projet , comme illustré à la figure 2.

Steven Haines

Étape 3. Configurez votre Maven POM

Ensuite, accédez à Importer un projet à partir d'un module externe , choisissez Maven et appuyez sur Suivant . Assurez-vous de choisir un SDK de projet Java 1.8, puis cliquez sur Terminer .

L'application de démarrage Spring Boot

Jetons maintenant un coup d'œil à l'application de démarrage Spring Boot qui a été générée par nos efforts (minimes) jusqu'à présent.

Pour commencer, le listing 1 montre le fichier Maven POM.

Liste 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     

Notez que le fichier POM utilise un parent spécial POM: spring-boot-starter-parent. Nous utiliserons le POM parent pour gérer les versions de toutes nos dépendances et nous assurer que les versions sont compatibles. Les référentiels à la fin du fichier POM font référence aux référentiels de clichés et de jalons Spring . Nous en avons besoin car Spring Boot 2.x est toujours une version jalon au moment de la rédaction de cet article.

Les dépendances sont assez minimes et la plupart sont précédées de spring-boot-starter:

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

Chacune de ces dépendances de démarrage apporte toutes les sous-dépendances dont elle a besoin. La figure 3 montre la vue des dépendances partiellement développée dans IntelliJ.

Steven Haines

Le fichier POM comprend les dépendances suivantes:

  • spring-boot-starter-data-jpa inclut Hibernate et Spring Data.
  • spring-boot-starter-thymeleaf inclut le moteur de modèle Thymeleaf.
  • spring-boot-starter-webinclut spring-boot-starter-tomcat, une version intégrée d'Apache Tomcat.
  • spring-boot-starter-json inclut les bibliothèques Jackson JSON.
  • spring-web and spring-webmvc comprend Spring MVC.
  • spring-boot-starter-test inclut des bibliothèques de test telles que JUnit et Mockito.

Lorsque Spring Boot voit ces dépendances dans le CLASSPATH, il lance la configuration automatique. Par exemple, quand il trouve spring-boot-starter-web, il crée une version intégrée de Tomcat, et quand il trouve H2 et spring-boot-starter-jpail crée une base de données intégrée H2 et un Hibernate EntityManager. Il connecte ensuite le EntityManagerdans Spring Data.

Spring Boot crée également une classe unique qui peut être utilisée pour exécuter l'application. La classe de l'exemple d'application est indiquée dans le Listing 2.

Liste 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

Pour notre application, nous allons définir un objet modèle simple, a Widget, le stocker dans une base de données H2 intégrée et créer un contrôleur pour gérer les widgets. Commençons par la Widgetclasse, qui est montrée dans le Listing 3.