什么是JSON? 以及jackson的使用

最新推荐文章于 2024-03-17 19:29:48 发布

pdh慎行

最新推荐文章于 2024-03-17 19:29:48 发布

阅读量450

点赞数

分类专栏： #SSM 文章标签： java spring

本文链接：https://blog.csdn.net/qq_37975919/article/details/113614968

版权

#SSM 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

1、题外话

前后端分离时代

后端部署后端，提供接口，提供数据
json
前端独立部署，负责渲染后端的数据

2、什么是JSON

JSON(JavaScript Object Notation, JS对象标记)是一种轻量级的数据交换格式，目前使用特别广泛。

●采用完全独立于编程语言的文本格式来存储和表示数据。
●简洁和清晰的层次结构使得JSON成为理想的数据交换语言。
●易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。

在JavaScript语言中，一切都是对象。因此，任何JavaScript 支持的类型都可以通过JSON来表示，例如字符串、数字、对象、数组等。看看他的要求和语法格式:

●对象表示为键值对，数据由逗号分隔
●花括号保存对象
●方括号保存数组

JSON键值对是用来保存JavaScript对象的一种方式，和JavaScript对象的写法也大同小异，键/值对组合中的键名写在前面并用双引号""包裏，使用冒号:分隔，然后紧接着值:

{“name”: “QinJiang”}
{“age”: “3” }
{“sex”: “男”}

●JSON是JavaScript对象的字符串表示法，它使用文本表示一个JS对象的信息，本质是一个字符串。

