Aprender Spring
Java

Aprender Spring con estos 14 tips

Compártelo

Los mejores 14 tips para aprender spring

Hoy vamos a compartir con ustedes algunas técnicas fundamentales y buenas prácticas para aprender spring. Normalmente en Spring MVC, escribimos una clase de controlador para manejar las solicitudes provenientes del cliente.

A continuación, el controlador invoca una clase de negocios para procesar tareas relacionadas con el negocio y luego redirige al cliente a un nombre de vista lógica que se resuelve mediante el servlet del distribuidor de Java Spring para generar resultados o resultados. Eso completa un viaje redondo de un ciclo típico de solicitud-respuesta.

También te puede interesar:

1. Uso del estereotipo @Controller

Esta es la forma más sencilla de crear una clase de controlador para manejar una o varias solicitudes. Simplemente anotando una clase con el estereotipo @Controller, por ejemplo:

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class HomeController {

@RequestMapping("/")
public String visitHome() {

// do something before returning view name

return "home";
}
}

Como puede ver, el método visitHome () maneja las solicitudes que llegan a la ruta de contexto de la aplicación (/) redirigiendo a la vista llamada home.
NOTA: el estereotipo @Controller solo se puede usar con anotación controlada y está habilitado en el archivo de configuración de Spring:

 

Cuando se activa la anotación, el contenedor Spring automáticamente busca las clases en el paquete especificado en la siguiente declaración:

 

Las clases anotadas por la anotación @Controller se configuran como controladores. Esta es la forma más preferible debido a su simplicidad: no es necesario declarar beans para los controladores en el archivo de configuración.

NOTA: Al usar la anotación @Controller, puede tener una clase de controlador de varias acciones que pueda atender múltiples solicitudes diferentes. Por ejemplo:

@Controller
public class MultiActionController {

@RequestMapping("/listUsers")
public ModelAndView listUsers() {

}

@RequestMapping("/saveUser")
public ModelAndView saveUser(User user) {

}

@RequestMapping("/deleteUser")
public ModelAndView deleteUser(User user) {

}
}

Como puede ver en la clase de controlador anterior, hay 3 métodos de control que procesan 3 solicitudes / listas de usuarios diferentes, / guardan usuario y / eliminan usuario, respectivamente.

2. Implementación de la interfaz del controlador

Otra forma (y quizás clásica) de crear un controlador en Spring MVC es hacer que una clase implemente la interfaz del Controlador. Por ejemplo:

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

public class MainController implements Controller {

@Override
public ModelAndView handleRequest(HttpServletRequest request,
HttpServletResponse response) throws Exception {
System.out.println("Welcome main");
return new ModelAndView("main");
}
}

La clase implementadora debe anular el método handleRequest () que invocará el servlet del distribuidor Spring cuando entre una solicitud de coincidencia. El patrón de URL de solicitud manejado por este controlador se define en el archivo de configuración de contexto de Spring de la siguiente manera:

 

Sin embargo, un inconveniente de este enfoque es que la clase de controlador no puede manejar múltiples URL de solicitud.

3. Extender la clase AbstractController

Tener su clase de controlador extendido la clase AbstractController si desea controlar fácilmente los métodos HTTP admitidos, el almacenamiento en caché de la sesión y el contenido. Considere el siguiente ejemplo:

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractController;

public class BigController extends AbstractController {

@Override
protected ModelAndView handleRequestInternal(HttpServletRequest request,
HttpServletResponse response) throws Exception {
System.out.println("You're big!");
return new ModelAndView("big");
}
}

Esto crea un controlador de acción simple con configuraciones con respecto a los métodos admitidos, la sesión y el almacenamiento en caché pueden especificarse en la declaración de bean del controlador. Por ejemplo:

 

Esta configuración indica que el único método POST es compatible con el método hander de este controlador. Para otra configuración (sesión, almacenamiento en caché) ver: AbstractController.
Spring MVC también ofrece varias clases de controladores que están diseñadas para fines específicos: AbstractUrlViewController, MultiActionController, ParameterizableViewController, ServletForwardingController, ServletWrappingController, UrlFilenameViewController.

4. Especificación de la asignación de URL para el método del controlador

