Spring MVC – Interfaz del modelo

Spring Web model-view-controller (MVC) es un marco de código abierto que se utiliza para crear aplicaciones web J2EE. Se basa en el patrón de diseño Modelo-Vista-Controlador e implementa las características básicas de un marco de resorte central: Inyección de dependencia. Está diseñado en torno a un ‘DispatcherServlet’ que envía requests a los controladores, con asignaciones de controladores configurables, resolución de vista, configuración regional y resolución de temas, así como soporte para cargar archivos. En el marco de MVC, M significa Modelo, que se usa para trabajar con los datos, V significa Vista, que se usa para presentar datos al usuario y C significa Controlador, que contiene la lógica comercial real para procesar la entrada del usuario.

Spring Framework proporciona una interfaz llamada Modelo (I) para trabajar con los datos. Define un marcador de posición para los atributos del modelo y está diseñado principalmente para agregar atributos al modelo. También se usa para transferir datos entre la vista y el controlador de la aplicación Spring MVC. La interfaz del modelo está disponible en el paquete org.springframework.ui . Actúa como un contenedor de datos que contiene los datos de la aplicación. Que los datos almacenados pueden ser de cualquier forma, como string, objeto, datos de la base de datos, etc.

Métodos disponibles en el modelo (I)

A continuación se muestran los métodos disponibles en el Modelo (I).

1) agregar atributo

Agrega el atributo especificado bajo el nombre proporcionado.

Model addAttribute(String attributeName,

                   @Nullable

                   Object attributeValue)
                   
attributeName - the name of the model attribute - can never be null
attributeValue - the model attribute value - can be null

2) agregar atributo

Agrega el atributo especificado a este Mapa usando un nombre generado.

Model addAttribute(Object attributeValue)

attributeValue - the model attribute value - can never be null

3) agregar todos los atributos

Para copiar todos los atributos de la colección especificada en este mapa, mediante la generación de nombres de atributos para cada elemento.

Model addAllAttributes(Collection<?> attributeValues)

attributeValues - the model attribute values

4) agregar todos los atributos

Para copiar todos los atributos del Mapa proporcionado en este Mapa.

Model addAllAttributes(Map<String,?> attributes)

5) fusionar atributos

Para copiar todos los atributos del mapa proporcionado en este mapa, con los objetos existentes del mismo nombre teniendo prioridad, es decir, no se reemplazan.

Model mergeAttributes(Map<String,?> attributes)

6) contiene atributo

¿Para verificar si este modelo contiene un atributo del nombre de pila?

boolean containsAttribute(String attributeName)

attributeName - the name of the model attribute - not null
It returns the value true/false.

7) obtener atributo

Para devolver el valor del atributo para el nombre especificado, si está presente.

@Nullable

Object getAttribute(String attributeName)

attributeName - the name of the model attribute - not null
It returns the corresponding attribute value. If not, it returns null.

8) como mapa

Devuelve el conjunto actual de atributos del modelo como un mapa.

Map<String,Object> asMap()

Aplicación Spring MVC

Crearemos una aplicación Spring MVC simple en Spring Tool Suite (STS) sobre cómo usar los objetos Model para almacenar los datos del formulario.

Pasos para crear la aplicación:

1. Cree un proyecto Spring MVC en Spring Tool Suite.
2. En STS, al crear el proyecto basado en la selección del desarrollador, descargará todas las dependencias maven requeridas, *.jar, archivos lib y proporcionará un servidor integrado.
3. Podemos ver que todas las dependencias que se requieren están disponibles en el archivo ‘pom.xml’.
4. Cree una clase Bean, una clase Controller y las páginas de vista JSP.
5. A continuación se muestra la estructura final del proyecto Spring MVC después de crear archivos *.java y *.jsp.

Estructura del proyecto

Implementación:

Los archivos a crear son los siguientes:

1. Details.java – Clase Bean – Para definir las propiedades del campo y los métodos getter/setter de las propiedades.
2. DetailsController.java – Clase de controlador – Para procesar la solicitud del usuario y generar la salida.
3. detalles.jsp : archivo JSP para interactuar con el usuario para la entrada.
4. detailsSummary.jsp : archivo JSP para mostrar la salida al usuario después de procesar la entrada.

1) Archivo de detalles.java:

package com.geeks.app;
  
public class Details {
      
    private String name;
    private String lang;
    private String ide;
  
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getLang() {
        return lang;
    }
    public void setLang(String lang) {
        this.lang = lang;
    }
    public String getIde() {
        return ide;
    }
    public void setIde(String ide) {
        this.ide = ide;
    }
      
}

La clase ‘Detalles’ tiene tres atributos: nombre, idioma e ide y sus métodos getters/setters para que todas las propiedades obtengan y establezcan los valores.

2) Archivo DetailsController.java:

package com.geeks.app;
  
