【Spring MVC学习笔记 五】SpringMVC框架整合Jackson工具

简介: 【Spring MVC学习笔记 五】SpringMVC框架整合Jackson工具

什么是JSON,JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式,目前使用特别广泛。采用完全独立于编程语言的文本格式来存储和表示数据。简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。易于人阅读和编写,同时也易于机器解析和生成,并有效地提升网络传输效率。

Json格式规则

从结构上看,所有的Json格式数据最终都可以分成三种类型:

  • 第一种类型是scalar(标量),也就是一个单独的string(字符串)或数字(numbers),比如"北京"这个单独的词
  • 第二种类型是sequence(序列),也就是若干个相关的数据按照一定顺序并列在一起,又叫做array(数组)或List(列表),比如["北京","天津"]
  • 第三种类型是mapping(映射),也就是一个名/值对(Name/value),即数据有一个名称,还有一个与之相对应的值,这又称作hash(散列)或dictionary(字典),比如{"城市名称":"北京"}

Json格式规则有如下几种:

  1. 并列的数据之间用逗号分隔
  2. 映射用冒号表示
  3. 并列数据的集合(数组)用方括号[]表示
  4. 映射的集合(对象)用大括号{}表示

我们为什么使用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,用法类似这里就不赘述 了。

相关文章
|
2天前
|
XML Java 程序员
Spring6框架中依赖注入的多种方式(推荐构造器注入)
依赖注入(DI)是一种过程,对象通过构造函数参数、工厂方法的参数或在对象实例构建后设置的属性来定义它们的依赖关系(即与其一起工作的其他对象)。
13 3
|
3天前
|
XML Java 测试技术
Spring框架
Spring框架
13 1
|
4天前
|
JavaScript 前端开发
1天搞定SpringBoot+Vue全栈开发 (5)Vue框架快速上手
1天搞定SpringBoot+Vue全栈开发 (5)Vue框架快速上手
|
4天前
|
XML Java 数据格式
Spring框架学习 -- Bean的生命周期和作用域
Spring框架学习 -- Bean的生命周期和作用域
16 2
|
4天前
|
存储 XML Java
Spring框架学习 -- 读取和存储Bean对象
Spring框架学习 -- 读取和存储Bean对象
13 0
Spring框架学习 -- 读取和存储Bean对象
|
4天前
|
XML Java Maven
Spring框架学习 -- 创建与使用
Spring框架学习 -- 创建与使用
14 0
|
4天前
|
存储 Java 应用服务中间件
Spring框架学习 -- 核心思想
Spring框架学习 -- 核心思想
17 0
|
13天前
|
开发框架 前端开发 .NET
ASP.NET CORE 3.1 MVC“指定的网络名不再可用\企图在不存在的网络连接上进行操作”的问题解决过程
ASP.NET CORE 3.1 MVC“指定的网络名不再可用\企图在不存在的网络连接上进行操作”的问题解决过程
50 0
|
13天前
|
开发框架 前端开发 JavaScript
JavaScript云LIS系统源码ASP.NET CORE 3.1 MVC + SQLserver + Redis医院实验室信息系统源码 医院云LIS系统源码
实验室信息系统(Laboratory Information System,缩写LIS)是一类用来处理实验室过程信息的软件,云LIS系统围绕临床,云LIS系统将与云HIS系统建立起高度的业务整合,以体现“以病人为中心”的设计理念,优化就诊流程,方便患者就医。
27 0
|
9月前
|
存储 开发框架 前端开发
[回馈]ASP.NET Core MVC开发实战之商城系统(五)
经过一段时间的准备,新的一期【ASP.NET Core MVC开发实战之商城系统】已经开始,在之前的文章中,讲解了商城系统的整体功能设计,页面布局设计,环境搭建,系统配置,及首页【商品类型,banner条,友情链接,降价促销,新品爆款】,商品列表页面,商品详情等功能的开发,今天继续讲解购物车功能开发,仅供学习分享使用,如有不足之处,还请指正。
127 0