Spring MVC usando configuración basada en Java

Requisitos previos: patrón de diseño MVC , Spring MVC con JSP View
El marco Spring MVC permite la separación de módulos, a saber , Model , View y Controller , y maneja sin problemas la integración de la aplicación. Esto permite al desarrollador crear aplicaciones complejas que también utilizan clases Java sencillas. El objeto modelo se puede pasar entre la vista y el controlador usando mapas. En este artículo, veremos cómo configurar una aplicación Spring MVC en el IDE de Eclipse y comprenderemos cómo crear aplicaciones. 
El marco Spring MVC se compone de los siguientes componentes: 
 

• Modelo: Un modelo puede ser un objeto o colección de objetos que básicamente contiene los datos de la aplicación.
• Vista: una vista se utiliza para mostrar la información al usuario en un formato específico. Spring soporta varias tecnologías como freemarker , speed y thymeleaf .
• Controlador: Contiene la parte lógica de la aplicación. La anotación @Controller se usa para marcar esa clase como controlador.
• Front Controller : Sigue siendo el responsable de gestionar el flujo de la aplicación web. DispatcherServlet actúa como un controlador frontal en Spring MVC.

Requisitos: 

• Eclipse (versión EE).
• Tomcat Apache última versión.

Pasos para configurar la aplicación Spring MVC en Eclipse IDE:
 

• Paso 1: Vaya al menú Archivo y haga clic en Nuevo -> Proyecto Maven. 
   

• Paso 2: Luego, en la barra de búsqueda, escriba maven . Haga clic en Proyecto Maven y haga clic en Siguiente . 
   

• Paso 3: La configuración predeterminada debe permanecer como está. Haga clic en Siguiente. 
   

• Paso 4: Seleccione maven-archetype-webapp para la aplicación web y haga clic en Siguiente . 
   

• Paso 5: proporcione una identificación de grupo y una identificación de artefacto . 
   

• Paso 6: Haga clic derecho en el proyecto y vaya a Propiedades . 
   

• Paso 7: haga clic en tiempos de ejecución específicos. Seleccione el apache tomcat instalado en su sistema. Haga clic en aplicar -> aplicar y cerrar. 
   

• Paso 8: Los archivos java deben estar en la carpeta src/main/java para compilar el proyecto spring MVC. Vaya a la carpeta src en el proyecto. Haga clic derecho en principal y haga clic en Nuevo -> Carpeta. 
   

• Paso 9: Escriba java como nombre de carpeta. 
   

• Paso 10: cree una clase java dentro de com.geesforgeeks.springmvc en la carpeta src/main/java . La estructura del directorio debe verse de la siguiente manera. 
   

• Pasos para implementar una aplicación Spring web MVC usando una configuración basada en Java:
  • Paso 1: Inicialmente, necesitamos crear un archivo POM.XML . Este archivo contiene las dependencias maven del framework spring para usarlas en el proyecto.
     

<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
                      http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.geeksforgeeks</groupId>
  <artifactId>SpringMVCjava</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>SpringMVCjava Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <dependencies>
   
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
     
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>4.3.12.RELEASE</version>
    </dependency>
     
  </dependencies>
  <build>
    <finalName>SpringMVCjava</finalName>
  </build>
</project>

• Paso 2: El proyecto contiene un archivo web.xml que recibe todas las requests del cliente. Usaremos WebInitializer.java en lugar de web.xml. La función getServletMappings() recibe todas las requests correspondientes al mapeo de URL ‘/’ . La función getServletConfigClasses() configura el servlet despachador y transfiere el manejador al archivo java MVCconfig.class del servlet despachador. El archivo MVCconfig.java se usa en lugar del servlet de despachador para la configuración basada en Java. Esta clase debe extender la clase AbstractAnnotationConfigDispatcherServletInitializer para cumplir el propósito del archivo web.xml en la configuración basada en Java. Este archivo se define como:
   

package com.geeksforgeeks.web;
 
import org.springframework.web
    .servlet.support
    .AbstractAnnotationConfigDispatcherServletInitializer;
 
public class WebInitializer
    extends AbstractAnnotationConfigDispatcherServletInitializer {
 
    @Override
    protected Class<?>[] getRootConfigClasses()
    {
        // TODO Auto-generated method stub
        return null;
    }
 
    @Override
    protected Class<?>[] getServletConfigClasses()
    {
        // TODO Auto-generated method stub
        return new Class[] { MVCconfig.class };
    }
 
    @Override
    protected String[] getServletMappings()
    {
        // TODO Auto-generated method stub
        return new String[] { "/" };
    }
}

• Paso 3: Ahora, necesitamos crear un archivo MVCconfig.java. Este archivo se utiliza en lugar del archivo de servlet del despachador. Anotar una clase con @Configuration indica que el contenedor Spring IoC puede usar la clase como fuente de definiciones de beans. Para habilitar la detección automática de los controladores anotados, es necesario agregar el escaneo de componentes a la configuración. También proporciona la ruta del paquete base (es decir, com.geeksforgeeks.web) en el que se deben buscar los archivos del controlador. Esta clase debe extender la clase WebMvcConfigurerAdapter para cumplir el propósito del servlet de despachador.
   

package com.geeksforgeeks.web;import org.springframework.context.annotation.ComponentScan;import org.springframework.context.annotation.Configuration;import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;@Configuration@ComponentScan({ "com.geeksforgeeks.web" })public class MVCconfigextends WebMvcConfigurerAdapter {}

• Paso 4: Ahora, necesitamos definir un controlador. Los controladores interpretan la entrada del usuario y la transforman en un modelo que la vista representa al usuario. La anotación @RequestMapping se utiliza para asignar direcciones URL como «/saludar» a una clase completa o un método de controlador en particular. Creamos un objeto de la clase ModelAndView . setViewName() indica la vista que se llamará y addObject() indica el contenido dinámico que se agregará a ese objeto.
   

package com.geeksforgeeks.web;
import org.springframework
    .stereotype.Controller;
import org.springframework.web
    .bind.annotation.RequestMapping;
import org.springframework.web
    .servlet.ModelAndView;
 
@Controller
public class GreetController {
 
    @RequestMapping("/greet")
    public ModelAndView showview()
    {
 
        ModelAndView mv = new ModelAndView();
        mv.setViewName("result.jsp");
        mv.addObject("result",
                     "GeeksForGeeks Welcomes "
                         + "you to Spring!");
        return mv;
    }
}

• Paso 5: Ahora, necesitamos crear una página de índice para la aplicación. Es la página que se muestra cuando se accede a la URL dada. Entonces, creamos el archivo index.jsp de la siguiente manera:
   

<html>
<body>
<h2>Hello World!</h2>
    <form action="greet">
        <input type="submit" value="Press to greet">
    </form>
</body>
</html>

• Paso 6: cuando se presiona el botón para saludar del index.jsp definido anteriormente, se abre la página Result.jsp . Entonces, necesitamos definir el archivo Result.jsp: 
   

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1" isELIgnored="false"%>
<!DOCTYPE html>
<html>
    <head>
        <meta charset="ISO-8859-1">
        <title>Insert title here</title>
    </head>
    <body>
     
        <h1>${result}</h1>
         
    </body>
</html>

• Cuando se abre index.jsp:
• Cuando se presiona el botón: