"Comprensión profunda de los mecanismos de manejo de excepciones y devolución de datos JSON de SpringMVC"

introducción

En el desarrollo web moderno, SpringMVC es un marco ampliamente utilizado que proporciona una rica funcionalidad y opciones de configuración flexibles. Este artículo profundizará en dos temas importantes: devolución de datos JSON y mecanismo de manejo de excepciones en SpringMVC. Introduciremos gradualmente los métodos de uso y configuración relevantes y profundizaremos la comprensión a través de casos y ejemplos completos.

1. Devolución de datos JSON en SpringMVC

1.1 Dependencias de importación

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.3</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.9.3</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-annotations</artifactId>
    <version>2.9.3</version>
</dependency> 

1.2 Configurar spring-MVC.xml

Para que SpringMVC maneje correctamente la devolución de datos JSON, debemos configurarlo en consecuencia en el archivo de configuración. Para manejar correctamente las solicitudes devueltas por datos JSON.

<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
    <property name="messageConverters">
        <list>
        	<ref bean="mappingJackson2HttpMessageConverter"/>
        </list>
    </property>
</bean>
<bean id="mappingJackson2HttpMessageConverter"
class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
    <!--处理中文乱码以及避免IE执行AJAX时，返回JSON出现下载文件-->
    <property name="supportedMediaTypes">
        <list>
            <value>text/html;charset=UTF-8</value>
            <value>text/json;charset=UTF-8</value>
            <value>application/json;charset=UTF-8</value>
        </list>
    </property>
</bean>

1.3 Uso de la anotación @ResponseBody

@ResponseBodyLa función de la anotación es convertir el objeto devuelto por el método del Controlador al formato especificado a través de un convertidor apropiado y luego escribirlo en el área del cuerpo del objeto de respuesta, generalmente se usa para devolver datos o datos XML JSON.

