Spring Boot: ejemplo de clase de servicio para mostrar códigos de respuesta y códigos de error personalizados

A veces, los mensajes de error o de estado en las páginas web serían diferentes del mensaje de error predeterminado emitido por Tomcat (o cualquier otro servidor). Una razón importante para esto es que los sitios web quieren verse únicos en su enfoque hacia sus usuarios. Por lo tanto, una página personalizada para mostrar códigos de estado siempre es mejor que la plantilla estándar. Spring Boot facilita en este caso el manejo de varias posibilidades de URL incorrectas ingresadas por el usuario. Para empezar, Spring Boot es lo suficientemente simple para configuraciones básicas con Spring Initializr (https://start.spring.io/). Se deben seguir los siguientes pasos después de ir al sitio de inicio:

1. El sitio ya tendría valores predeterminados para el grupo, el artefacto, el nombre del paquete, etc., que se pueden cambiar según los requisitos.
2. La última versión estable de Spring se habría seleccionado en el iniciador de forma predeterminada, pero puede probar las versiones inestables SNAPSHOT y M3 si lo prefiere.
3. También hay una opción para agregar dependencias. Para nuestro tutorial, estaríamos codificando solo servicios web RESTful, sería suficiente agregar la dependencia de Spring Web y Spring Boot DevTools. Spring Boot DevTools proporciona características de reinicios de aplicaciones más rápidos, LiveReload y otras configuraciones que garantizan que el desarrollador no necesite reiniciar la aplicación cada vez que se cambia el código.

Después de todos los pasos, el proyecto se puede descargar como un archivo zip. Después de extraer el contenido de los archivos zip, se puede importar al IDE haciendo clic en:

1. Importar -> Maven -> Proyectos Maven existentes -> Siguiente
2. Haga clic en examinar, vaya a la ubicación donde se descarga el proyecto, seleccione la carpeta del proyecto y haga clic en seleccionar carpeta.

Ahora es el momento de mencionar las expectativas de salida para este tutorial. El resultado esperado se demuestra con capturas de pantalla. Se espera que la clase de servicio muestre resultados solo para requests GET, otros métodos deben mostrar un código de error 405.

 

Si los valores de los parámetros no coinciden con los valores posibles especificados o no hay ningún parámetro presente, se debe mostrar una página de error de página no encontrada.

 

Una solicitud de GET /format=text debe devolver un mensaje de respuesta simple que muestre la hora actual y el código de estado como correcto utilizando HashMap como formato de datos de respuesta.

 

Una solicitud de GET /format=page debería mostrar la página web. Esto es subjetivo en cada caso y en este caso solo mostraremos una página web de muestra disponible en el dominio público.

 

Los requisitos anteriores se pueden codificar en clases de controlador anotadas con la anotación @RestController como se demuestra en el ejemplo que se proporciona a continuación.

Archivo controlador.java

package com.springboot.springbootdemo;
  
import java.lang.annotation.Repeatable;
import java.net.URI;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.HashMap;
import org.springframework.boot.web.servlet.error.ErrorController;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.HttpRequestMethodNotSupportedException;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.server.MethodNotAllowedException;
  
@RestController
public class Controller implements ErrorController {
  
    @GetMapping("/format=page")
    public ResponseEntity<Object> page()
    {
        return ResponseEntity.status(HttpStatus.FOUND)
            .location(URI.create(
                "https://www.geeksforgeeks.org/resource-injection-in-java-ee/"))
            .build();
    }
  
    @GetMapping("/format=text")
    public HashMap<String, String> text()
    {
        HashMap<String, String> map
            = new HashMap<String, String>();
        SimpleDateFormat formatter = new SimpleDateFormat(
            "yyyy-MM-dd'T'HH:mm:ssZ");
        Date date = new Date(System.currentTimeMillis());
        String formattedString = formatter.format(date);
        map.put("currentTime", formattedString);
        map.put("status", "OK");
        return map;
    }
  
    @PostMapping("/**")
    public HashMap<String, String> all_except_get()
    {
        HashMap<String, String> map
            = new HashMap<String, String>();
        map.put("status", "401");
        return map;
    }
  
    @DeleteMapping("/**")
    public HashMap<String, String> all_delete()
    {
        HashMap<String, String> map = all_except_get();
        return map;
    }
  
    @PutMapping("/**")
    public HashMap<String, String> all_put()
    {
        HashMap<String, String> map = all_except_get();
        return map;
    }
  
    @PatchMapping("/**")
    public HashMap<String, String> all_patch()
    {
        HashMap<String, String> map = all_except_get();
        return map;
    }
  
    @RequestMapping("/error")
    public ResponseEntity<Object> handleError()
    {
        return ResponseEntity.status(HttpStatus.FOUND)
            .location(URI.create(
                "http://localhost:8002/LoginRegistration/404error.html"))
            .build();
    }
  
    public String getErrorPath() { return "/error"; }
}

Una explicación del código dado anteriormente:

• La función ResponseEntity<Object> page() anotada con @GetMapping(“/format=page”) maneja las requests de GET /format=page redirigiendo el control a la página web “https://www.geeksforgeeks.org/resource-injection -in-java-ee/” con el comando ‘return ResponseEntity.status(HttpStatus.FOUND).ubicación(URI.create(“https://www.geeksforgeeks.org/resource-injection-in-java-ee/” )).construir();’
• URI.create() crea un nuevo objeto URI que analiza el enlace de la página web como URI.
• El método location() busca la ubicación de la URI a la que se va a redirigir el control. HttpStatus.FOUND devuelve el código de respuesta que indica si se puede acceder a la URL o no.
• El método build() construye todo este flujo de comandos que luego es procesado por ResponseEntity.status. Luego, la función Java devuelve toda esta respuesta, después de lo cual el control se redirige a la URL dada, según el código de estado de la solicitud.
• El texto de la función ResponseEntity<Object> anotado con @GetMapping(“/format=text”) maneja las requests de GET /format=text declarando y devolviendo el objeto de tipo HashMap<String, String>.
• El objeto devuelve el HashMap con dos pares clave-valor. Un par clave-valor es el código de estado con el mensaje «OK» y otro par clave-valor es la fecha y la hora actuales con formato de string ISO 8601, es decir, en el formato «yyyy-MM-dd’T’HH:mm formato ‘Z’.
• El formato anterior se puede lograr usando el comando del formateador “SimpleDateFormat formatter= new SimpleDateFormat(“yyyy-MM-dd’T’HH:mm:ssZ”);”. La fecha y hora actuales se almacenan en una variable usando el comando «Fecha fecha = nueva fecha (System.currentTimeMillis());» que luego se formatea en una string usando el formateador «String formattedString=formatter.format(date);» que declaramos hace un momento.
• La string formateada luego se agrega al mapa junto con el mensaje de estado. Ahora, el mensaje que se mostrará para la URL correspondiente se devuelve como un mapa.
• Dado que se espera que el servicio maneje solo requests GET y que se muestre un error 405 para otras requests, («/**») se usa después de cada asignación de anotación para recibir todas las requests de un tipo determinado (POST, PUT, DELETE y PATCH) y lanza el mensaje de error 405.

Por ejemplo,

@PostMapping("/**")
public HashMap<String, String> all_except_get()
{
    HashMap<String, String> map
        = new HashMap<String, String>();
    map.put("status", "405");
    return map;
}

es la función para manejar todas las requests POST. De manera similar, la función dada a continuación maneja todas las requests DELETE:

@PutMapping("/**")
public HashMap<String, String> all_put() {
HashMap<String, String> map = all_except_get();
     return map;
}

Como es evidente del código anterior, no es necesario declarar y devolver un mapa con un código de estado cada vez. Dado que ya se ha definido una vez, se invoca la función para obtener el valor del mapa en la variable que luego se devuelve. Se sigue el mismo procedimiento para @DeleteMapping(“/**”) y @PatchMapping(“/**”) también.

archivo application.properties

server.port=8075
server.error.whitelabel.enabled=false

Antes de codificar los métodos personalizados del controlador de errores, es necesario agregar las líneas «server.error.whitelabel.enabled=false» en el archivo application.properties para que se pueda anular la página de error de etiqueta blanca predeterminada. 

Nota : Spring Boot usa el puerto 8080 de forma predeterminada para iniciar Tomcat. Si se requiere usar un puerto diferente, el número de puerto debe mencionarse en el archivo application.properties con server.port=8075.

Ahora volvamos a codificar los métodos del controlador de errores en la clase de servicio. El método getErrorPath() devuelve la ruta de la página de error, que en este caso devuelve el «/error» que se adjunta a la URL. Posteriormente, tiene que haber una función para manejar la URL de error, que se proporciona a continuación:

@RequestMapping("/error")
public ResponseEntity<Object> handleError()
{
    return ResponseEntity.status(HttpStatus.FOUND)
        .location(URI.create(
            "http://localhost:8002/LoginRegistration/404error.html"))
        .build();
}

De manera similar a como se demostró para @GetMapping(“/format=page”), la declaración de devolución transfiere el control a la página de error. Algunas funciones que se pueden codificar mediante la clase de servicio, incluida la función de error personalizado, se muestran y explican en los ejemplos anteriores.