Esta es la tarea obligatoria que debe hacer al codificar una clase de controlador que está diseñada para manejar una o más solicitudes específicas. Spring MVC proporciona la anotación @RequestMapping que se utiliza para especificar la asignación de URL. Por ejemplo:

@RequestMapping("/login")

Eso mapea el patrón / inicio de sesión de URL que será manejado por el método o clase anotado. Cuando esta anotación se usa a nivel de clase, la clase se convierte en un controlador de acción simple. Por ejemplo:

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
@RequestMapping("/hello")
public class SingleActionController {

@RequestMapping(method = RequestMethod.GET)
public String sayHello() {
return "hello";
}
}

Cuando la anotación @RequestMapping se usa a nivel de método, puede tener un controlador de acción múltiple. Por ejemplo:

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class UserController {

@RequestMapping("/listUsers")
public String listUsers() {
return "ListUsers";
}

@RequestMapping("/saveUser")
public String saveUser() {
return "EditUser";
}

@RequestMapping("/deleteUser")
public String deleteUser() {
return "DeleteUser";
}
}

La anotación @RequestMapping también se puede usar para especificar múltiples patrones de URL que se manejarán con un único método. Por ejemplo:

@RequestMapping({"/hello", "/hi", "/greetings"})

Además, esta anotación tiene otras propiedades que pueden ser útiles en algunos casos, p. la propiedad del método que se cubre a continuación.

5. Especificación de métodos de solicitud HTTP para el método Handler

Puede especificar qué método HTTP (GET, POST, PUT, …) es compatible con un método de controlador utilizando la propiedad de método de la anotación @RequestMapping. Aquí hay un ejemplo:

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
public class LoginController {

@RequestMapping(value = "/login", method = RequestMethod.GET)
public String viewLogin() {
return "LoginForm";
}

@RequestMapping(value = "/login", method = RequestMethod.POST)
public String doLogin() {
return "Home";
}
}

Como puede ver, este controlador tiene dos métodos que manejan el mismo patrón / inicio de sesión de URL, pero el primero es para el método GET y el último para el método POST.
Para obtener más información sobre el uso de la anotación @RequestMapping, consulte la anotación @RequestMapping.

6. Mapeo de los parámetros de solicitud al método del manejador

Una de las características interesantes de Spring MVC es que puede recuperar los parámetros de solicitud como parámetros regulares del método del manejador utilizando la anotación @RequestParam. Esta es una buena manera de desacoplar el controlador de la interfaz HttpServletRequest de Servlet API.
Veamos varios ejemplos. Considera el siguiente método:

@RequestMapping(value = "/login", method = RequestMethod.POST)
public String doLogin(@RequestParam String username,
@RequestParam String password) {

}

Spring vincula los parámetros del método nombre de usuario y contraseña a los parámetros de solicitud HTTP con los mismos nombres. Eso significa que puede invocar una URL de la siguiente manera (si el método de solicitud es GET):
http: // localhost: 8080 / spring / login? username = scott & contraseña = tigre

La conversión de tipo también se realiza automáticamente. Por ejemplo, si declara un parámetro de tipo entero de la siguiente manera:

@RequestParam int securityNumber

Entonces Java Spring convertirá automáticamente el valor del parámetro de solicitud (String) al tipo especificado (integer) en el método del controlador.
En caso de que el nombre del parámetro sea diferente al nombre de la variable. Puede especificar el nombre real del parámetro de la siguiente manera:

@RequestParam("SSN") int securityNumber

La anotación @RequestParam también tiene 2 atributos adicionales que pueden ser útiles en algunos casos. El atributo requerido especifica si el parámetro es obligatorio o no. Por ejemplo:

@RequestParam(required = false) String country

Eso significa que el parámetro country es opcional, por lo tanto puede faltar en la solicitud. En el ejemplo anterior, la variable país será nula si no hay tal parámetro presente en la solicitud.

Otro atributo es defaultValue, que se puede utilizar como valor de reserva cuando el parámetro de solicitud está vacío. Por ejemplo:

@RequestParam(defaultValue = "18") int age

Spring también nos permite acceder a todos los parámetros como un objeto Map si el parámetro del método es de tipo Map <String, String>. Por ejemplo:

