什么是JSON，JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式，目前使用特别广泛。采用完全独立于编程语言的文本格式来存储和表示数据。简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。
Json格式规则
从结构上看，所有的Json格式数据最终都可以分成三种类型：
- 第一种类型是scalar（标量），也就是一个单独的string（字符串）或数字（numbers），比如
"北京"这个单独的词 - 第二种类型是sequence（序列），也就是若干个相关的数据按照一定顺序并列在一起，又叫做array（数组）或List(列表)，比如
["北京"，"天津"] - 第三种类型是mapping（映射），也就是一个名/值对（Name/value），即数据有一个名称，还有一个与之相对应的值，这又称作hash（散列）或dictionary（字典），比如
{"城市名称"："北京"}
Json格式规则有如下几种：
- 并列的数据之间用逗号
，分隔 - 映射用冒号
：表示 - 并列数据的集合（数组）用方括号
[]表示 - 映射的集合（对象）用大括号
{}表示
我们为什么使用Json格式呢，因为目前大多数项目都是前后端分离的，而前后端要交互的数据格式用JSON最好了，简单易懂，而在SpringMVC中使用Json格式比较好的一个工具就是Jackson。
Jackson使用实践
接下来我们实践一下Jackson的使用。
1 新建一个项目
首先我们新建一个Jackson的SpringMVC项目
配置pom.xml引入Jackson依赖：
<!--https://mvnrepository.com/仓库获取的最新包 20210831--> <dependencies> <!-- jackson包引入--> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.12.1</version> </dependency> <!--Spring MVC框架依赖--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.3.9</version> </dependency> <!--JSP相关依赖--> <dependency> <groupId>javax.servlet.jsp</groupId> <artifactId>jsp-api</artifactId> <version>2.2</version> </dependency> <dependency> <groupId>javax.servlet</groupId> <artifactId>jstl</artifactId> <version>1.2</version> </dependency> <!--servlet相关依赖--> <dependency> <groupId>javax.servlet</groupId> <artifactId>javax.servlet-api</artifactId> <version>4.0.1</version> <scope>provided</scope> </dependency> <!--单元测试相关依赖--> <dependency> <groupId>org.junit.jupiter</groupId> <artifactId>junit-jupiter-api</artifactId> <version>${junit.version}</version> <scope>test</scope> </dependency> <dependency> <groupId>org.junit.jupiter</groupId> <artifactId>junit-jupiter-engine</artifactId> <version>${junit.version}</version> <scope>test</scope> </dependency> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>RELEASE</version> <scope>compile</scope> </dependency> </dependencies>
2 创建Model类
我们创建一个Model类，这个Model类就是要返回给前端的VO
package com.example.jackson.model; import lombok.Data; import java.util.Date; /** * * @Name User * * @Description * * @author tianmaolin * * @Data 2021/9/9 */ @Data public class User { private String username; private int age; private String hobby; private Date birthday; }
3 编写控制器Controller
我们需要编写一个控制器，注意控制器可以使用注解@RestController来标明所有返回的数据都将被序列化为Json格式：
package com.example.jackson.controller; import com.example.jackson.model.User; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Date; import java.util.List; /** * * @Name UserController * * @Description * * @author tianmaolin * * @Data 2021/9/9 */ @RestController @RequestMapping("/user") public class UserController { @RequestMapping("/getUserInfo") public String getUserInfo() throws JsonProcessingException { //创建一个jackson的对象映射器，用来解析数据 ObjectMapper mapper = new ObjectMapper(); //自定义日期格式对象 SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); //指定日期格式 mapper.setDateFormat(simpleDateFormat); List<User> userList = new ArrayList<>(); //创建一个对象 User user1 = new User(); user1.setUsername("tml"); user1.setAge(39); user1.setHobby("跑步"); user1.setBirthday(new Date()); userList.add(user1); //创建一个对象 User user2 = new User(); user2.setUsername("gcy"); user2.setAge(18); user2.setHobby("跳舞"); user2.setBirthday(new Date()); userList.add(user2); //将我们的对象解析成为json格式 String jsonStr = mapper.writeValueAsString(userList); //由于@RestController注解，这里会将str转成json格式返回，十分方便 return jsonStr; } }
4 注册DispatcherServlet
接着是我们的传统艺能，注册SpringMVC过滤器来拦截请求
<?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" version="4.0"> <!--配置前端控制器--> <servlet> <!--1.注册DispatcherServlet--> <servlet-name>springMVC</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <!--通过初始化参数指定SpringMVC配置文件的位置，进行关联--> <init-param> <param-name>contextConfigLocation</param-name> <!--关联一个springMVC的配置文件:【servlet-name】-servlet.xml--> <param-value>classpath:springmvc-servlet.xml</param-value> </init-param> <!--启动级别-1,在Tomcat启动时就初始化Spring容器--> <load-on-startup>1</load-on-startup> </servlet> <!--/ 匹配所有的请求；（不包括.jsp）--> <!--/* 匹配所有的请求；（包括.jsp）--> <servlet-mapping> <servlet-name>springMVC</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> </web-app>
5 编写springmvc-servlet.xml配置文件
编写springmvc-servlet.xml文件，并且在这里加一部分配置让返回的数据不会乱码。
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd"> <!-- 自动扫描包，让指定包下的注解生效,由IOC容器统一管理 --> <context:component-scan base-package="com.example.jackson.controller"/> <!-- 让Spring MVC不处理静态资源 --> <mvc:default-servlet-handler /> <!-- 支持mvc注解驱动 在spring中一般采用@RequestMapping注解来完成映射关系 要想使@RequestMapping注解生效 必须向上下文中注册DefaultAnnotationHandlerMapping 和一个AnnotationMethodHandlerAdapter实例 这两个实例分别在类级别和方法级别处理。 而annotation-driven配置帮助我们自动完成上述两个实例的注入。 --> <mvc:annotation-driven /> <!--视图解析器--> <!--通过视图解析器解析处理器返回的逻辑视图名并传递给DispatcherServlet--> <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver"> <!--前缀--> <property name="prefix" value="/WEB-INF/jsp/"/> <!--后缀--> <property name="suffix" value=".jsp"/> </bean> <mvc:annotation-driven> <mvc:message-converters register-defaults="true"> <bean class="org.springframework.http.converter.StringHttpMessageConverter"> <constructor-arg value="UTF-8"/> </bean> <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"> <property name="objectMapper"> <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean"> <property name="failOnEmptyBeans" value="false"/> </bean> </property> </bean> </mvc:message-converters> </mvc:annotation-driven> </beans>
6 配置Tomcat服务器并测试
最后我们配置并启动Tomcat服务器来测试：
在浏览器中输入：http://localhost:8080/jackson/user/getUserInfo，返回结果为：
常用的工具类JsonUtil
其实我们一般会将Jackson封装为常用的工具类去使用：
@Slf4j public class JsonUtil { private static final String STANDARD_PATTERN = "yyyy-MM-dd HH:mm:ss"; private static final String DATE_PATTERN = "yyyy-MM-dd"; private static final String TIME_PATTERN = "HH:mm:ss"; @Getter private static ObjectMapper objectMapper = new ObjectMapper(); static { objectMapper.setPropertyNamingStrategy(PropertyNamingStrategy.LOWER_CAMEL_CASE); //时区 objectMapper.setTimeZone(TimeZone.getTimeZone("GMT+8")); // 初始化JavaTimeModule JavaTimeModule javaTimeModule = new JavaTimeModule(); // 处理LocalDateTime DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(STANDARD_PATTERN); javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(dateTimeFormatter)); javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(dateTimeFormatter)); // 处理LocalDate DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern(DATE_PATTERN); javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer(dateFormatter)); javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer(dateFormatter)); // 处理LocalTime DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern(TIME_PATTERN); javaTimeModule.addSerializer(LocalTime.class, new LocalTimeSerializer(timeFormatter)); javaTimeModule.addDeserializer(LocalTime.class, new LocalTimeDeserializer(timeFormatter)); // 注册时间模块, 支持支持jsr310, 即新的时间类(java.time包下的时间类) objectMapper.registerModule(javaTimeModule); // 包含所有字段 objectMapper.setSerializationInclusion(JsonInclude.Include.ALWAYS); // 在序列化一个空对象时时不抛出异常 objectMapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS); // 忽略反序列化时在json字符串中存在, 但在java对象中不存在的属性 objectMapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES); } /** * 对象转Json格式 */ public static <T> String objToJson(T obj) { if (obj == null) { return null; } try { return obj instanceof String ? (String) obj : objectMapper.writeValueAsString(obj); } catch (Exception e) { LOGGER.warn("obj To json is error", e); return null; } } /** * 集合转Json格式 */ public static <T> String arrayToJson(Collection<T> list) { try { return objectMapper.writeValueAsString(list); } catch (Exception e) { LOGGER.warn("list To json is error", e); return "[]"; } } /** * Json格式转对象 */ public static <T> T json2Object(String json, Class<T> clazz) { if (StringUtils.isEmpty(json) || clazz == null) { return null; } try { return clazz.equals(String.class) ? (T) json : objectMapper.readValue(json, clazz); } catch (Exception e) { LOGGER.warn("json To obj is error", e); return null; } } /** * Json格式转对象 */ public static <T> T convertObject(Object fromValue, Class<T> clazz) throws IllegalArgumentException { if (fromValue == null || clazz == null) { return null; } try { return objectMapper.convertValue(fromValue, clazz); } catch (Exception e) { LOGGER.warn("convertObject is error", fromValue, e); return null; } } /** * Json格式转对象 * 通过 TypeReference 处理List<User>这类多泛型问题 */ public static <T> T json2Object(String json, TypeReference<T> typeReference) { if (StringUtils.isEmpty(json) || typeReference == null) { return null; } try { return (T) (typeReference.getType().equals(String.class) ? json : objectMapper.readValue(json, typeReference)); } catch (Exception e) { LOGGER.warn("json To obj is error", e); return null; } } /** * Json格式转对象 * 通过jackson 的javatype 来处理多泛型的转换 */ public static <T> T json2Object(String json, Class<?> collectionClazz, Class<?>... elements) { JavaType javaType = objectMapper.getTypeFactory().constructParametricType(collectionClazz, elements); try { return objectMapper.readValue(json, javaType); } catch (Exception e) { LOGGER.warn("json To obj is error", e); return null; } } }
总结一下
Jackson比较简单，就是一个处理Json交互的框架而已，但是在面对前后端分离这种开发模式的时候它却可以帮大忙，对于各种格式也能很好的兼容，还记得我之前的一篇Blog聊到了返回的各种Model格式，那都是对于前后端我们都一起开发的策略，对于前后端分离的开发模式，我们返回给前端同学的数据一定是序列化好的Json串，同样他们传递给我们的Body请求也是同理，这样有了一种契约后，双方就可以各自为战，以约定好的入参和返回值同时开发了，当然除了Jackson还有别的优秀的类似框架，例如FastJson，用法类似这里就不赘述 了。
