Springmvc ---- json解析和异常处理

目录

一、json解析

1. JOSN的各种场景

 二、异常处理

 1）SpringMVC自带的简单异常处理器

 2）通过HandlerExceptionResovler接口实现全局异常

 3)使用@ControllerAdvice+@ExceptionHandler实现全局异常

 4）全局异常处理JSON返回

---

一、json解析

 SpringMVC框架如何产生下面三种格式的数据？（对象，数组，对象数组）

1.导入pom.xml依赖

2.配置Springmvc.xml配置适配器

作用是做json数据转换

3.使用注解能够将任何的数据转换成json对象

1. JOSN的各种场景

操作步骤：

1.导入依赖：

 <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.添加适配器：（固定代码）

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

3.创建处理器类controller类

package com.zking.oa.controller;
 
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
 
/**
 * @author 锦鲤
 * @site www.lucy.com
 * @company xxx公司
 * @create  2022-08-22 16:36
 */
@Controller
@RequestMapping("/clz/json")
public class JsonController {
 
    @ResponseBody
    @RequestMapping("/clzEdit")
        public String clzEdit(){
        System.out.println("JsonController.clzEdit");
            return  "clzEdit";
        }
 
 
 
 
 
}

其他代码配置‘

接口类

’

package com.zking.oa.biz;

import com.zking.oa.model.Clazz;
import com.zking.oa.util.PageBean;

import java.util.List;
import java.util.Map;

/**
 * @author 锦鲤
 * @site www.lucy.com
 * @company xxx公司
 * @create  2022-08-18 13:08
 */
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 listPager (Clazz clazz, PageBean pagebean);
        List
 }

 clazzmapper.java

package com.zking.oa.mapper;

import com.zking.oa.model.Clazz;
import com.zking.oa.util.PageBean;
import org.springframework.stereotype.Repository;

import java.util.List;
import java.util.Map;

@Repository
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 listPager (Clazz clazz);
    List

}

 clazzmapper.xml配置

  select
  
  from t_struts_class
  
    
      and cname like CONCAT('%', #{cname},'%')
    
    
      and cid =#{cid}
    

  

 实现类

package com.zking.oa.biz;

import com.zking.oa.mapper.ClazzMapper;
import com.zking.oa.model.Clazz;
import com.zking.oa.util.PageBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;

/**
 * @author 锦鲤
 * @site www.lucy.com
 * @company xxx公司
 * @create  2022-08-18 13:08
 */
@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 listPager(Clazz clazz, PageBean pagebean) {
        return  clazzmapper.listPager(clazz);
    }

    @Override
    public List
}

 

1.1.1返回List

 //    list
    @ResponseBody
    @RequestMapping("/list")
    public List<Clazz> list(HttpServletRequest request, Clazz clazz) {
        PageBean pagebean = new PageBean();
        pagebean.setRequest(request);
//结果[{},{}]
        return this.clazzBiz.listPager(clazz, pagebean);
    }

1.1.2返回List

 //    list
    @ResponseBody
    @RequestMapping("/listMap")
    public List<Map> listMap(HttpServletRequest request, Clazz clazz) {
        PageBean pagebean = new PageBean();
        pagebean.setRequest(request);
//结果{},{}
        return this.clazzBiz.listMapPaper(clazz, pagebean);
    }

1.1.3返回T

 //    T
    @ResponseBody
    @RequestMapping("/load")
    public Clazz load(HttpServletRequest request, Clazz clazz) {
        PageBean pagebean = new PageBean();
        pagebean.setRequest(request);
        return this.clazzBiz.listPager(clazz, pagebean).get(0);
    }

1.1.4返回Map

  //    map
    @ResponseBody
    @RequestMapping("/map")
    public Map map(HttpServletRequest request, Clazz clazz) {
        PageBean pagebean = new PageBean();
        pagebean.setRequest(request);
//结果{}
        return this.clazzBiz.listMapPaper(clazz, pagebean).get(0);
    }

1.1.5返回混合

 
    //  格式  {
//    msg:"",
//    data:[],
//    pagebean:{}
    //    }
 
    @ResponseBody
    @RequestMapping("/hunhe")
    public Map hunhe(HttpServletRequest request, Clazz clazz) {
        //http://loclhost：8080/clz/json/load?cid=2
        PageBean pagebean = new PageBean();
        pagebean.setRequest(request);
        List<Clazz> lst = this.clazzBiz.listPager(clazz, pagebean);
        Map map = new HashMap();
        map.put("data", lst);
        map.put("pagebean", pagebean);
 
        return map;
    }
 
 