import java.util.Arrays;
import java.util.List;
  
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
  
@Controller
public class DetailsController {
      
    @RequestMapping(value = "/")
    public String viewPage(Model model) {
  
        Details detail = new Details();
        model.addAttribute("detail", detail);
          
        List<String> ideNames = Arrays.asList("Eclipse", "IntelliJ", "PyCharm", "Visual Studio", "NetBeans");
        model.addAttribute("ideNames", ideNames);        
          
        return "details";
    }
  
    @RequestMapping(value = "/submit", method = RequestMethod.POST)
    public String submit(@ModelAttribute("detail") Details detail) {
            return "detailsSummary";
    }
  
}

Este controlador tiene un método GET asignado a ‘/’ y un método POST asignado a ‘/submit’.

Anotaciones utilizadas:

• @Controller transmite al contenedor que esta clase es la clase de controlador de resorte. Para usar esta anotación, necesitamos importar el paquete org.springframework.stereotype.Controller.
• @RequestMapping, asigna las URL de solicitud al método especificado en función del valor proporcionado. Para usar esta anotación, debemos importar el paquete org.springframework.web.bind.annotation.RequestMapping.
• @ModelAttribute, que se usa para vincular un parámetro de método o un valor de retorno de método al atributo del modelo nombrado. Necesitamos importar el paquete org.springframework.web.bind.annotation.ModelAttribute.

El método ‘viewPage’ devuelve la plantilla de formulario ‘detalle’. Incluye el atributo de modelo ‘detalle’ para que la plantilla pueda asociar atributos de formulario con un objeto de ‘detalle’. Y también, incluye el atributo de modelo ‘ideNames’ para mostrar los valores en el campo desplegable que se asigna con el mismo nombre en la página JSP. El método ‘enviar’ tiene el objeto ‘Detalles’, redirige el navegador a la página ‘detallesResumen’ en la solicitud POST.

3) archivo detalles.jsp:

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<%@taglib uri="http://www.springframework.org/tags/form" prefix="form"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<title>Welcome Page</title>
</head>
<body>
  
    <h2>Welcome to GeeksforGeeks!!</h2>
    <h3>Please fill in the form</h3>
    <form:form action="submit" method="post" modelAttribute="detail">
        <table>
            <tr>
                <td><form:label path="name">Name: </form:label></td>
                <td><form:input path="name" /></td>
            </tr>
            <tr>
                <td><form:label path="lang">Coding Language: </form:label></td>
                <td><form:radiobutton path="lang" label="Java" value="Java" />
                    <form:radiobutton path="lang" label="C Language" value="C Language" />
                    <form:radiobutton path="lang" label="Python" value="Python" /></td>
            </tr>
            <tr>
                <td><form:label path="ide">Select IDE: </form:label></td>
                <td><form:select path="ide" items="${ideNames}" /></td>
            </tr>
            <tr>
                <td><form:button>Submit</form:button></td>
            </tr>
        </table>
    </form:form>
  
</body>
</html>

La página contiene un formulario simple, con cada uno de sus campos en una celda separada en una tabla. El formulario está diseñado para publicar en ‘/submit’. Está marcado como respaldado por el atributo de modelo ‘detalles’ y el método ‘POST’ – ‘enviar’ en el controlador web. Estamos utilizando la biblioteca de etiquetas de Spring Form para mostrar los nombres de las etiquetas, los campos de entrada, las etiquetas desplegables y los botones de opción. En el campo desplegable, usamos el marcador de posición ‘${ideNames}’, en el que una vez que se ejecuta la aplicación, este objeto contenedor se actualizará con los datos proporcionados en el atributo de modelo ‘ideNames’ en la clase del controlador.

4) archivo detailsSummary.jsp:

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<title>Summary page</title>
</head>
<body>
  
    <h3>Details submitted!</h3>
  
    <table>
        <tr>
            <td>Name:</td>
            <td>${detail.name}</td>
        </tr>
        <tr>
            <td>Coding Language:</td>
            <td>${detail.lang}</td>
        </tr>
        <tr>
            <td>IDE selected:</td>
            <td>${detail.ide}</td>
        </tr>
    </table>
  
</body>
</html>

Esta es la página JSP de resultados para mostrar los valores ingresados ​​por el usuario en el navegador después del procesamiento de la entrada. Cada campo se mostrará en una celda separada en una tabla.

Ejecute la aplicación:

• Haga clic con el botón derecho en el Proyecto, Ejecutar como -> Ejecutar en el servidor.
• Seleccione el servidor en el host local para ejecutar la aplicación.
• Abra la URL: http://localhost:8080/app/ en el navegador para obtener la siguiente pantalla.

Pagina de bienvenida

• Ingrese los detalles en el formulario.

Aporte

• Haga clic en enviar para obtener el resultado.

Producción