目录
1.1.
1.2.1.什么是Jackson
Jackson是一个流行的Java库，用于处理JSON格式数据的序列化和反序列化。它提供了一组简单易用的API，可以方便地将Java对象与JSON数据进行转换。
1.2.2 常用注解
在使用Jackson进行JSON序列化和反序列化时，可以使用一些常用的注解来控制转换过程。例如：
@JsonFormat 指定序列化日期/时间值时的格式
@JsonIgnore 作用在字段或方法上，用来完全忽略被注解的字段和方法对应的属性
1.2.3Jackson具有以下特点和优势：
高性能：Jackson是一个高性能的JSON处理库，它使用了一些优化技术，如流式处理和基于缓冲区的读写，以提供非常快速的JSON序列化和反序列化性能。
灵活性：Jackson提供了多种转换策略和配置选项，可以根据需要进行灵活的定制。它支持对Java对象的字段级别的映射、支持不同的日期格式、支持多态类型处理等。
支持注解：Jackson支持使用注解来定制JSON序列化和反序列化的行为。通过在Java对象上添加注解，可以指定字段的名称、序列化的顺序、忽略某些字段等。
多种数据格式支持：除了JSON，Jackson还支持其他多种数据格式的处理，包括XML、YAML等。它可以方便地将Java对象转换为这些格式，或者将这些格式的数据转换为Java对象。
广泛应用：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>演示如何使用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.实例：
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>
效果：
创建一个名为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;
}
}效果：
创建一个名为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());
}
}
}效果：