doLogin(@RequestParam Map&lt;String, String&gt; params)

Luego, los parámetros del mapa contienen todos los parámetros de solicitud en forma de pares clave-valor.

Para obtener más información sobre el uso de la anotación @RequestParam, consulte la anotación @RequestParam.

7. Regresar el modelo y la vista

Una vez procesada la lógica de negocio, un método controlador debe devolver una vista que luego será resuelta por el servlet despachador de Spring. Spring nos permite devolver un objeto String o ModelAndView del método hander. En el siguiente ejemplo, el método del manejador devuelve un String que representa una vista llamada “LoginForm”:

@RequestMapping(value = "/login", method = RequestMethod.GET)
public String viewLogin() {
return "LoginForm";
}

Esa es la forma más simple de devolver un nombre de vista. Pero si desea enviar datos adicionales a la vista, debe devolver un objeto ModelAndView. Considere el siguiente método de manejo:

@RequestMapping("/listUsers")
public ModelAndView listUsers() {

List listUser = new ArrayList&lt;&gt;();
// get user list from DAO...

ModelAndView modelView = new ModelAndView("UserList");
modelView.addObject("listUser", listUser);

return modelView;
}

Como puede ver, este método de manejo devuelve un objeto ModelAndView que contiene el nombre de vista “UserList” y una colección de objetos User que se pueden usar en la vista.
Spring también es muy flexible, ya que puede declarar el objeto ModelAndView como un parámetro del método del controlador en lugar de crear uno nuevo. Por lo tanto, el ejemplo anterior se puede reescribir de la siguiente manera:

@RequestMapping("/listUsers")
public ModelAndView listUsers(ModelAndView modelView) {

List listUser = new ArrayList&lt;&gt;();
// get user list from DAO...

modelView.setViewName("UserList");
modelView.addObject("listUser", listUser);

return modelView;
}

8. Poner objetos en el modelo

En una aplicación que sigue la arquitectura MVC, el controlador (C) debe pasar datos al modelo (M) que luego se utiliza en la vista (V). Como vemos en el ejemplo anterior, el método addObject () de la clase ModelAndView es para poner un objeto al modelo, en forma de par nombre-valor:

 

modelView.addObject("listUser", listUser);
modelView.addObject("siteName", new String("CodeJava.net"));
modelView.addObject("users", 1200000);

Nuevamente, Spring es muy flexible. Puede declarar un parámetro de tipo Mapa en el método del controlador, Spring usa este mapa para almacenar objetos para el modelo. Veamos otro ejemplo:

@RequestMapping(method = RequestMethod.GET)
public String viewStats(Map&lt;String, Object&gt; model) {
model.put("siteName", "CodeJava.net");
model.put("pageviews", 320000);

return "Stats";
}

Esto es incluso más simple que usar el objeto ModelAndView. Dependiendo de su gusto, puede usar el objeto Map o ModelAndView. Gracias por la flexibilidad de Spring.

9. Redirigir en el método Handler

En caso de que desee redirigir al usuario a otra URL si se cumple una condición, solo agregue la redirección: / antes de la URL. El siguiente fragmento de código da un ejemplo:

// check login status....

if (!isLogin) {
return new ModelAndView("redirect:/login");
}

// return a list of Users

En el código anterior, el usuario será redireccionado a la / login URL si no está conectado.

10. Manejo de presentación de formularios y validación de formularios

Spring facilita el manejo del envío de formularios, proporcionando la anotación @ModelAttribute para vincular los campos de formulario a un objeto de respaldo de formulario y la interfaz BindingResult para validar los campos de formulario. El siguiente fragmento de código muestra un método de controlador típico que se encarga de manejar y validar los datos del formulario:

@Controller
public class RegistrationController {

@RequestMapping(value = "/doRegister", method = RequestMethod.POST)
public String doRegister(
@ModelAttribute("userForm") User user, BindingResult bindingResult) {

if (bindingResult.hasErrors()) {
// form validation error

} else {
// form input is OK
}

// process registration...

return "Success";
}
}

Obtenga más información sobre la anotación @ModelAttribute y la interfaz BindingResult de la documentación oficial de Spring:

