SpringMVC（四）——JSON交互处理

其他 2021-03-08 20:19
0 阅读

文章目录

1、什么是JSON？

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

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

语法格式
（1）对象表示键值对，由逗号隔开
（2）花括号保存对象
（3）方括号保存数组

例子：{“键” : “值”}

{
    
    "name": "QinJiang"}
{
    
    "age": "3"}
{
    
    "sex": "男"}

很多人搞不清楚JSON和JavaScript的关系，其实可以这么理解：JSON是JavaScript的字符串表示法，它使用文本表示一个JS对象的信息，本质是一个字符串。

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

JSON和JavaScript对象互转
（1）从JSON字符串转换为JavaScript对象，使用JSON.parse（）方法；

var obj = JSON.parse('{"a": "Hello", "b": "World"}');
//结果是 {a: 'Hello', b: 'World'}

（2）从JavaScript对象转换为JSON字符串，使用JSON.stringify（）方法

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

代码测试

1、新建一个Module，srpingmvc05-json，添加web支持

2、在web目录下新建一个json-01.html，编写测试内容

扫描二维码关注公众号，回复： 12727460 查看本文章 
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <script type="text/javascript">
        // 编写一个js的对象
        let user ={
     
     
            name:"陈志辉",
            age:18,
            sex:"男"
        }
        // 将js对象转换为JSON字符串
        let str = JSON.stringify(user);
        console.log(str);

        // 将JSON字符串转化为js对象
        let user2 = JSON.parse(str);
        console.log(user2.age,user2.name,user2.sex);
    </script>
</body>
</html>

3、直接用浏览器打开，按F12查看控制台输出
在这里插入图片描述

2、Controller返回JSON数据

Jackson是目前比较交的json解析工具，还有阿里巴巴的fastjson等，这里我们使用jackson，首先导入它的jar包

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.10.3</version>
</dependency>

1、配置web.xml

<?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"
        xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
        version="4.0">

   <!--1.注册servlet-->
   <servlet>
       <servlet-name>SpringMVC</servlet-name>
       <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
       <!--通过初始化参数指定SpringMVC配置文件的位置，进行关联-->
       <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>

   <!--所有请求都会被springmvc拦截 -->
   <servlet-mapping>
       <servlet-name>SpringMVC</servlet-name>
       <url-pattern>/</url-pattern>
   </servlet-mapping>

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

2、配置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="chen.controller"/>

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

</beans>

3、编写一个User实体类

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <script type="text/javascript">
        // 编写一个js的对象
        let user ={
    
    
            name:"陈志辉",
            age:18,
            sex:"男"
        }
        // 将js对象转换为JSON字符串
        let str = JSON.stringify(user);
        console.log(str);

        // 将JSON字符串转化为js对象
        let user2 = JSON.parse(str);
        console.log(user2.age,user2.name,user2.sex);
    </script>
</body>
</html>

4、编写Controller

@Controller
public class UserController {
    
    


    @RequestMapping("/json1")
    @ResponseBody
    public String json1() throws JsonProcessingException {
    
    
        ObjectMapper objectMapper = new ObjectMapper();

        User user = new User("陈志辉2",20,"男");

        String str = objectMapper.writeValueAsString(user);

        return str;
    }

}

5、配置Tomcat，启动测试！
在这里插入图片描述

所以我们设置

//produces:指定响应体返回类型和编码
@RequestMapping(value = "/json1",produces = "application/json;charset=utf-8")

在这里插入图片描述

3、代码优化

乱码统一解决

前面的那一种代码解决办法比较麻烦，如果有多个请求需要添加，那么我们可以通过Spring配置统一指定，这样就不用每次都去处理！

在springmvc的配置文件中，添加上：

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

接着我们可以直接在类上使用@RestController，这样的话所有的方法都只会返回json字符串，不用每个都添加@ResponseBody，我们在前后端开发中，一般都用@RestController，十分便捷！！

@RestController
public class UserController {
    
    


    @RequestMapping(value = "/json1")
    public String json1() throws JsonProcessingException {
    
    

                //创建一个jackson的对象映射器，用来解析数据
                ObjectMapper mapper = new ObjectMapper();
                //创建一个对象
                User user = new User("陈志辉2", 3, "男");
                //将我们的对象解析成为json格式
                String str = mapper.writeValueAsString(user);
                //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
                return str;

    }

}

成功！！
在这里插入图片描述

4、测试集合输出

增加一个新的方法

@RequestMapping("/json2")
public String json2() throws JsonProcessingException {
    
    

   //创建一个jackson的对象映射器，用来解析数据
   ObjectMapper mapper = new ObjectMapper();
   //创建一个对象
   User user1 = new User("志辉1号", 3, "男");
   User user2 = new User("志辉2号", 3, "男");
   User user3 = new User("志辉3号", 3, "男");
   User user4 = new User("志辉4号", 3, "男");
   List<User> list = new ArrayList<User>();
   list.add(user1);
   list.add(user2);
   list.add(user3);
   list.add(user4);

   //将我们的对象解析成为json格式
   String str = mapper.writeValueAsString(list);
   return str;
}

运行结果：十分完美，没有任何问题！
在这里插入图片描述

5、输出时间对象

新增一个方法

