Spring MVC Controladores
Un controlador usualmente es el encargado de preparar el modelo (los datos manejados por la aplicación) y seleccionar el nombre de la vista que será utilizada para mostrar el modelo al cliente, el modelo es una implementación de la interface Map en la cual podemos almacenar datos en formato clave/valor estos datos serán enviados a la vista para su correcta representación, puede ser: HTML, PDF, etc., debemos decir que un controlador es capaz de generar una respuesta sin necesidad de una vista, esto es útil a la hora de crear servicios que generan respuestas en formatos como: XML, JSON, etc.
Típicamente definimos los controladores usando las anotaciones @Controller y @RequestMapping, además de la clase ModelAndView usada para devolver el modelo y el nombre de la vista, en Spring MVC la creación de controladores es muy flexible, podemos crearlos usando distintos métodos, con o sin anotaciones, a lo largo de este tutorial trataremos de ver algunas de ellas.
Usamos la anotación @Controller para establecer las clases que serán usadas como controladores, recordemos que debemos indicarle a Spring donde encontrar estas clases, para ello usaremos: si la configuración es con anotaciones @ComponentScan(basePackages = {"..."}), si es desde XML <context:component-scan base-package="..." />, donde base-package indica el paquete donde se encuentran las clases controladores.
package carmelo.spring.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
@Controller
public class HelloController {
@RequestMapping(value = "/hola")
public ModelAndView hola() {
ModelAndView mv = new ModelAndView();
mv.addObject("titulo", "Tutoriales Spring MVC :: HelloController");
mv.addObject("mensaje", "saludo desde el metodo: <br /> "
+ "<code>public ModelAndView hola() {...}</code>");
mv.setViewName("hello");
return mv;
}
@RequestMapping(value = "/hello")
public String hello(Model model) {
model.addAttribute("titulo", "Tutoriales Spring MVC :: HelloController");
model.addAttribute("mensaje", "saludo desde el metodo: <br /> "
+ "<code>public String hello(Model) {...}</code>");
return "hello";
}
}
La anotación @RequestMapping(value="/hola", method=RequestMethod.GET) nos permite indicar la petición a la responderá un determinado método, debemos indicar la URL y la operación HTTP (GET, POST, PUT, etc.), si no lo indicamos se aceptan todas las operaciones HTTP.
hola()responde a la URL http://localhost:8084/tutorial_webmvc_controller/hola.hello(Model)responde a http://localhost:8084/tutorial_webmvc_controller/hello.
Ambos métodos utilizan la vista hello.jsp, lo debemos notar son las diversas formas como podemos agregar métodos a los controladores, el primero retorna un objeto ModelAndView el cual contiene los datos del modelo y el nombre de la vista, el segundo rellena el modelo a través de la interface Model y retorna el nombre de la vista.
La vista JSP que genera esta salida es la siguiente: hello.jsp.
<!DOCTYPE html>
<html>
<head>
<title>Spring Web MVC</title>
</head>
<body>
<h1>${titulo}</h1>
<p>${mensaje}</p>
</body>
</html>
La anotación @RequestMapping puede aplicarse a nivel de clase, cuando hacemos esto el parámetro value de la clase se combinará con el aplicado a nivel de método para determinar así cual es la URL a la que debe responder, ejemplo:
@Controller
@RequestMapping(value = "/hello")
public class HelloController {
@RequestMapping(value = "/fecha")
@ResponseBody
public String fecha() {
return "Hoy es: " + LocalDate.now()
.format(DateTimeFormatter.ISO_DATE);
}
}
fecha() responde a http://localhost:8084/tutorial_webmvc_controller/hello/fecha.
Habíamos mencionado podía generar una respuesta sin necesidad de usar una vista, para ello debemos usar la anotación @ResponseBody el método debe retornar la respuesta, en este caso un texto que contiene la fecha actual.
Parámetros de entrada con @RequestParam
Hasta este momento en los 3 tutoriales Spring MVC que llevamos solo hemos creado controladores que no interactúan con el cliente, en este punto veremos la anotación @RequestParam que nos permite recibir parámetros de entrada, ejemplo: tenemos un controlador VentasController el cual nos permitirá ver todas las ventas de un determinado vendedor, para indicar cual es el vendedor usaremos parámetros en la URL, de la siguiente forma:
Para pasar un parámetro mediante la URL usamos el símbolo "?" el final de la misma, luego indicamos el nombre de la variable seguido del símbolo "=" inmediatamente establecemos su valor, la forma es: parámetro=valor, para capturar el valor en el controlador usamos @RequestParam("parametro") indicando el nombre del parámetro que deseamos capturar.
Es posible establecer el parámetro como opcional, para ello establecemos required=false, y con defaultValue=”…” establecemos el valor que tendrá el parámetro en caso de que no este presente en la URL, ejemplo: @RequestParam(value="name", required=false, defaultValue="World")
Si deseamos indicar varios parámetros debemos separarlos con el símbolo &, por ejemplo: para enviar el nombre y un valor entero que representa el mes:
El controlador se define de la siguiente manera:
@Controller
public class VentasController {
@RequestMapping("/ventas")
public String porVendedor(
@RequestParam("nombre") String nombre,
@RequestParam("mes") Integer mes,
Model model) {
model.addAttribute("vendedor", nombre);
model.addAttribute("ventas", "Listado de ventas para el mes: " + mes);
return "ventas";
}
}
Otra forma de comunicarnos con el controlador es utilizar @PathVariable("variable") para obtener una variable que este insertada en la URL, primero @RequestMapping("/vendedor/{id}") donde {...} define una variable, la URL http://localhost:8084/webapp/vendedor/4855 el entero 4855 representa la variable.
@Controller
public class VentasController {
@ResponseBody
@RequestMapping("/vendedor/{id}")
public String vendedor(@PathVariable("id") Long id) {
return "Buscar vendor con ID = " + id;
}
}
Podemos tener una o más variables en la URL, en el siguiente ejemplo usaremos dos variables una para indicar el departamento de ventas y la segunda para identificar al vendedor de dicho departamento, el controlador se define de la siguiente manera:
@ResponseBody
@RequestMapping("/depto/{dep}/vendedor/{id}")
public String departamentoVendedor(
@PathVariable("id") Long id,
@PathVariable("dep") String dep) {
String res = "Este es el departamento de: %s, y el vendedor ID: %d";
return String.format(res, dep, id);
}
En la última sección de este tutorial vimos como el usuario de nuestra aplicaciones web puede comunicarse con el controlador, claro, en una aplicación real el usuario no va ha editar la URL manualmente como lo hicimos aquí, lo correcto sería que mediante un UI el usuario introduce o selecciona la datos y mediante un botón, por ejemplo, enviara la solicitud al controlador, en el siguiente tutorial veremos las vistas, haremos esto que acabamos de mencionar.
- Ver código en: Tutorial Controladores Spring MVC.
- Ver más tutoriales: Serie Spring Web MVC.
Comentarios
Publicar un comentario