Usando @ModelAttribute en un argumento de método
Usando @ModelAttribute en un método
Interface BindingResult

11. Manejo de carga de archivos

Spring también facilita la gestión de la carga de archivos dentro de un método de manejo, vinculando automáticamente los datos de carga a una matriz de objetos CommonsMultipartFile. java Spring utiliza Apache Commons FileUpload como el solucionador multiparte subyacente.

El siguiente fragmento de código muestra lo fácil que es cargar archivos del cliente:

 

@RequestMapping(value = "/uploadFiles", method = RequestMethod.POST)
public String handleFileUpload(
@RequestParam CommonsMultipartFile[] fileUpload) throws Exception {

for (CommonsMultipartFile aFile : fileUpload){

// stores the uploaded file
aFile.transferTo(new File(aFile.getOriginalFilename()));

}

return "Success";
}

12. Autocadenamiento de clases de negocios en el controlador

Un controlador debe delegar el procesamiento de la lógica comercial a las clases de negocios relevantes. Para este propósito, puede usar la anotación @Autowired para permitir que Java Spring inyecte automáticamente la implementación real de una clase empresarial al controlador. Considere el siguiente fragmento de código de una clase de controlador:

@Controller
public class UserController {

@Autowired
private UserDAO userDAO;

public String listUser() {
// handler method to list all users
userDAO.list();
}

public String saveUser(User user) {
// handler method to save/update a user
userDAO.save(user);
}

public String deleteUser(User user) {
// handler method to delete a user
userDAO.delete(user);
}

public String getUser(int userId) {
// handler method to get a user
userDAO.get(userId);
}
}

Aquí, todas las lógicas de negocios relacionadas con la administración de usuarios son proporcionadas por una implementación de la interfaz UserDAO. Por ejemplo:

interface UserDAO {

List list();

void save(User user);

void checkLogin(User user);
}

Al usar la anotación @Autowired, los métodos del manejador pueden delegar tareas a la clase de negocios, como podemos ver en el ejemplo anterior:

List listUser = userDAO.list();

13. Accediendo a HttpServletRequest y HttpServletResponse

En algunos casos, debe acceder directamente a los objetos HttpServletRequest o HttpServletResponse dentro de un método de control. Por la flexibilidad de Spring, simplemente agregue el parámetro relevante al método del controlador. Por ejemplo:

@RequestMapping("/download")
public String doDownloadFile(
HttpServletRequest request, HttpServletResponse response) {

// access the request

// access the response

return "DownloadPage";
}

Spring detecta e inyecta automáticamente los objetos HttpServletRequest y HttpServletResponse en el método. Luego puede acceder a la solicitud y a la respuesta, como obtener InputStream, OutputStream o devolver un código HTTP específico.

14. Siguiendo el Principio de Responsabilidad Individual

Finalmente, hay dos buenas prácticas que debe seguir al diseñar y codificar controladores en Java Spring MVC:

Una clase de controlador no debe ejecutar lógica de negocios. En su lugar, debe delegar el procesamiento de negocios a las clases de negocios relevantes. Esto mantiene al controlador enfocado en su responsabilidad diseñada para controlar los flujos de trabajo de la aplicación. Por ejemplo:

@Controller
public class UserController {

@Autowired
private UserDAO userDAO;

public String listUser() {
// handler method to list all users
userDAO.list();
}

public String saveUser(User user) {
// handler method to save/update a user
userDAO.save(user);
}

public String deleteUser(User user) {
// handler method to delete a user
userDAO.delete(user);
}

public String getUser(int userId) {
// handler method to get a user
userDAO.get(userId);
}
}

Cree cada controlador por separado para cada dominio comercial. Por ejemplo, UserController para controlar flujos de trabajo de la administración de usuarios, OrderController para controlar flujos de trabajo de procesamiento de pedidos, etc. Por ejemplo:

@Controller
public class UserController {

}

@Controller
public class ProductController {

}

@Controller
public class OrderController {

}

@Controller
public class PaymentController {

}

Espero que te haya gustado estos 14 tips para aprender spring y así reforzar tus conocimientos relacionados al lenguaje de programación Java, déjanos tu comentario y nos vemos en un próximo articulo. Gracias….

Compártelo

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *