Parte 8. Escribir una pequeña aplicación en Spring-boot

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

• sobre la red ;
• sobre arquitectura de software ;
• sobre los protocolos HTTP/HTTPS ;
• sobre los conceptos básicos de Maven ;
• sobre servlets (estamos escribiendo una aplicación web sencilla) ;
• sobre contenedores de servlets .
• sobre los conceptos básicos de MVC .

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

Paso 1: cree una aplicación de arranque de primavera en IntelliJ IDEA

Usando Archivo -> Nuevo -> Proyecto... cree un nuevo proyecto. En la ventana que se abre, en el menú del lado izquierdo, seleccione Spring Initializr, seleccione Project SDK y deje la opción URL del servicio Initializr como predeterminada. Haga clic en el botón Siguiente. En la siguiente ventana debemos seleccionar los parámetros del proyecto. Tendremos un proyecto Maven. Seleccione Tipo: Proyecto Maven, complete Grupo y Artefacto y haga clic en Siguiente. En la siguiente ventana debemos seleccionar los componentes de Spring Framework que usaremos. Sólo necesitamos dos:

• Spring Web es un componente que nos permitirá crear aplicaciones Web. Este componente incluye Spring MVC.
• Thymeleaf: el llamado motor de plantillas. Algo que nos permitirá transferir datos de 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. El proyecto ha sido creado. Tenemos la siguiente estructura de proyecto: Aquí nos interesan 2 archivos: pom.xml - descriptor de implementación. Algo que le permite importar rápida y fácilmente bibliotecas de diferentes marcos a nuestro proyecto, así como algo en el que configuramos el ensamblaje de nuestra aplicación. Nuestra aplicación está construida con Maven, pom.xml es el archivo de configuración de este sistema de compilación. Clase Java: MvcDemoApplication. Esta es la clase principal de nuestra aplicación, desde la cual lanzaremos nuestro proyecto Spring-Boot. 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.javarush</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. Crea páginas web

Nuestra aplicación será sumamente sencilla. Tendremos una página principal: index.html, dentro de la cual habrá un enlace a la página de bienvenida: Greeting.html. En la página de saludo mostraremos el saludo. Implementemos la capacidad de enviar un nombre de saludo a la página saludo.html a través de parámetros de URL. Creemos 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 creemos la página saludo.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>

Aquí, desde una página HTML atípica, puede ver una etiqueta: El <p th:text="'Hello, ' + ${name} + '!'" /> atributo de etiqueta es una herramienta del motor de plantillas Thymeleaf. Gracias a ello, el valor de la etiqueta será el texto “Hola” + el valor de la variable , que estableceremos desde código Java. thppname

Paso 3: crea un controlador

Dentro del paquete mvc_demo crearemos un paquete de control, dentro del cual 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, están sucediendo muchas cosas. Comencemos el análisis. La anotación @Controller indica que esta clase es un controlador. Los controladores en Spring procesan solicitudes HTTP a direcciones específicas. Nuestra clase tiene un método helloWorldController, que está marcado con la anotación - @RequestMapping(value = "/greeting"). Esta anotación nos dice que este método procesa solicitudes HTTP GET a la dirección /saludo. En otras palabras, este método funcionará si alguien va a /saludar. 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 será devuelto como respuesta a la solicitud HTTP. Como puede ver, nuestro método devuelve el nombre de la página web que creamos anteriormente: saludo. Nuestro método toma 2 argumentos. Veámoslos: Parámetro 1: @RequestParam(nombre = "nombre", requerido = falso, valor predeterminado = "Mundo") Nombre de cadena. La anotación @RequestParam indica que el parámetro de nombre de cadena es un parámetro de URL. Los paréntesis de anotación indican que este parámetro en la URL es opcional (obligatorio = falso), si está ausente, el valor del parámetro Nombre de cadena será Mundo (defaultValue = "Mundo"), y si está presente, entonces este parámetro en la URL se llamará nombre (nombre = "nombre") Puede que haya muchas cosas que no estén claras aquí. Pongamos ejemplos. La siguiente tabla muestra cuál será el valor del parámetro Nombre de cadena para diferentes opciones para acceder a la dirección /saludo (con y sin parámetros en la URL) Parámetro 2: El segundo parámetro es Modelo modelo. Este parámetro es un modelo. Este modelo consta internamente de varios atributos. Cada atributo tiene un nombre y un valor. Algo así como pares clave-valor. Usando este parámetro, podemos transferir datos del código Java a páginas html. O, en terminología MVC, transferir datos del Modelo a la Vista. Queda por analizar la última línea. La forma en que pasamos datos de Java a html o del Modelo a la Vista. El cuerpo del método contiene 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 la etiqueta: <p th:text="'Hello, ' + ${name} + '!'" /> dijimos que el valor de la etiqueta p será el texto "Hola" + el valor de la variable de nombre, que estableceremos desde el código Java. Establecemos este valor usando la línea model.addAttribute("name", name);

Paso 5. Lanzar

Para iniciar, necesitamos ejecutar el método principal en la clase MvcDemoApplication: En los registros de inicio, veremos que nuestra aplicación web se inició en el puerto 8080: Y esto significa que podemos ir a la página en el navegador: http:// localhost:8080 : Aquí se nos mostró la página index.html. Sigamos el enlace para saludar: Durante esta transición, nuestro controlador funcionó. No pasamos ningún parámetro a través de la URL, por lo tanto, como se indica en la anotación, el valor del atributo de nombre tomó el valor predeterminado Mundo. Intentemos ahora pasar el parámetro a través de la URL: todo funciona según lo previsto. Ahora intenta rastrear la ruta de la variable de nombre:

1. El usuario pasó el valor del parámetro nombre = Amigo -> vía url
2. El controlador procesó nuestra acción, aceptó la variable de nombre y estableció el atributo del modelo, con el nombre y el valor aceptado ->
3. Desde el modelo, estos datos fueron a la Vista, a la página saludo.html y se mostraron al usuario.

¡Eso es todo!