@RequestMapping("/json3")
public String json3() throws JsonProcessingException {
    
    

   ObjectMapper mapper = new ObjectMapper();

   //创建时间一个对象，java.util.Date
   Date date = new Date();
   //将我们的对象解析成为json格式
   String str = mapper.writeValueAsString(date);
   return str;
}

在这里插入图片描述

  • 默认的日期格式会是一个数字，是1970年1月1日到当前日期的毫秒数
  • Jackson默认是会把时间转成timestamps形式

解决方案：取消timestamps形式，自定义时间格式！！！

@RequestMapping("/json4")
public String json4() throws JsonProcessingException {
    
    

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

   Date date = new Date();
   String str = mapper.writeValueAsString(date);

   return str;
}

在这里插入图片描述

6、抽取为工具类

如果遇到经常要使用到的代码，我们可以将其封装到一个工具人中

编写JsonUtils.java类

public class JsonUtils {
    
    

    public static String getJson(Object object) throws JsonProcessingException {
    
    

        return getJson(object,"yyyy-MM-dd HH:mm:ss");
    }

    public static String getJson(Object object, String dateFormat) throws JsonProcessingException {
    
    

        ObjectMapper mapper = new ObjectMapper();
        //不使用时间差的方式
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
        //自定义日期格式对象
        SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
        //指定日期格式
        mapper.setDateFormat(sdf);

        return mapper.writeValueAsString(object);

    }

}

这样我们使用工具类，就可以使得代码更加简洁啦


@RequestMapping(value = "/j2")
// @ResponseBody//添加之后就不会走试图解析器，会直接返回一个字符串
public String test2() throws JsonProcessingException {
    
    

    ObjectMapper mapper = new ObjectMapper();
    ArrayList<User> users = new ArrayList<>();
    User user1 = new User("Tom1",13,"男");
    User user2 = new User("Tom2",13,"男");
    User user3 = new User("Tom3",13,"男");
    User user4 = new User("Tom4",13,"男");
    User user5 = new User("Tom5",13,"男");
    users.add(user);
    users.add(user2);
    users.add(user3);
    users.add(user4);
    users.add(user5);

    return JsonUtils.getJson(users);
}


@RequestMapping("/json5")
public String json5() throws JsonProcessingException {
    
    
   Date date = new Date();
   String json = JsonUtils.getJson(date);
   return json;
}

都能完美运行！！！

7、FastJson

fastjson.jar是阿里开发的一款专门用于Java开发的包，可以方便的实现json对象与JavaBean对象的转换，实现JavaBean对象与json字符串的转换，实现json对象与json字符串的转换。实现json转换的方法有很多，最后的实现结果都是一样的！

fastjson的pom依赖

<dependency>
   <groupId>com.alibaba</groupId>
   <artifactId>fastjson</artifactId>
   <version>1.2.60</version>
</dependency>

FastJson三个主要的类：

1、JSONObject代表json对象
（1）JSONObject实现了Map接口, 猜想 JSONObject底层操作是由Map实现的。
（2）JSONObject对应json对象，通过各种形式的get()方法可以获取json对象中的数据，也可利用诸如size()，isEmpty()等方法获取"键：值"对的个数和判断是否为空。其本质是通过实现Map接口并调用接口中的方法完成的。

2、JSONArray代表json对象数组
（1）内部是有lIst接口的方法来完成操作的。

3、JSON代表JSONObject和JSONArray的转化
（1）JSON类源码分析使用
（2）仔细观察这些方法，主要是实现json对象，json对象数组，javabean对象，json字符串之间的转化。

代码测试，新建一个FastJsonDemo类

public class FastJsonDemo {
    
    
   public static void main(String[] args) {
    
    
       //创建一个对象
       User user1 = new User("志辉1号", 3, "男");
       User user2 = new User("志辉2号", 3, "男");
       User user3 = new User("志辉3号", 3, "男");
       User user4 = new User("志辉4号", 3, "男");
       List<User> list = new ArrayList<User>();
       list.add(user1);
       list.add(user2);
       list.add(user3);
       list.add(user4);

       System.out.println("*******Java对象 转 JSON字符串*******");
       String str1 = JSON.toJSONString(list);
       System.out.println("JSON.toJSONString(list)==>"+str1);
       String str2 = JSON.toJSONString(user1);
       System.out.println("JSON.toJSONString(user1)==>"+str2);

       System.out.println("\n****** JSON字符串 转 Java对象*******");
       User jp_user1=JSON.parseObject(str2,User.class);
       System.out.println("JSON.parseObject(str2,User.class)==>"+jp_user1);

       System.out.println("\n****** Java对象 转 JSON对象 ******");
       JSONObject jsonObject1 = (JSONObject) JSON.toJSON(user2);
       System.out.println("(JSONObject) JSON.toJSON(user2)==>"+jsonObject1.getString("name"));

       System.out.println("\n****** JSON对象 转 Java对象 ******");
       User to_java_user = JSON.toJavaObject(jsonObject1, User.class);
       System.out.println("JSON.toJavaObject(jsonObject1, User.class)==>"+to_java_user);
  }
}

这种工具类，我们只需要掌握使用就好啦，在使用的时候再根据具体的业务去找对应的实现。和以前的commons-io那种工具包一样拿来用就行！

猜你喜欢

目录

热门文章