一篇博文教你SpringMVC中JSON注解&异常处理的使用

目录

 一、JSON数据返回

1.2.Jackson的介绍

1.3.3.案例演示

二、异常处理

2.4.1.异常处理方式①

2.4.2.异常处理方式②

2.4.3.异常处理方式③

---

 一、JSON数据返回

1.1.

1.2.Jackson的介绍

1.2.1.什么是Jackson
Jackson是一个流行的Java库，用于处理JSON格式数据的序列化和反序列化。它提供了一组简单易用的API，可以方便地将Java对象与JSON数据进行转换。

1.2.2 常用注解
在使用Jackson进行JSON序列化和反序列化时，可以使用一些常用的注解来控制转换过程。例如：

@JsonFormat

指定序列化日期/时间值时的格式

@JsonIgnore

作用在字段或方法上，用来完全忽略被注解的字段和方法对应的属性

1.2.3Jackson具有以下特点和优势：

1. 高性能：Jackson是一个高性能的JSON处理库，它使用了一些优化技术，如流式处理和基于缓冲区的读写，以提供非常快速的JSON序列化和反序列化性能。

2. 灵活性：Jackson提供了多种转换策略和配置选项，可以根据需要进行灵活的定制。它支持对Java对象的字段级别的映射、支持不同的日期格式、支持多态类型处理等。

3. 支持注解：Jackson支持使用注解来定制JSON序列化和反序列化的行为。通过在Java对象上添加注解，可以指定字段的名称、序列化的顺序、忽略某些字段等。

4. 多种数据格式支持：除了JSON，Jackson还支持其他多种数据格式的处理，包括XML、YAML等。它可以方便地将Java对象转换为这些格式，或者将这些格式的数据转换为Java对象。

5. 广泛应用：Jackson在Java开发领域得到了广泛的应用。它已经成为许多主流框架和技术的首选，如Spring MVC、Hibernate、JAX-RS等。

1.3 使用注解
1.3.1 导入依赖
要使用Jackson库，首先需要在项目中导入相应的依赖。

<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.3.2.配置spring-mvc.xml

<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.3.案例演示

演示如何使用Jackson返回JSON数据，我们创建一个简单的控制器方法，并使@ResponseBody注解将其返回的对象转换为JSON格式。

JsonController

package com.liyongan.controller;

import com.liyongan.biz.ClazzBiz;
import com.liyongan.model.Clazz;
import com.liyongan.util.PageBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import javax.validation.GroupDefinitionException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

//@ResponseBody
//@Controller
@RestController                 //RestController=ResponseBody+Controller
@RequestMapping("/clz/json")
public class JsonController {
    @Autowired
    private ClazzBiz clazzBiz;

    /**
     * 返回List<T>//json数组
     * @param req
     * @param clazz
     * @return
     */
//    @ResponseBody
    @RequestMapping("/list")
    public List<Clazz> list(HttpServletRequest req, Clazz clazz){
        PageBean pageBean = new PageBean();
        pageBean.setRequest(req);
        List<Clazz> lst = this.clazzBiz.selectBySnamePager(clazz, pageBean);
        System.out.println(1 / 0);
        return lst;
    }

    /**
     * 返回T//json对象
     * @param req
     * @param clazz
     * @return
     */
//    @ResponseBody
    @RequestMapping("/load")
    public Clazz load(HttpServletRequest req, Clazz clazz){
        if(clazz.getCid() != null){
            List<Clazz> lst = this.clazzBiz.selectBySnamePager(clazz, null);
            return lst.get(0);
        }
        return null;
    }


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

    /**
     * 返回Map//单个map
     * @param req
     * @param clazz
     * @return
     */
//    @ResponseBody
    @RequestMapping("/mapLoad")
    public Map mapLoad(HttpServletRequest req, Clazz clazz){
        if(clazz.getCid() != null){
            List<Map> lst = this.clazzBiz.mapListPager(clazz, null);
            return lst.get(0);
        }
        return null;
    }


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

    //    @ResponseBody
    @RequestMapping("/jsonStr")
    public String jsonStr(HttpServletRequest req, Clazz clazz){
        if(true)
            throw new GroupDefinitionException("该死的刁民，总想害朕");
        return "clzEdit";
    }


}

返回各种类型数据

Json数组

Json对象

Json数组 

单个map

1.4.@ResponseBody注解使用

@ResponseBody注解的作用是将Controller的方法返回的对象通过适当的转换器转换为指定的格式之后，写入到response对象的body区，通常用来返回JSON数据或者是XML数据。

注意：在使用此注解之后不会再走视图解析器，而是直接将数据写入到输入流中，他的效果等同于通过response对象输出指定格式的数据。

二、异常处理

如果我们不使用异常处理就会出现这样的界面：体验非常的不好。

2.1.为什么要全局异常处理

全局异常处理的目的是为了提升系统的稳定性和用户体验。当应用程序抛出异常时，全局异常处理可以捕获并处理这些异常，从而避免将异常信息直接暴露给用户。

2.2 异常处理思路
在设计异常处理机制时，需要考虑以下几个方面：定义自定义异常类、编写异常处理器、配置全局异常处理。

2.3 SpringMVC异常分类
Spring MVC将异常分为两类：可预测的异常和不可预测的异常。可预测的异常是我们在代码中明确捕获并处理的异常，而不可预测的异常是无法预测和处理的异常。

2.4.实例：

2.4.1.异常处理方式①

SpringMVC中自带了一个异常处理器叫SimpleMappingExceptionResolver，该处理器实现了HandlerExceptionResolver 接口，全局异常处理器都需要实现该接口。

在springmvc中配置

<!-- 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: 微微
  Date: 2023/9/13
  Time: 18:12
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>错误异常界面</title>
</head>
<body>
发生错误异常界面！！!
<hr>
${ex}问题是：
${msg}
</body>
</html>

效果：

2.4.2.异常处理方式②

创建一个名为exception的包将GlobalException放入

package com.liyongan.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);
    }
}

创建一个名为Component的包将的GlobalExceptionHandler类放入

package com.liyongan.controller;

import com.liyongan.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","运行时异常....");
        }
        return mv;
    }
}

效果：

2.4.3.异常处理方式③

创建一个名为Component的包将我们的GlobalExceptionResolver类放入

package com.liyongan.controller;

import com.liyongan.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 {


// 返回错误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;
    }
}

这种方式是将我们的错误信息进行map保存然后转换为JSON格式输出在页面上

2.5.响应封装类

进行优化：GlobalExceptionResolver.java

@ControllerAdvice
public class GlobalExceptionResolver {
 
    // 响应封装类
    @ResponseBody
    @ExceptionHandler
    public Map handler(Exception e){
 
        if (e instanceof GlobalException){
            GlobalException globalException = (GlobalException) e;
            return R.ok(500,"全局异常....",globalException.getMessage());
        }else if (e instanceof RuntimeException){
            RuntimeException runtimeException = (RuntimeException) e;
            return R.ok(500,"运行时异常....",runtimeException.getMessage());
        }else {
            return R.ok(500,"其他异常....",e.getMessage());
        }
    }
}

效果：