Dominando Spring Framework 5, Parte 1: Spring MVC

Spring MVC es la biblioteca tradicional de Spring Framework para crear aplicaciones web Java. Es uno de los frameworks web más populares para construir aplicaciones web Java completamente funcionales y servicios web RESTful. En este tutorial, obtendrá una descripción general de Spring MVC y aprenderá a crear aplicaciones web Java utilizando Spring Boot, Spring Initializr y Thymeleaf.

descargar Descargar el código Obtenga el código fuente para aplicaciones de ejemplo en este tutorial. Creado para JavaWorld por Steven Haines

Spring Boot con Spring Initializr

Realizaremos un seguimiento rápido de nuestra aplicación web Spring MVC con la ayuda de Spring Boot y Spring Initializr. Dada la entrada para el tipo de aplicación que se va a construir, Spring Initializr usa las dependencias más comunes y los valores predeterminados para instalar y configurar una aplicación Spring Boot básica. También puede agregar dependencias personalizadas y Spring Initializr las incluirá y administrará, lo que garantiza la compatibilidad de la versión con software de terceros y Spring. Las aplicaciones Spring Boot se ejecutan de forma independiente, sin necesidad de proporcionar un entorno de tiempo de ejecución.

En este caso, dado que estamos creando una aplicación web, Spring Boot incluirá y configurará automáticamente Tomcat como parte del tiempo de ejecución de la aplicación. También podemos personalizar la aplicación agregando un controlador de base de datos H2 a nuestro archivo Maven POM. Spring Boot creará automáticamente una base de datos integrada y una DataSourceinstancia en el contexto de la aplicación. Una vez que se establecen las dependencias, Spring Boot proporcionará configuraciones predeterminadas para la aplicación. Por supuesto, podemos cambiar las configuraciones si queremos, pero gracias a Spring Boot tenemos una ventaja: una aplicación totalmente configurada que funciona desde el primer momento.

Una vez que hayamos seleccionado y configurado nuestras dependencias, pasaremos esas selecciones a Spring Initializr, que proporcionará un archivo ZIP descargable que contiene un proyecto Spring Boot base.

Spring MVC con motor de base de datos H2

Comenzaremos creando una aplicación web Spring MVC básica que conserva los datos en una base de datos integrada H2.

Paso 1. Instalar y configurar la aplicación

Navegue a Spring Initializr en start.spring.io y seleccione Generar un proyecto Maven con Java y Spring Boot 2.0.X , donde X es la última versión de Spring Boot (2.0.3 al momento de escribir este artículo). Asegúrese de seleccionar Spring Boot 2.x para que pueda implementar Spring Web MVC 5. Spring Boot 1.4 y Spring Boot 1.5 implementarán Spring 4.

Ingrese un nombre de grupo con el formato que coincida con su dirección web, como com.geekcap.javaworld, e ingrese un nombre de artefacto, como spring5mvc-example. La figura 1 muestra mi configuración.

Steven Haines

Para agregar dependencias a la aplicación web, puede ingresar una lista de dependencias separadas por comas en el campo de texto Buscar dependencias o hacer clic en Cambiar a la versión completa . Tomaremos la ruta más fácil haciendo clic en Cambiar a la versión completa . Las dependencias se dividen en grupos, como motores centrales, web y de plantillas. Para este ejemplo, seleccione las casillas de verificación para: Web -> Web, Motores de plantillas -> Thymeleaf, SQL -> JPA y SQL -> H2 . Esto es lo que cada una de esas selecciones agregará a la aplicación:

  • Web: Spring MVC y Tomcat
  • Thymeleaf: motor de plantillas web Thymeleaf
  • JPA: Spring JPA, Hibernate y Spring Data
  • H2: La base de datos incorporada H2

Cuando haya terminado, haga clic en el botón Generar proyecto en la parte inferior de la página. Spring Initializr creará un archivo ZIP listo para usar con todas las fuentes del proyecto requeridas, que puede descargar.

Paso 2. Importe el proyecto Spring Initializr a su IDE

Extraiga el archivo ZIP de Spring Initializr, luego importe el proyecto a su IDE favorito. Por ejemplo, para importar el proyecto a IntelliJ, elija Archivo -> Nuevo proyecto , como se muestra en la Figura 2.

Steven Haines

Paso 3. Configure su Maven POM

A continuación, vaya a Importar proyecto desde un módulo externo , elija Maven y presione Siguiente . Asegúrese de elegir un SDK de proyecto Java 1.8 y luego presione Finalizar .

La aplicación de inicio Spring Boot

Ahora echemos un vistazo a la aplicación de inicio Spring Boot que ha sido generada por nuestros (mínimos) esfuerzos hasta ahora.

Para comenzar, el Listado 1 muestra el archivo POM de Maven.

Listado 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     

Tenga en cuenta que el archivo POM POM utiliza una matriz especial: spring-boot-starter-parent. Usaremos el POM principal para administrar las versiones de todas nuestras dependencias y asegurarnos de que las versiones sean compatibles. Los repositorios al final del archivo POM hacen referencia a los repositorios de instantáneas y hitos de Spring . Los necesitamos porque Spring Boot 2.x todavía es un lanzamiento importante en el momento de escribir este artículo.

Las dependencias son bastante mínimas y la mayoría están precedidas por spring-boot-starter:

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

Cada una de estas dependencias de inicio trae todas las subdependencias que necesita. La Figura 3 muestra la vista de dependencia parcialmente expandida en IntelliJ.

Steven Haines

El archivo POM incluye las siguientes dependencias:

  • spring-boot-starter-data-jpa incluye Hibernate y Spring Data.
  • spring-boot-starter-thymeleaf incluye el motor de plantillas Thymeleaf.
  • spring-boot-starter-webincluye spring-boot-starter-tomcat, una versión integrada de Apache Tomcat.
  • spring-boot-starter-json incluye las bibliotecas Jackson JSON.
  • spring-web and spring-webmvc incluye Spring MVC.
  • spring-boot-starter-test incluye bibliotecas de prueba como JUnit y Mockito.

Cuando Spring Boot ve estas dependencias en CLASSPATH, inicia la configuración automática. Por ejemplo, cuando encuentra spring-boot-starter-web, crea una versión incrustada de Tomcat, y cuando encuentra H2 y spring-boot-starter-jpacrea una base de datos incrustada H2 y un Hibernate EntityManager. Luego se conecta EntityManagera Spring Data.

Spring Boot también crea una clase única que se puede usar para ejecutar la aplicación. La clase para la aplicación de ejemplo se muestra en el Listado 2.

Listado 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

Para nuestra aplicación, definiremos un objeto modelo simple, a Widget, lo almacenaremos en una base de datos H2 incrustada y crearemos un controlador para administrar widgets. Comencemos con la Widgetclase, que se muestra en el Listado 3.