ViewResolver en Spring MVC

Spring MVC es un marco Web MVC para crear aplicaciones web. En general, todos los marcos MVC proporcionan una forma de trabajar con vistas. Spring hace eso a través de ViewResolvers , lo que le permite representar modelos en el navegador sin vincular la implementación a una tecnología de vista específica. Ahora comprendamos ViewResolver con un proyecto de ejemplo en STS. 

El marco Spring MVC se compone de los siguientes componentes:

1. Modelo : Un modelo puede ser un objeto o una colección de objetos que básicamente contiene los datos de la aplicación.
2. Vista : una vista se utiliza para mostrar la información al usuario en un formato específico. Spring admite varias tecnologías como marcador libre, velocidad y hoja de tomillo.
3. Controlador : Contiene la parte lógica de la aplicación. La anotación @Controller se usa para marcar esa clase como controlador.
4. 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: Previo a la misma se necesitan ciertos requisitos que son los siguientes:  

1. Eclipse (versión EE)/STS IDE
2. Archivos JAR de primavera
3. Tomcat Apache última versión

Implementación: Proyecto

A continuación se ilustra paso a paso de la siguiente manera:

Nota : Vamos a utilizar Spring Tool Suite 4 IDE para este proyecto. Consulte este artículo para instalar STS en su máquina local ¿Cómo descargar e instalar Spring Tool Suite (Spring Tools 4 para Eclipse) IDE? 

Paso 1: cree un proyecto web dinámico en su STS IDE para el cual uno debería estar bien versado en cómo crear un proyecto web dinámico en Spring Tool Suite.

Paso 2: descargue el archivo Spring JAR y vaya a la carpeta src> main> webapp> WEB-INF> lib y pase estos archivos JAR. 

Paso 3: Configure el servidor Apache Tomcat y configure el servidor Tomcat con la aplicación. 

Configuración del ‘servlet de despachador’

Vaya a Dispatcher Servlet en Spring y lea más sobre Dispatcher Servlet, que es un concepto muy importante de entender. Ahora vamos a configurar Dispatcher Servlet con nuestra aplicación Spring MVC. 

Paso 4: Vaya al archivo src > main > webapp > WEB-INF > web.xml .

