Parte 8. Escribamos una pequeña aplicación usando Spring Boot

Este material es la parte final de la serie "Introducción al desarrollo empresarial". Artículos anteriores:

• acerca de la creación de redes
• sobre arquitectura de software
• sobre HTTP/HTTPS
• sobre los conceptos básicos de Maven
• sobre servlets (escribir una aplicación web simple)
• sobre contenedores de servlets
• sobre los conceptos básicos de MVC

Veamos la implementación más simple de MVC usando Spring MVC como ejemplo. Para hacer esto, escribiremos una pequeña aplicación Hello World usando Spring Boot. Te daré instrucciones paso a paso, para que puedas repetir todo tú mismo. Primero, escribiremos una pequeña aplicación y luego la analizaremos.

Paso 1. Creación de una aplicación Spring Boot en IntelliJ IDEA.

Use Archivo -> Nuevo -> Proyecto… para crear un nuevo proyecto. En la ventana que se abre, en el menú del lado izquierdo, seleccione Spring Initializr y seleccione Project SDK. Deje el valor predeterminado para la opción URL del servicio Initializr. Haga clic en el botón "Siguiente". En la siguiente ventana, debemos seleccionar la configuración del proyecto. Vamos a tener un proyecto Maven. Seleccione Proyecto Maven como el tipo. Rellene los campos Grupo y Artefacto Haga clic en Siguiente. En la siguiente ventana, debemos seleccionar los componentes de Spring Framework que usaremos. Dos son suficientes para nosotros:

• Spring Web es un componente que nos permite crear aplicaciones web. Este componente incluye Spring MVC.
• Thymeleaf es nuestro motor de plantillas. Es algo que nos permite enviar datos desde Java a páginas HTML

En la siguiente ventana, seleccione el nombre y la ubicación del proyecto en el sistema de archivos: Haga clic en el botón "Finalizar". Se crea el proyecto. Terminamos con la siguiente estructura de proyecto: Aquí estamos interesados ​​en 2 archivos: pom.xml (descriptor de implementación). Esto le permite importar rápida y fácilmente bibliotecas de diferentes marcos a nuestro proyecto. También es donde configuramos cómo se construye nuestra aplicación. Nuestra aplicación está construida usando Maven, y pom.xml es el archivo de configuración para este sistema de compilación. La clase Java es MvcDemoApplication. Esta es la clase principal de nuestra aplicación. Lanzaremos nuestro proyecto Spring Boot desde allí. Para comenzar, simplemente ejecute el método principal de esta clase. Aquí está el código para esta clase, así como el archivo pom.xml: MvcDemoApplication:

@SpringBootApplication
public class MvcDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(MvcDemoApplication.class, args);
    }

}

pom.xml:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.codegym/groupId>
    <artifactId>mvc_demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>mvc_demo</name>
    <description>Spring MVC Demo</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

Paso 2. Creación de una página web

Nuestra aplicación será extremadamente simple. Tendremos una página principal (index.html), que contendrá un enlace a la página de bienvenida (saludo.html). En la página de saludo, mostramos un saludo. Usaremos parámetros de URL para pasar el nombre que se usará en el saludo a la página greeting.html. Vamos a crear la página principal de nuestra aplicación — index.html:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Main page</title>
</head>
<body>
    <p>Get your greeting <a href="/greeting">here</a></p>
</body>
</html>

Ahora crearemos la página greeting.html:

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Getting Started: Serving Web Content</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body>
    <p th:text="'Hello, ' + ${name} + '!'" />
</body>
</html>

Nuestra página tiene una <p th:text="'Hello, ' + ${name} + '!'" />etiqueta, que no es normal para HTML. El thatributo de la petiqueta es un mecanismo utilizado por el motor de plantillas de Thymeleaf. El pvalor de la etiqueta será "Hola", + el valor de la namevariable, que estableceremos en código Java.

Paso 3. Crear un controlador

Dentro del paquete mvc_demo, crearemos un paquete controlador, en el que crearemos nuestro controlador, HelloWorldController:

@Controller
public class HelloWorldController {

   @RequestMapping(value = "/greeting")
   public String helloWorldController(@RequestParam(name = "name", required = false, defaultValue = "World") String name, Model model) {
       model.addAttribute("name", name);
       return "greeting";
   }

}

Por un lado, hay muy poco código, pero por otro lado, están sucediendo muchas cosas. Comencemos nuestro análisis. La anotación @Controller indica que esta clase es un controlador. En Spring, los controladores procesan solicitudes HTTP dirigidas a URL específicas. Nuestra clase tiene un método helloWorldController que está marcado con la anotación @RequestMapping(value = "/saludo"). Esta anotación indica que este método procesa solicitudes HTTP GET dirigidas a la URL /saludo. En otras palabras, este método se invocará si alguien navega a /saludo. Este método devuelve una cadena. Según Spring MVC, el método del controlador debe devolver el nombre de la vista. A continuación, Spring buscará un archivo HTML con el mismo nombre, que devolverá como respuesta a la solicitud HTTP. Como se puede ver, Nuestro método toma 2 argumentos. Echémosle un vistazo: Parámetro 1: @RequestParam(name = "name", required = false, defaultValue = "World") Nombre de la cadena. La anotación @RequestParam indica que el parámetro de nombre de cadena es un parámetro de URL. Si la anotación indica que este parámetro de URL es opcional (obligatorio = falso), entonces, si está ausente, el valor del parámetro de nombre de cadena será "Mundo" (valor predeterminado = "Mundo"). Si está presente, el parámetro de URL será "nombre" (nombre = "nombre"). Puede haber muchas cosas que no entiendas aquí. Proporcionemos algunos ejemplos. La siguiente tabla muestra cuál será el valor del parámetro Nombre de cadena, con varias opciones para acceder a /saludo (con y sin parámetros de URL) Parámetro 2: El segundo parámetro es un modelo modelo. Este parámetro es algún modelo. Este modelo consta de varios atributos internos. Cada atributo tiene un nombre y un valor. Algo así como pares clave-valor. Podemos usar este parámetro para enviar datos desde código Java a páginas HTML. O, utilizando la terminología de MVC, envíe datos desde el modelo a la vista. Sólo queda examinar la última línea. Es cómo enviamos datos de Java a HTML, o del modelo a la vista. El método incluye la siguiente línea: model.addAttribute("name", name); Aquí creamos un nuevo atributo llamado nombre y le asignamos el valor del parámetro nombre. Recuerde, recientemente discutimos el <p th:text = "'Hello,' + ${name} + '!'" /> Dijimos que el valor de la etiqueta p es "Hola", + el valor de la variable de nombre, que estableceremos en código Java. Establecemos este valor usando la línea model.addAttribute("name", name);

Paso 5. Ejecutar

Para comenzar, necesitamos ejecutar el método principal de la clase MvcDemoApplication: En los registros, veremos que nuestra aplicación web se inició en el puerto 8080: Y esto significa que en un navegador, podemos ir a la página en http:// localhost:8080 : Aquí tenemos la página index.html. Sigamos el enlace a la página de saludo: Nuestro controlador fue invocado en esta transición. No pasamos ningún parámetro a través de la URL. Como resultado, el atributo de nombre toma el valor predeterminado ("Mundo") indicado en la anotación. Intentemos pasar el parámetro a través de la URL: todo funciona según lo previsto. Ahora intente rastrear la ruta de la variable de nombre:

1. El usuario pasó "name=Amigo" en la URL ->
2. El controlador procesó nuestra acción, recibió la variable de nombre y estableció un atributo de modelo llamado nombre igual al valor recibido ->
3. Estos datos se vieron desde el modelo, terminaron en la página greeting.html y se mostraron al usuario.

¡Eso es todo por ahora!