【SpringMVC】JSON注解&异常处理的使用

一级目录

一、JSON数据返回

在Web开发中，使用JSON格式返回数据已成为一种常见的做法。本节将介绍如何使用Jackson库实现JSON数据的返回。

1.1 前言

随着移动应用和前后端分离的趋势，使用JSON作为数据传输格式变得越来越流行。在Spring MVC中，我们可以通过配置和使用Jackson库来方便地将Java对象转换为JSON格式的数据并返回给客户端。

1.2 Jackson的介绍

1.2.1 什么是Jackson

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

1.2.2 常用注解

在使用Jackson进行JSON序列化和反序列化时，可以使用一些常用的注解来控制转换过程。例如，@JsonProperty可以用于指定JSON属性与Java对象属性之间的映射关系，@JsonFormat可以用于指定日期格式化方式等。

1.3 使用注解

1.3.1 导入依赖
要使用Jackson库，首先需要在项目中导入相应的依赖。可以通过Maven或Gradle来管理依赖。

<dependency>
    <groupId>com.fasterxml.jackson.coregroupId>
    <artifactId>jackson-databindartifactId>
    <version>2.9.3version>
dependency>
<dependency>
    <groupId>com.fasterxml.jackson.coregroupId>
    <artifactId>jackson-coreartifactId>
    <version>2.9.3version>
dependency>
<dependency>
    <groupId>com.fasterxml.jackson.coregroupId>
    <artifactId>jackson-annotationsartifactId>
    <version>2.9.3version>
dependency> 

1.3.2 配置spring-mvc.xml

在Spring MVC的配置文件（spring-mvc.xml）中，需要进行一些配置以启用Jackson的支持。可以配置一个MappingJackson2HttpMessageConverter bean，并将其注册到Spring MVC的消息转换器列表中。

<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">
    
    <property name="supportedMediaTypes">
        <list>
            <value>text/html;charset=UTF-8value>
            <value>text/json;charset=UTF-8value>
            <value>application/json;charset=UTF-8value>
        list>
    property>
bean>

1.3.3 案例实战

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

package com.niyin.web;

import com.niyin.excetpion.GlobalException;
import com.niyin.utils.PageBean;
import com.niyin.biz.tyBiz;
import com.niyin.model.ty;
import com.niyin.utils.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 javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


@ResponseBody
@Controller
@RequestMapping("/clz/json")
public class JsonController {
    @Autowired
    private tyBiz tyBiz;

    /**
     * 返回List
     * @param req
     * @return
     */
//    @ResponseBody
    @RequestMapping("/list")
    public List<ty> list(HttpServletRequest req, ty t){
        PageBean pageBean = new PageBean();
        pageBean.setRequest(req);
        List<ty> lst = this.tyBiz.selectByPager(t,pageBean);
//        System.out.println(1 / 0);
        return lst;
    }

    /**
     * 返回T
     * @param req
     * @return
     */
//    @ResponseBody
    @RequestMapping("/load")
    public ty load(HttpServletRequest req, ty t){
        if(t.getTid() != null){
            List<ty> lst = this.tyBiz.selectByPager(t,null);
            return lst.get(0);
        }
        return null;
    }


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

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


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

//    @ResponseBody
    @RequestMapping("/jsonStr")
    public String jsonStr(HttpServletRequest req, ty t){
//        if (true)
//        throw new GlobalException("你不正经，无理取闹");
        return "clzEdit";

    }


}

返回各种类型数据
list

load

mapList

mapLoad

all

jsonStr

小提示@JsonIgnore 可以用于·隐藏数据。

二、异常处理

异常处理是Web开发中不可避免的一部分。Spring MVC提供了全局异常处理机制，可以统一处理应用程序中的异常情况。

2.1 为什么要全局异常处理

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

2.2 异常处理思路

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

2.3 SpringMVC异常分类

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

2.4 案例实战

2.4.1 异常处理方式①

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

<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
        
        <property name="defaultErrorView" value="error"/>
        
        <property name="exceptionAttribute" value="ex"/>
        
        <property name="exceptionMappings">
            <props>
                <prop key="java.lang.RuntimeException">errorprop>
            props>
            
        property>
    bean>

jsp

<%--
  Created by IntelliJ IDEA.
  User: 林墨
  Date: 2023/9/13
  Time: 15:37
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Titletitle>
head>
<body>
错误信息界面
${ex}
<hr>
${msg}
body>
html>

2.4.2 异常处理方式②

创建一个名为exception的包将我们的GlobalException类放入其中。

package com.niyin.excetpion;

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.niyin.component;

import com.niyin.excetpion.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;
    }
}

2.4.3 异常处理方式③

GlobalExceptionResolver.java

package com.niyin.component;

import com.niyin.excetpion.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;
    }
}

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