Archivo: web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.geeksforgeeks.org/2001/XMLSchema-instance"
               xmlns="http://xmlns.jcp.org/xml/ns/javaee"
               xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                             http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
       id="WebApp_ID" version="4.0">
       <display-name>springmvc-view-resolver</display-name>
       <welcome-file-list>
              <welcome-file>index.html</welcome-file>
              <welcome-file>index.jsp</welcome-file>
              <welcome-file>index.htm</welcome-file>
              <welcome-file>default.html</welcome-file>
              <welcome-file>default.jsp</welcome-file>
              <welcome-file>default.htm</welcome-file>
       </welcome-file-list>
 
       <absolute-ordering />
 
       <servlet>
              <!-- Provide a Servlet Name -->
              <servlet-name>viewresolver-dispatcher</servlet-name>
              <!-- Provide a fully qualified path to the DispatcherServlet class -->
              <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
              <load-on-startup>1</load-on-startup>
       </servlet>
 
       <servlet-mapping>
              <!-- Provide a Servlet Name that you want to map -->
              <servlet-name>viewresolver-dispatcher</servlet-name>
              <!-- Provide a url pattern -->
              <url-pattern>/demo.com/*</url-pattern>
       </servlet-mapping>
 
</web-app>

Paso 5: Ahora ve a   src > main > webapp > WEB-INF  y crea un archivo XML. En realidad, este es un archivo de configuración de Spring como el archivo beans.xml. Y el nombre del archivo debe estar en este formato.

YourServletName-servlet.xml  

Por ejemplo, para este proyecto, el nombre del archivo debe ser

viewresolver-dispatcher-servlet.xml 

Entonces, puede crear un archivo de configuración de Spring o simplemente puede crear un archivo XML simple y agregar las siguientes líneas de código dentro de ese archivo.

Archivo: viewresolver-despachador-servlet.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.geeksforgeeks.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">
   
  <!-- This Line is used for scanning all the packages that have controller classes -->
  <context:component-scan base-package="com.demo.controllers"></context:component-scan>
 
</beans>

Creando ‘Controlador Spring MVC’

Paso 6: Ahora, creemos algunos controladores. Vaya a src/main/java y cree un nuevo paquete de controladores (por ejemplo, com.demo.controllers) según su elección. Y dentro de eso, cree una clase Java y nombre la clase como DemoController . Ahora, cómo decirle a Spring que esta es nuestra clase de controlador. Entonces, la forma en que vamos a decirle a Spring es marcándolo con una anotación @Controller .

@Controller
public class DemoController {}

Nota: Spring inicializará automáticamente la clase que tenga una anotación @Controller y registrará esa clase con el contenedor Spring.

Ahora, creemos un método simple dentro de la clase Controller y usemos la anotación @RequestMapping antes del método, algo así.

// Annotation 
@RequestMapping("/hello")

// Method 
public String helloWorld() 
{
    return "";
}

Ahora, en la declaración de devolución, tenemos que devolver algunas vistas (páginas web), de modo que cada vez que se invoque el punto final ‘/hello’, podemos ver nuestro resultado en la página web. Así que vamos a crear nuestra primera Vista.

Creando ‘Vista’

Vaya a src> main> webapp> WEB-INF> haga clic con el botón derecho en> New> Folder y nombre la carpeta como vistas. Luego vistas> clic derecho> Nuevo> Archivo JSP y nombre su primera vista. Aquí lo hemos llamado archivo demo.jsp . A continuación se muestra el código para el archivo demo.jsp . Hemos creado una página web simple dentro de ese archivo. 

Archivo: demo.jsp

<!DOCTYPE html>
<html>
<body bgcolor="green">
    <h1>Hello GeeksforGeeks!</h1>
</body>
</html>

Ahora ve a la clase DemoController y dentro del método helloWorld() tenemos que devolver un valor como este.

return "/WEB-INF/views/demo.jsp";

Se nos acaba de dar el camino para nuestra vista.

Archivo: DemoController.java 

// Java Program to Illustrate DemoController Class
 
package com.demo.controllers;
 
// Importing required classes
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
 
// Class
@Controller
public class DemoController {
 
    // Method
    @RequestMapping("/hello") public String helloWorld()
    {
        return "/WEB-INF/views/demo.jsp";
    }
}

Ejecutando ‘Aplicación Spring MVC’

Paso 7: para ejecutar nuestra aplicación Spring MVC , haga clic con el botón derecho en su proyecto > Ejecutar como > Ejecutar en el servidor. Andrun su aplicación como se muestra en la imagen de abajo como se muestra a continuación de la siguiente manera:  

Después de eso, use la siguiente URL para ejecutar su controlador

http://localhost:8080/springmvc-view-resolver/demo.com/hello

Producción:

 

Entonces, ¿cuál es el problema con el proyecto anterior? Simplemente vaya al archivo DemoController.java nuevamente y el problema radica en esta línea de código:

return "/WEB-INF/views/demo.jsp";

Entonces, el escenario es, supongamos que alguien nos dice que creemos o muevamos este archivo demo.jsp dentro de otro directorio y aquí tenemos que cambiar la ruta nuevamente, lo cual no es una práctica de codificación estándar. El problema aquí es que hemos proporcionado una ruta completamente calificada en nuestro método de manejo del controlador que hace que nuestra aplicación esté estrechamente acoplada y la solución para este problema es ViewResolver . Para cambiar la ruta muchas veces, debe ir a su archivo de configuración de Spring (aquí está: viewresolver-dispatcher-servlet.xml) y allí puede modificar estas cosas. Ahora comprendamos cómo ViewResolver resuelve este problema.  

Aquí está esta línea, /WEB-INF/views/demo.jsp , a veces existe un escenario, cuando alguien quiere cambiar WEB-INF/views (la ruta) o .jsp (la extensión como .html), el nombre debe ser el mismo. 

 

Y los llamamos prefijos y sufijos en consecuencia. Ahora entendamos esto en el siguiente código, pero antes de eso, aprendamos un poco sobre ViewResolver. En el marco de Spring, hay muchos ViewResolver disponibles. Pero en este proyecto, vamos a usar InternalResourceViewResolver. Ahora pasemos a la parte de codificación. 

Paso 8: Vaya al archivo DemoController.java y modifique el código como se muestra en el siguiente fragmento. 

Archivo: DemoController.java modificado 

// Java Program to Illustrate DemoController Class
 
package com.demo.controllers;
 
// Importing required classes
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
 
// Class
@Controller
public class DemoController {
 
    // Method
    @RequestMapping("/hello") public String helloWorld()
    {
 
        // Just return the page name
        // No Path, no extension
        return "demo";
    }
}

Aquí solo hemos devuelto el nombre de la página, nada más. 

Nota : el nombre del archivo de retorno y el nombre de la vista deben ser iguales porque estamos devolviendo esa página web desde el método del controlador del controlador. 

Configure ViewResolver dentro del archivo de configuración de Spring (es decir, viewresolver-dispatcher-servlet.xml)

Paso 9: Modifique viewresolver-dispatcher-servlet.xml y agregue las siguientes líneas de código de la siguiente manera: 

<bean id = 'viewResolver' class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/views/"/>
    <property name="suffix" value=".jsp"/>
</bean>

Esto es lo que hemos discutido anteriormente y es completamente el concepto de Inyección de Dependencia Basada en Setter en el marco de primavera.

Archivo: viewresolver-despachador-servlet.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.geeksforgeeks.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">
   
  <!-- This Line is used for scanning all the packages that have controller classes -->
  <context:component-scan base-package="com.demo.controllers"></context:component-scan>
   
  <!-- Configure ViewResolver -->
  <bean id = 'viewResolver' class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/views/"/>
    <property name="suffix" value=".jsp"/>
  </bean>
 
</beans>

Ahora, dentro de esta propiedad de «valor», puede cambiar de acuerdo con los requisitos tantas veces como desee. Ahora ejecute su aplicación Spring y el resultado será el siguiente.

Producción: