JSON和全局异常处理

╰半橙微兮° 2023-10-15 21:53 21阅读 0赞

**目录**

1️⃣JSON

一、什么是json？

二、与javascript的关系

三、语法格式

四、注意事项

五、总结

六，使用json

1导入pom.xml依赖

2.配置spring-mvc.xml

3. @ResponseBody注解使用

创建一个web层控制器

编写ClazzBiz

实现接口

测试：

2.异常处理机制

1.为什么要全局异常处理？

2.异常处理思路

3.SpringMVC异常分类

4.异常处理方法

方法一

方法二

方法三

--------------------

## 1️⃣JSON ##

### **一、什么是json？** ###

json的全称为：JavaScript Object Notation，是一种轻量级的数据交互格式。它基于 ECMAScript (欧洲计算机协会制定的js规范)的一个子集，采用完全独立于编程语言的文本格式来存储和表示数据。【以上来自于百度百科】

简单来说：json就是一种在各个编程语言中流通的数据格式，负责不同编程语言中的数据传递和交互。  
类似于：

*  国际通用语言-**英语**
 *  中国56个民族不同地区的通用语言-**普通话**。

但真要说json到底是什么，以及json的作用，我们总是难以描述，下面我将从各个方面来进行说明：

### **二、与javascript的关系** ###

相信很多程序员只要一提到json总会想到js，因为json不仅含有js的名字，其格式也与js中对象（object）的格式并无一二。

这里我们要进行一个说明，首先**json是基于ECMAScript语法**，但这并不意味着json必须在js中使用，或者必须要产生什么联系，json在js中的处理也并没有比其他语言占有更多优势。只是因为语法相似，而使得**js开发者能更快的上手json**而已。

事实上几乎所有编程语言中都有对json数据转换的支持：  
js中，json与对象的转换：`JSON.parse()`/`JSON.stringify()`;  
php中，json与数组的转换：`json_encode()`/`json_decode()`;  
java中，json与对象的转换：`fromJson()`/`toJson()`;  
python中，json与对象的转换：`json.dumps()`/`json.loads()`;

### **三、语法格式** ###

那么json的语法格式到底是怎样的呢？我们先来看一段json数据：  
`{"name":"admin","age":18}`  
这就是一种最简单的json，如果有学过js的开发者是不是发现json的语法与js中object的语法**几乎相同**。  
但是，注意：

*  json是一种纯字符数据，不属于编程语言
 *  json的语法与js中object的语法几乎一致（下一部分说明不同）
 *  json数据以键值对形式存在，多个键值对之间用逗号`,`隔开，键值对的键和值之间用冒号`:`连接
 *  json数据在js对象的基础上做了严格化
 *  json数据中的键值对可以使用编程语言中所谓的关键字（\*见注意事项）
 *  json的数据可以用花括号`{}`或中括号`[]`包裹，对应js中的object和array

### **四、注意事项** ###

为什么说几乎相同，而不是完全相同呢？接下来我们要说的就是json与js中对象的不同点，也是json严格要求的部分：

*  json的键值对的**键**部分，必须用双引号`"`包裹，单引号都不行（所以如果在键中出现了关键字，也被字符化了），而js中对象没有强制要求（所以在键中不允许出现关键字）
 *  json的键值对的**值**部分，不允许出现函数`function`，`undefined`，`NaN`，但是可以有`null`，js中对象的值中可以出现
 *  json数据结束后，不允许出现没有意义的逗号`,`如：`{"name":"admin","age":18,}`，注意看数据结尾部分18的后面的逗号，不允许出现

### **五、总结** ###

所以，json数据的格式可以是：  
`{"name":"admin","age":18}`  
也可以是：  
`["hello",3.1415,"json"]`  
还可以是：  
`[{"name":"admin","age":18},{"name":"root","age":16},{"name":"张三","age":20}]`

不能是：（key没有双引号）  
`{"name":"admin",age:18}`  
不能是：（无意义的逗号）  
`{"name":"admin","age":18,}`  
不能是：（不允许出现函数）  
`{"name":"admin","age":18,"show":function()()}`  
不能是：（不允许出现undefined）  
`{"name":"admin","age":18,"show":undefined}`  
不能是：（不允许出现NaN）  
`{"name":"admin","age":18,"strong":NaN}`  
不能是：（无意义的逗号）  
`["hello",3.1415,"json",]`  
不能是：（无意义的逗号）  
`[{"name":"admin","age":18},{"name":"root","age":16},{"name":"张三","age":20},]`

以上内容，希望能对以后使用json有所帮助，简单来说json处理的是

> 对象｛｝，数值\[ \] , 混合 ｛rows: \[ \]｝以及 json转换的注解

其实作为通用数据，xml也是一种不错的选择，但是随着json的出现，xml的使用场景正慢慢被json蚕食，相对来说json在某些方面下的体现还是比xml稍具优势，后期可再开一篇文档说明json和xml的区别。

### 六，使用json ###

#### 1导入pom.xml依赖 ####

<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>

#### 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">
            
            <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>

#### 3. **@ResponseBody注解使用** ####

> `@ResponseBody`注解的作用是将Controller的方法返回的对象通过适当的转换器转换为指定的格式之后，写入到response对象的body区，通常用来返回`JSON`数据或者是XML数据。
> 
> 注意：在使用此注解之后不会再走**视图解析器**，而是直接将数据写入到输入流中，他的效果等同于通过response对象输出指定格式的数据。

##### 创建一个web层控制器 #####

package com.xzs.web;
    
    import com.xzs.Biz.ClazzBiz;
    import com.xzs.model.Clazz;
    import com.xzs.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;
    
    @Controller
    @RequestMapping("/clz/json")
    public class JsonController {
        @Autowired
        private ClazzBiz clazzBiz;
    
        /**
         * 返回List<T>
         * @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.listPager(clazz, pageBean);
            return lst;
        }
    
        /**
         * 返回T
         * @param req
         * @param clazz
         * @return
         */
        @ResponseBody
        @RequestMapping("/load")
        public Clazz load(HttpServletRequest req, Clazz clazz){
            if(clazz.getCid() != null){
                List<Clazz> lst = this.clazzBiz.listPager(clazz, null);
                return lst.get(0);
            }
            return null;
        }
    
    
        /**
         * 返回List<Map>
         * @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
         * @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.listPager(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){
            return "clzEdit";
        }
    
    
    }

在ClazzMapper.xml中创建

<select id="mapListPager" resultType="java.util.Map" parameterType="java.lang.Integer" >
      select
      <include refid="Base_Column_List" />
      from t_struts_class
      <where><if test="cname !=null">
        and cname like concat('%',#{cname},'%')
      </if></where>
    </select>

注意！！！这里方法返回的是map值所以resultType中的属性值要填java.util.Map

在ClazzMapper中实现该方法

package com.xzs.mapper;
    
    import com.xzs.model.Clazz;
    import com.xzs.utils.PageBean;
    
    import java.util.List;
    import java.util.Map;
    
    public interface ClazzMapper {
        int deleteByPrimaryKey(Integer cid);
    
        int insert(Clazz record);
    
        int insertSelective(Clazz record);
    
        Clazz selectByPrimaryKey(Integer cid);
    
        int updateByPrimaryKeySelective(Clazz record);
    
        int updateByPrimaryKey(Clazz record);
    
        List<Clazz> listPger(Clazz clazz);
    
        List<Map> mapListPager(Clazz clazz);
    }

##### 编写ClazzBiz #####

package com.xzs.Biz;
    
    import com.xzs.model.Clazz;
    import com.xzs.utils.PageBean;
    import org.springframework.stereotype.Repository;
    
    import java.util.List;
    import java.util.Map;
    
    @Repository
    public interface ClazzBiz {
        int deleteByPrimaryKey(Integer cid);
    
        int insert(Clazz record);
    
        int insertSelective(Clazz record);
    
        Clazz selectByPrimaryKey(Integer cid);
    
        int updateByPrimaryKeySelective(Clazz record);
    
        int updateByPrimaryKey(Clazz record);
    
        List<Clazz> listPager(Clazz clazz, PageBean page);
    
        List<Map> mapListPager(Clazz clazz, PageBean page);
    }

##### 实现接口 #####

package com.xzs.Impl;
    
    import com.xzs.Biz.ClazzBiz;
    import com.xzs.mapper.ClazzMapper;
    import com.xzs.model.Clazz;
    import com.xzs.utils.PageBean;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    import java.util.List;
    import java.util.Map;
    
    @Service
    public class ClazzBizImpl implements ClazzBiz {
    @Autowired
        private ClazzMapper clazzMapper;
        @Override
        public int deleteByPrimaryKey(Integer cid) {
            return clazzMapper.deleteByPrimaryKey(cid);
        }
    
        @Override
        public int insert(Clazz record) {
            return clazzMapper.insert(record);
        }
    
        @Override
        public int insertSelective(Clazz record) {
            return clazzMapper.insertSelective(record);
        }
    
        @Override
        public Clazz selectByPrimaryKey(Integer cid) {
            return clazzMapper.selectByPrimaryKey(cid);
        }
    
        @Override
        public int updateByPrimaryKeySelective(Clazz record) {
            return clazzMapper.updateByPrimaryKeySelective(record);
        }
    
        @Override
        public int updateByPrimaryKey(Clazz record) {
            return clazzMapper.updateByPrimaryKey(record);
        }
    
        @Override
        public List<Clazz> listPager(Clazz clazz, PageBean pageBean) {
            return clazzMapper.listPger(clazz);
        }
    
        @Override
        public List<Map> mapListPager(Clazz clazz, PageBean pageBean) {
            return clazzMapper.mapListPager(clazz);
        }
    
    
    }

##### 测试： #####

public List<Clazz> list方法

![43a9f3d5f8764da6b792e9a25b87edaa.png][]

public Clazz load 方法

![34785b3744f14d458919017a43065605.png][]

public List<Map> mapList方法

![d10ce70dec6e4d2aab32a9d0d5ba025c.png][]

public Map mapLoad方法

![17b6a4d528cc407d8c8b201c0799e524.png][]

public Map all方法

![2d4a312aa3ed4a1fb4a069e727d48351.png][]

public String jsonStr方法

![036deed9bd564f2eaef2da78a1ff82a1.png][]

> 注意：当我们的方法全部都是返SON对象时 @ResponseBody可以放在只写一个但是必须得是上述JsonController中@Controller的上方并且（ @ResponseBody，@Controller）等于@RestController如果在JsonController中将 public String jsonStr方法上的@ResponseBody给注释掉那么将不再返回json数据而是进行页面跳转

证明：

import com.xzs.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;
    
    @Controller
    @RequestMapping("/clz/json")
    public class JsonController {
        @Autowired
        private ClazzBiz clazzBiz;
    
        /**
         * 返回List<T>
         * @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.listPager(clazz, pageBean);
            return lst;
        }
    
        /**
         * 返回T
         * @param req
         * @param clazz
         * @return
         */
        @ResponseBody
        @RequestMapping("/load")
        public Clazz load(HttpServletRequest req, Clazz clazz){
            if(clazz.getCid() != null){
                List<Clazz> lst = this.clazzBiz.listPager(clazz, null);
                return lst.get(0);
            }
            return null;
        }
    
    
        /**
         * 返回List<Map>
         * @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
         * @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.listPager(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){
            return "clzEdit";
        }
    
    
    }

![376e14425ee1458bb489b1d7ac9033cc.png][]

package com.xzs.web;
    
    import com.xzs.Biz.ClazzBiz;
    import com.xzs.model.Clazz;
    import com.xzs.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 ClazzBiz clazzBiz;
    
        /**
         * 返回List<T>
         * @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.listPager(clazz, pageBean);
            return lst;
        }
    
        /**
         * 返回T
         * @param req
         * @param clazz
         * @return
         */
    //    @ResponseBody
        @RequestMapping("/load")
        public Clazz load(HttpServletRequest req, Clazz clazz){
            if(clazz.getCid() != null){
                List<Clazz> lst = this.clazzBiz.listPager(clazz, null);
                return lst.get(0);
            }
            return null;
        }
    
    
        /**
         * 返回List<Map>
         * @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
         * @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.listPager(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){
            return "clzEdit";
        }
    
    
    }

![ac29ab3eae024d9fb8914c491e14556e.png][]

隐藏数据

在实体类中在要隐藏的属性上添加@JsonIgnore即可

package com.xzs.model;
    
    import com.fasterxml.jackson.annotation.JsonIgnore;
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import org.hibernate.validator.constraints.NotBlank;
    
    import javax.validation.constraints.NotNull;
    
    @Data//相当于set get toString方法
    @AllArgsConstructor //有参构造器
    @NoArgsConstructor
    public class Clazz {
        @NotNull(message = "班级编号不能为空")
    //    @Size(max = 100,min = 10,message = "大小必须在10至100之间")
        protected Integer cid;
    
        @NotBlank(message = "班级名不能为空")
        protected String cname;
    
        @NotBlank(message = "班级教员老师不能为空")
        protected String cteacher;
    @JsonIgnore
        private String pic="暂无图片";
    
    
    }

![758cc2a43d184ed3a12f9e78336f2e92.png][]

## 2.异常处理机制 ##

### 1.为什么要全局异常处理？ ###

我们知道，系统中异常包括：编译时异常和运行时异常RuntimeException，前者通过捕获异常从而获取异常信息，后者主要通过规范代码开发、测试通过手段减少运行时异常的发生。在开发中，不管是dao层、service层还是controller层，都有可能抛出异常，在springmvc中，能将所有类型的异常处理从各处理过程解耦出来，既保证了相关处理过程的功能较单一，也实现了异常信息的统一处理和维护。

### 2.异常处理思路 ###

系统的dao、service、controller出现异常都通过throws Exception向上抛出，最后由springmvc前端控制器交由异常处理器进行异常处理。springmvc提供全局异常处理器（一个系统只有一个异常处理器）进行统一异常处理。

![d513741c754744e7af57a206389c2c39.png][]

### 3.SpringMVC异常分类 ###

*  使用Spring MVC提供的简单异常处理器SimpleMappingExceptionResolver；
 *  实现Spring的异常处理接口HandlerExceptionResolver自定义自己的异常处理器；
 *  使用@ControllerAdvice + @ExceptionHandler

### 4.异常处理方法 ###

@RequestMapping("/mapList")
        public List<Map> mapList(HttpServletRequest req, Clazz clazz){
            System.out.println((1 / 0));
            PageBean pageBean = new PageBean();
            pageBean.setRequest(req);
            List<Map> lst = this.clazzBiz.mapListPager(clazz, pageBean);
            return lst;
        }

#### 方法一 ####

<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">error</prop>
            </props>
        	
        </property>
    </bean>

编写错误界面error.jsp

<%--
      Created by IntelliJ IDEA.
      User: xzs
      Date: 2023/9/13
      Time: 16:48
      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>
    网络异常
    </body>
    </html>

![279dc0140fc147598dd79663bd724753.png][]

#### 方法二 ####

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

package com.xzs.component;
    
    import com.xzs.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 {
                RuntimeException runtimeException = (RuntimeException) e;
                mv.addObject("ex",runtimeException.getMessage());
                mv.addObject("msg","其他时异常....");
            }
            return mv;
        }
    }

编写错误界面

运行结果

![6f209979ecdb49f9a02400c5e3ce37f6.png][]

#### 方法三 ####

package com.xzs.component;
    
    import com.xzs.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;
        }
    }

返回json数据

![6473f93d0bdb490fa0e74a55835123ab.png][]

package com.xzs.component;
    
    import com.xzs.exception.GlobalException;
    import org.springframework.web.bind.annotation.ControllerAdvice;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    import org.springframework.web.bind.annotation.ResponseBody;
    import org.springframework.web.servlet.ModelAndView;
    
    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;
    //    }
    }

![43ba566ee1b247a5b8e6d8a3e7aae393.png][]

[43a9f3d5f8764da6b792e9a25b87edaa.png]: https://img-blog.csdnimg.cn/43a9f3d5f8764da6b792e9a25b87edaa.png
[34785b3744f14d458919017a43065605.png]: https://img-blog.csdnimg.cn/34785b3744f14d458919017a43065605.png
[d10ce70dec6e4d2aab32a9d0d5ba025c.png]: https://img-blog.csdnimg.cn/d10ce70dec6e4d2aab32a9d0d5ba025c.png
[17b6a4d528cc407d8c8b201c0799e524.png]: https://img-blog.csdnimg.cn/17b6a4d528cc407d8c8b201c0799e524.png
[2d4a312aa3ed4a1fb4a069e727d48351.png]: https://img-blog.csdnimg.cn/2d4a312aa3ed4a1fb4a069e727d48351.png
[036deed9bd564f2eaef2da78a1ff82a1.png]: https://img-blog.csdnimg.cn/036deed9bd564f2eaef2da78a1ff82a1.png
[376e14425ee1458bb489b1d7ac9033cc.png]: https://img-blog.csdnimg.cn/376e14425ee1458bb489b1d7ac9033cc.png
[ac29ab3eae024d9fb8914c491e14556e.png]: https://img-blog.csdnimg.cn/ac29ab3eae024d9fb8914c491e14556e.png
[758cc2a43d184ed3a12f9e78336f2e92.png]: https://img-blog.csdnimg.cn/758cc2a43d184ed3a12f9e78336f2e92.png
[d513741c754744e7af57a206389c2c39.png]: https://img-blog.csdnimg.cn/d513741c754744e7af57a206389c2c39.png
[279dc0140fc147598dd79663bd724753.png]: https://img-blog.csdnimg.cn/279dc0140fc147598dd79663bd724753.png
[6f209979ecdb49f9a02400c5e3ce37f6.png]: https://img-blog.csdnimg.cn/6f209979ecdb49f9a02400c5e3ce37f6.png
[6473f93d0bdb490fa0e74a55835123ab.png]: https://img-blog.csdnimg.cn/6473f93d0bdb490fa0e74a55835123ab.png
[43ba566ee1b247a5b8e6d8a3e7aae393.png]: https://img-blog.csdnimg.cn/43ba566ee1b247a5b8e6d8a3e7aae393.png