Nota: Después de usar esta anotación, no se utilizará el analizador de vista , pero los datos se escribirán directamente en el flujo de entrada, su efecto es equivalente a generar datos en el formato especificado a través del objeto de respuesta.

 <select id="selBySnamePager" resultType="com.yuan.model.Student" parameterType="com.yuan.model.Student" >
    select
    <include refid="Base_Column_List" />
    from t_mysql_student
    <where>
      <if test="sname!=null">
        and sname like concat('%',#{sname},'%')
      </if>
    </where>

  </select>

  <select id="mapListPager" resultType="java.util.Map" parameterType="com.yuan.model.Student" >
    select
    <include refid="Base_Column_List" />
    from t_mysql_student
    <where>
      <if test="sname != null">
        and sname like concat('%',#{sname},'%')
      </if>
    </where>
  </select>

    /**
     * 返回List<T>
     * @param req
     * @param student
     * @return
     */
    @ResponseBody
    @RequestMapping("/list")
    public List<Student> list(HttpServletRequest req, Student student){
    
    
        PageBean pageBean = new PageBean();
        pageBean.setRequest(req);
        List<Student> lst = this.studentBiz.selBySnamePager(student, pageBean);
        return lst;
    }

  /**
     * 返回T
     * @param req
     * @param Student
     * @return
     */
    @ResponseBody
    @RequestMapping("/load")
    public Student load(HttpServletRequest req, Student Student){
    
    
        if(Student.getSname() != null){
    
    
            List<Student> lst = this.studentBiz.selBySnamePager(Student, null);
            return lst.get(0);
        }
        return null;
    }

  /**
     * 返回List<Map>
     * @param req
     * @param Student
     * @return
     */
    @ResponseBody
    @RequestMapping("/mapList")
    public List<Map> mapList(HttpServletRequest req, Student Student){
    
    
        PageBean pageBean = new PageBean();
        pageBean.setRequest(req);
        List<Map> lst = this.studentBiz.mapListPager(Student, pageBean);
        return lst;
    }

 /**
     * 返回Map
     * @param req
     * @param Student
     * @return
     */
    @ResponseBody
    @RequestMapping("/mapLoad")
    public Map mapLoad(HttpServletRequest req, Student Student){
    
    
        if(Student.getSname() != null){
    
    
            List<Map> lst = this.studentBiz.mapListPager(Student, null);
            return lst.get(0);
        }
        return null;
    }

 @ResponseBody
    @RequestMapping("/all")
    public Map all(HttpServletRequest req, Student Student){
    
    
        PageBean pageBean = new PageBean();
        pageBean.setRequest(req);
        List<Student> lst = this.studentBiz.selBySnamePager(Student, pageBean);
        Map map = new HashMap();
        map.put("lst",lst);
        map.put("pageBean",pageBean);
        return map;
    }

@ResponseBody
    @RequestMapping("/jsonStr")
    public String jsonStr(HttpServletRequest req, Student Student){
    
    
        return "clzEdit";
    }

• @JsonIgnore oculta un atributo en datos json

@ToString
public class Student {
    
    
    @JsonIgnore
    @NotBlank(message = "编号不能为空")
    private String sid;
    @NotBlank(message = "名字不能为空")
    private String sname;
    @NotBlank(message = "年龄不能为空")
    private String sage;
    @NotBlank(message = "性别不能为空")
    private String ssex;

1.4.Jackson

• 1.4.1 Introducción

Jackson es una biblioteca de aplicaciones simple basada en Java. Jackson puede convertir fácilmente objetos Java en objetos json y documentos xml. También puede convertir json y xml en objetos Java. Jackson depende de menos paquetes jar, es fácil de usar y tiene un rendimiento relativamente alto. La comunidad de Jackson es relativamente activa y la velocidad de actualización es relativamente rápida.

Características

• Fácil de usar, proporciona una apariencia de alto nivel que simplifica los casos de uso comunes.
• No es necesario crear una asignación; la API proporciona asignaciones predeterminadas para la mayoría de las serializaciones de objetos.
• Alto rendimiento, rápido y bajo uso de memoria
• Crear json limpio
• No depende de otras bibliotecas
• Código fuente abierto

1.4.2 Anotaciones de uso común

anotación	ilustrar
@JsonIgnorar	Actúa sobre campos o métodos para ignorar por completo los atributos correspondientes a los campos y métodos anotados.
@JsonProperty	Actúa sobre campos o métodos y se utiliza para serializar/deserializar atributos. Puede usarse para evitar atributos faltantes y proporcionar cambios de nombre de nombres de atributos.
@JsonIgnoreProperties	Actúa sobre las clases para indicar que algunos atributos deben ignorarse durante la serialización/deserialización.
@JsonSin envolver	Actúa sobre campos o métodos de propiedad y se utiliza para agregar propiedades de objetos JSON secundarios al objeto JSON adjunto.
@JsonFormato	Especifica el formato al serializar valores de fecha/hora.

2. Mecanismo de manejo de excepciones

2.1 Por qué es necesario el manejo global de excepciones

El manejo de excepciones es una tarea de desarrollo importante que puede ayudarnos a manejar mejor los errores y excepciones en nuestros programas. Esta sección presentará por qué necesitamos un mecanismo global de manejo de excepciones y discutirá su importancia y ventajas.

2.2 Ideas de manejo de excepciones

Las excepciones en el dao, el servicio y el controlador del sistema se lanzan hacia arriba mediante throws Exception y, finalmente, el controlador front-end springmvc se lo entrega al controlador de excepciones para que lo maneje. Springmvc proporciona un controlador de excepciones global (un sistema tiene solo un controlador de excepciones) para el manejo unificado de excepciones.

2.3 Clasificación de excepciones SpringMVC

• Utilice el controlador de excepciones simple SimpleMappingExceptionResolver proporcionado por Spring MVC;
• Implemente la interfaz de manejo de excepciones de Spring HandlerExceptionResolver para personalizar su propio controlador de excepciones;
• Por @ControllerAdvice + @ExceptionHandler

2.4 Caso integral

A través de un caso completo, obtendremos una comprensión profunda de cómo manejar excepciones en SpringMVC. Esta sección presentará un caso práctico y demostrará cómo utilizar el mecanismo de manejo de excepciones global para manejar excepciones.

• Método uno de manejo de excepciones

SpringMVC viene con un controlador de excepciones llamado SimpleMappingExceptionResolver, que implementa la interfaz HandlerExceptionResolver. Todos los controladores de excepciones globales deben implementar esta interfaz.

<!-- springmvc提供的简单异常处理器 -->
<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
    <!-- 定义默认的异常处理页面 -->
    <property name="defaultErrorView" value="error"/>
    <!-- 定义异常处理页面用来获取异常信息的变量名，也可不定义，默认名为exception --> 
    <property name="exceptionAttribute" value="ex"/>
    <!-- 定义需要特殊处理的异常，这是重要点 --> 
    <property name="exceptionMappings">
        <props>
            <prop key="java.lang.RuntimeException">error</prop>
        </props>
    	<!-- 还可以定义其他的自定义异常 -->
    </property>
</bean> 

• error.jsp

<%--
  Created by IntelliJ IDEA.
  User: yuanh
  Date: 2023/9/13
  Time: 16:07
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
异常
${ex}
</body>
</html>

• Código de excepción

• Efectos de funcionamiento anormales
  

• Método dos de manejo de excepciones

Excepción global

package com.yuan.exception;

public class GlobalException extends RuntimeException {
    
    
    public GlobalException() {
    
    
    }

    public GlobalException(String message) {
    
    
        super(message);
    }

    public GlobalException(String message, Throwable cause) {
    
    
        super(message, cause);
    }

    public GlobalException(Throwable cause) {
    
    
        super(cause);
    }

    public GlobalException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
    
    
        super(message, cause, enableSuppression, writableStackTrace);
    }
}

Controlador de excepciones global

package com.yuan.Component;

import com.yuan.exception.GlobalException;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ModelAndView;

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

@Component
public class GlobalExceptionHandler implements HandlerExceptionResolver {
    
    
    @Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest,
                                         HttpServletResponse httpServletResponse,
                                         Object o, Exception e) {
    
    
        ModelAndView mv = new ModelAndView();
        mv.setViewName("error");
        if (e instanceof GlobalException){
    
    
            GlobalException globalException = (GlobalException) e;
            mv.addObject("ex",globalException.getMessage());
            mv.addObject("msg","全局异常....");
        }else if (e instanceof RuntimeException){
    
    
            RuntimeException runtimeException = (RuntimeException) e;
            mv.addObject("ex",runtimeException.getMessage());
            mv.addObject("msg","运行时异常....");
        }else {
    
    
            mv.addObject("ex",e.getMessage());
            mv.addObject("msg","其他异常....");

        }
        return mv;
    }
}

Método de excepción

    @ResponseBody
    @RequestMapping("/jsonStr")
    public String jsonStr(HttpServletRequest req, Student Student){
    
    
        if(true)
        throw  new GlobalException("异常123");
        return "clzEdit";
    }

• Manejo de la excepción tres @ControllerAdvice

package com.yuan.Component;

import com.yuan.exception.GlobalException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.HashMap;
import java.util.Map;

@ControllerAdvice
public class GlobalExceptionResolver {
    
    

//    跳转错误页面
//    @ExceptionHandler
//    public ModelAndView handler(Exception e){
    
    
//        ModelAndView mv = new ModelAndView();
//        mv.setViewName("error");
//        if (e instanceof GlobalException){
    
    
//            GlobalException globalException = (GlobalException) e;
//            mv.addObject("ex",globalException.getMessage());
//            mv.addObject("msg","全局异常....");
//        }else if (e instanceof RuntimeException){
    
    
//            RuntimeException runtimeException = (RuntimeException) e;
//            mv.addObject("ex",runtimeException.getMessage());
//            mv.addObject("msg","运行时异常....");
//        }
//        return mv;
//    }

// 返回错误json数据
    @ResponseBody
    @ExceptionHandler
    public Map handler(Exception e){
    
    
        Map map = new HashMap();
        if (e instanceof GlobalException){
    
    
            GlobalException globalException = (GlobalException) e;
            map.put("ex",globalException.getMessage());
            map.put("msg","全局异常....");
        }else if (e instanceof RuntimeException){
    
    
            RuntimeException runtimeException = (RuntimeException) e;
            map.put("ex",runtimeException.getMessage());
            map.put("msg","运行时异常....");
        }else {
    
    
            map.put("ex",e.getMessage());
            map.put("msg","其它异常....");
        }
        return map;
    }
}

Resumir

Este artículo analiza en profundidad los mecanismos de manejo de excepciones y devolución de datos JSON en SpringMVC. Comenzamos con métodos de configuración y uso, introdujimos gradualmente puntos de conocimiento relevantes y profundizamos nuestra comprensión a través de casos y ejemplos completos. Espero que este artículo pueda ayudar a los lectores a comprender y aplicar mejor el mecanismo de manejo de excepciones y devolución de datos JSON en SpringMVC.