---

 二、异常处理

 背景：

在开发中，不管是dao层、service层还是controller层，都有可能抛出异常，在springmvc中，能将所有类型的异常处理从各处理过程解耦出来，既保证了相关处理过程的功能较单一，也实现了异常信息的统一处理和维护。

异常处理的三种方式

 1）使用Spring MVC提供的简单异常处理器SimpleMappingExceptionResolver；

   2）实现Spring的异常处理接口HandlerExceptionResolver自定义自己的异常处理器；

   3）使用@ControllerAdvice + @ExceptionHandler

 

 jsonController类

  //    list<T> //    list<T> 异常处理
    @ResponseBody
    @RequestMapping("/list")
    public List<Clazz> list(HttpServletRequest request, Clazz clazz) {
        PageBean pagebean = new PageBean();
        pagebean.setRequest(request);
//结果[{},{}]
        if(true){
            throw new RuntimeException("查询班级异常，异常存在于jsonController.xml里");
 
        }
        return this.clazzBiz.listPager(clazz, pagebean);
    }

 实现类

@Override
    public List<Map> listMapPaper(Clazz clazz, PageBean pagebean) {
        if(true){
            throw new RuntimeException("错误出现在 ClazzBizImpl.ListapPager...里");
 
        }
        return clazzmapper.listMapPaper(clazz);
    }

1）SpringMVC自带的简单异常处理器

package com.zking.oa.Excetion;

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ModelAndView;

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

/**
 * @author 锦鲤
 * @site www.lucy.com
 * @company xxx公司
 * @create  2022-08-22 19:49
 */
//第三个方法则注掉
@Component
public class GlobalhandlerExcetionResovler  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 exception=(GlobalException)e;
            mv.addObject("ex",exception.getMessage());
            mv.addObject("msg","全局异常，错误代码506");

        }
        else if( e instanceof  RuntimeException){
            RuntimeException exception=(RuntimeException)e;
            mv.addObject("ex",exception.getMessage());
            mv.addObject("msg","运行时异常，错误代码606");

        }

        return mv;
    }
}

 

<%--
  Created by IntelliJ IDEA.
  User: Administrator
  Date: 2022/8/22
  Time: 18:56
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    


        ${ex}
    

 

 

 

 2）通过HandlerExceptionResovler接口实现全局异常

package com.zking.oa.Excetion;
 
/**
 * @author 锦鲤
 * @site www.lucy.com
 * @company xxx公司
 * @create  2022-08-22 16:36
 */
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);
    }
}

 

异常处理器 GlobalExceptionHandler

@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;
    }
}

测试代码controller层的改变

 @ResponseBody

 

    @RequestMapping("/load")

    public Clazz load(HttpServletRequest req, Clazz clazz){

        if(clazz.getCid() != null){

            List lst = this.clazzBiz.listPager(clazz, null);

            if (true)

                throw new GlobalException("错误出现在 JsonController.load...");

            return lst.get(0);

        }

        return null;

    }

 

 

   3)使用@ControllerAdvice+@ExceptionHandler实现全局异常

@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;
    }
}

 

 4）全局异常处理JSON返回

package com.zking.oa.Excetion;
 
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ModelAndView;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
/**
 * @author 锦鲤
 * @site www.lucy.com
 * @company xxx公司
 * @create  2022-08-22 19:10
 * 处理全局异常的解析器
 */
 
 
@ControllerAdvice
public class GlobalExceptionResolver implements HandlerExceptionResolver {
 
    /**
     *
     * @param httpServletRequest
     * @param httpServletResponse
     * @param o 目标对象
     * @param e 目标对象执行出现的异常
     * @return
     */
 
 
    @ExceptionHandler
    @Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest,
                                         HttpServletResponse httpServletResponse,
                                         Object o, Exception e) {
 
        ModelAndView mv=new ModelAndView();
        mv.setViewName("error");
        if(e instanceof GlobalException){
            GlobalException GlobalExcetion = (GlobalException) e;
            mv.addObject("ex",GlobalExcetion.getMessage());
            mv.addObject("msg","全局异常，错误代码503");
 
        }
        else if (e instanceof  RuntimeException){
            RuntimeException runtimeException = (RuntimeException) e;
            mv.addObject("ex",runtimeException.getMessage());
            mv.addObject("msg","全局异常，错误代码503");
 
        }
        return mv;
    }
}

 

效果图：

 

 

 

---