var obj = {a: ‘Hello’, b: ‘World’}; //这是一个对象，注意键名也是可以使用引号包裹的
var json = ‘{“a”: “Hello", “b”: “World”}’; //这是一个JSON 字符串，本质是:一个字符串

JSON和JavaScript对象互转

●要实现从JSON字符串转换为JavaScript对象，使用JSON.parse()方法:

var obj = JSON.parse(’{“a”: “He1lo”,“b”: “World”}’);
//结果是{a: ‘Hello’,b: ‘World’}

●要实现从JavaScript对象转换为JSON字符串，使用JSON.stringify() 方法:

var json = JSON.stringify({a: ‘Hello’, b: ‘World’});
//结果是’{“a”: “Hello”, "b”: “World”}

3、Controller返回JSON数据

3.1 jackson的使用

●Jackson应该是目前比较好的json解析工具了
●当然工具不止这一个，比如还有阿里巴巴的fastjson等等。
●使用Jackson，需要导入它的jar包;

（1）在pom.xml中导入它的依赖

<dependencies>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.11.4</version>
        </dependency>
		<dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.10</version>
        </dependency>
    </dependencies>

（2）配置web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd"
         version="5.0">

    <!--1 配置DispatcherServlet，这个是SpringMVC的核心：请求分发器，前端控制器-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--关联一个spring的配置文件: [servlet-name]-servlet.xmL-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <!--/匹配所有的请求: (不包括.jsp) -->
    <!--/*匹配所有的请求; (包括.jsp) -->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!--2.配置SpringMVC的乱码过滤-->
    <filter>
        <filter-name>encoding</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

</web-app>

(3)新建并配置关联的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
       https://www.springframework.org/schema/mvc/spring-mvc.xsd">

	<!--自动扫描指定的包，下面所有注解类交给IOC容器管理-->
    <context:component-scan base-package="com.kuang.controller"/>
    <mvc:default-servlet-handler/>
    <mvc:annotation-driven />

    <!-- 视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          id="internalResourceViewResolver" >
        <property name="prefix" value="/WEB-INF/jsp/" />
        <property name="suffix" value=".jsp" />
    </bean>
</beans>

（4）我们随便编写一个User的实体类，然后我们去编写我们的测试Controller

package com.kuang.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data	//等同于getter and Setter
@AllArgsConstructor	//生成带参构造器
@NoArgsConstructor	//生成无参构造器
public class User {
    private int id;
    private String name;
    private int age;
}

（5）测试Controller类

下述代码返回的是一个user对象的字符串格式。User( id=3, name=??1?,age= 19)

package com.kuang.controller;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.kuang.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class UserController {

    @RequestMapping("/j1")
    @ResponseBody   //他就不会走视图解析器，会直接返回一个字符串
    public String json1()  {
        //创建一个对象
        User user = new User(3,"秦疆1号",19);
        return user.toString();
    }
}

下述代码返回的则是一个Json格式{“id”:3,“name”:"??1?",“age”:19}

package com.kuang.controller;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.kuang.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
public class UserController {

    @RequestMapping("/j1")
    @ResponseBody   //他就不会走视图解析器，会直接返回一个字符串
    public String json1() throws JsonProcessingException {
        //jackson,ObjectMapper
        ObjectMapper mapper = new ObjectMapper();
        //创建一个对象
        User user = new User(3,"秦疆1号",19);
        String str = mapper.writeValueAsString(user);
        return str;
        //return user.toString();
    }
}

（6）HTTP Status 500 - Servlet.init() for servlet springmvc threw exception

type ：Exception report
message ：Servlet.init() for servlet springmvc threw exception
description： The server encountered an internal error that prevented it from fulfilling this request.

root cause

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'userController': Lookup method resolution failed; nested exception is java.lang.IllegalStateException: Failed to introspect Class [com.kuang.controller.UserController] from ClassLoader [WebappClassLoader

java.lang.IllegalStateException: Failed to introspect Class [com.kuang.controller.UserController] from ClassLoader [WebappClassLoader

java.lang.NoClassDefFoundError: com/fasterxml/jackson/core/JsonProcessingException

试试关于java.lang.NoClassDefFoundError: com/fasterxml/jackson/core/JsonProcessingException解决方法
以及记 Idea lib导包，500 错误_波拿巴的博客-CSDN博客
我是根据第二篇博文解决的，我修改了pom.xml中的依赖为

<dependencies>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.11.4</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.11.4</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.11.4</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.10</version>
        </dependency>
    </dependencies>

然后重新在 lib下加入，好了之后再启动的tomcat就可以了

(7)发现出现了乱码问题

乱码是因为，它只是将字符串输出到当前页面，没有通过向前端发送请求，也没有过视图解析器，自然也就没有走srpingmvc配置文件中的乱码过滤步骤。

我们需要设置一下他的编码格式为utf-8, 以及它返回的类型;
通过**@ RequestMaping的produces属性**来实现，修改下代码

@Controller
public class UserController {

    @RequestMapping(value = "/j1",produces = "application/json;charset=utf-8")
    @ResponseBody   //他就不会走视图解析器，会直接返回一个字符串
    public String json1() throws JsonProcessingException {
        //jackson,ObjectMapper
        ObjectMapper mapper = new ObjectMapper();
        //创建一个对象
        User user = new User(3,"秦疆1号",19);
        String str = mapper.writeValueAsString(user);
        return str;
        //return user.toString();
    }
}

结果：
在这里插入图片描述
上一种方法比较麻烦，如果项目中有许多请求则每一个都要添加，可以通过Spring配置统一指定，这样就不用每次都去处理了!
在springmvc的配置文件上添加一段消息StringHttpMessageConverter转换配置!

<!--JSON乱码问题配置-->
    <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>

重启一下再看效果就对了
在这里插入图片描述

（8）返回集合

//返回一个集合
    @RequestMapping("/j2")
    public String json2() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();

        ArrayList<Object> list = new ArrayList<>();

        User user1 = new User(3,"秦疆1号",19);
        User user2 = new User(3,"秦疆1号",19);
        User user3 = new User(3,"秦疆1号",19);
        User user4 = new User(3,"秦疆1号",19);

        list.add(user1);
        list.add(user2);
        list.add(user3);
        list.add(user4);

        String str = mapper.writeValueAsString(list);
        return str;
    }

效果：
在这里插入图片描述

（9）返回时间戳

@RequestMapping("/j3")
    public String json3() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        // objectMapper, 时间解析后的默认格式为: Timestamp(时间戳)
        Date date = new Date();
        return mapper.writeValueAsString(date);
    }

@RequestMapping("/j3")
    public String json3() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        // objectMapper, 时间解析后的默认格式为: Timestamp(时间戳)
        Date date = new Date();
        //自定义日期格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss" ) ;
        return mapper.writeValueAsString(sdf.format(date));
    }

@RequestMapping("/j3")
    public String json3() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        // objectMapper, 时间解析后的默认格式为: Timestamp(时间戳)
        //不使用时间戳的方式，
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
        //自定义日期格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss" ) ;
        mapper.setDateFormat(sdf);
        Date date = new Date();
        return mapper.writeValueAsString(date);
    }

抽取为JSON工具类

public class JsonUtils {
    public static String getJson(Object object){
        return getJson(object,"yyyy-MM-dd HH:mm:ss");
    }
    
    public static String getJson(Object object, String dateFormat){
        ObjectMapper mapper = new ObjectMapper();
        //不使用时间戳的方式，
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
        //自定义日期格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss" ) ;
        mapper.setDateFormat(sdf);
        try {
            return mapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;
    }