6 JSON-有解無憂

6 JSON

什么使 JSON ？

JSON(JavaScript Object Notation, JS 物件標記) 是一種輕量級的資料交換格式，目前使用特別廣泛；
采用完全獨立于編程語言的文本格式來存盤和表示資料，
簡潔和清晰的層次結構使得 JSON 成為理想的資料交換語言，
易于人閱讀和撰寫，同時也易于機器決議和生成，并有效地提升網路傳輸效率，

在 JavaScript 語言中，一切都是物件，因此，任何JavaScript 支持的型別都可以通過 JSON 來表示，例如字串、數字、物件、陣列等：

物件表示為鍵值對，資料由逗號分隔
花括號保存物件
方括號保存陣列

JSON 鍵值對是用來保存 JavaScript 物件的一種方式，和 JavaScript 物件的寫法也大同小異，鍵/值對組合中的鍵名寫在前面并用雙引號 "" 包裹，使用冒號 : 分隔，然后緊接著值：

{"name": "Zzb"}
{"age": "1"}
{"sex": "男"}

JSON 是 JavaScript 物件的字串表示法，它使用文本表示一個 JS 物件的資訊，本質是一個字串，

var obj = {a: 'Hello', b: 'World'}; //這是一個物件，注意鍵名也是可以使用引號包裹的
var json = '{"a": "Hello", "b": "World"}'; //這是一個 JSON 字串，本質是一個字串

JSON 和 JavaScript 物件互轉

JSON ——> JavaScript

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

JavaScript ——> JSON

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

測驗

1、新建module：springmvc-05-json，添加web支持！

2、在web目錄下，新建一個jsonTest1.html，撰寫測驗內容：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>JsonTest</title>
</head>
<body>

<script type="text/javascript">
    //撰寫一個js的物件
    var user = {
        name:"Zzb",
        age:1,
        sex:"男"
    };
    //將js物件轉換成json字串
    var str = JSON.stringify(user);
    console.log(str);

    //將json字串轉換為js物件
    var user2 = JSON.parse(str);
    console.log(user2)
    console.log(user2.age,user2.name,user2.sex);

</script>

</body>
</html>

在網頁中打開，測驗結果為：

Controller 回傳 JSON 資料

決議工具有：Jackson、fastjson

Jackson

1、匯入相關jar包

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

2、配置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 配置DispatcherServlet-->
    <servlet>
        <servlet-name>DispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <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>
    <servlet-mapping>
        <servlet-name>DispatcherServlet</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>

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.zzb.controller"/>
    <!--讓Spring MVC不處理靜態資源，例如.mp3 .css .jpg等不走視圖決議器-->
    <mvc:default-servlet-handler/>
    <!--
       支持mvc注解驅動
       在spring中一般采用@RequestMapping注解來完成映射關系
       要想使@RequestMapping注解生效
       必須向背景關系中注冊DefaultAnnotationHandlerMapping
       和一個AnnotationMethodHandlerAdapter實體
       這兩個實體分別在類級別和方法級別處理，
       而annotation-driven配置幫助我們自動完成上述兩個實體的注入
    -->
    <mvc:annotation-driven/>

    <!--視圖決議器-->
    <bean  id="internalResourceViewResolver">
        <!--前綴-->
        <property name="prefix" value="https://www.cnblogs.com/WEB-INF/jsp/"/>
        <!--后綴-->
        <property name="suffix" value="https://www.cnblogs.com/zzbstudy/archive/2020/12/17/.jsp"/>
    </bean>

</beans>

4、物體類

package com.zzb.pojo;

public class User {

    private String name;
    private int age;
    private String sex;

    public User() {
    }

    public User(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
}

5、撰寫Controller

package com.zzb.controller;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.zzb.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("/json1")
    @ResponseBody // 該注解宣告回傳結果是回應體，不會走視圖決議器
    public String jsonTest1() throws JsonProcessingException {
        // 創建一個jackson的物件映射器，用來決議資料
        ObjectMapper mapper = new ObjectMapper();
        // 創建一個物件
        User user = new User("Zzb1號", 1, "男");
        String str = mapper.writeValueAsString(user);
        return str;
    }
}

6、配置Tomcat，注意專案中添加lib檔案，并在其中添加依賴！

測驗：

出現亂碼問題！

需要設定一下編碼格式（utf-8），以及回傳的型別！

通過@RequestMaping的produces屬性來實作，修改下代碼

//produces:指定回應體回傳型別和編碼
@RequestMapping(value = "https://www.cnblogs.com/json1",produces = "application/json;charset=utf-8")

亂碼問題解決！

代碼優化

亂碼統一解決

每次使用上述方法解決亂碼問題比較麻煩，可以通過Spring配置統一指定！在springmvc的核心組態檔中添加StringHttpMessageConverter轉換配置！

    <mvc:annotation-driven>
        <mvc:message-converters register-defaults="true">
            <bean >
                <constructor-arg value="https://www.cnblogs.com/zzbstudy/archive/2020/12/17/UTF-8"/>
            </bean>
            <bean >
                <property name="objectMapper">
                    <bean >
                        <property name="failOnEmptyBeans" value="https://www.cnblogs.com/zzbstudy/archive/2020/12/17/false"/>
                    </bean>
                </property>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>

回傳回應體

    @RequestMapping("/json1")
    @ResponseBody // 該注解宣告回傳結果是回應體，不會走視圖決議器
	@RestController // 可以在類上直接使用該注解，該類的所有方法都只會回傳回應體，不需要每個方法都添加 @ResponseBody 注解

測驗：

集合轉JSON

添加類方法

    @RequestMapping("/json2")
    public String jsonTest2() throws JsonProcessingException {
        // 創建一個jackson的物件映射器，用來決議資料
        ObjectMapper mapper = new ObjectMapper();
        // 創建一個物件
        User user1 = new User("Zzb1號", 1, "男");
        User user2 = new User("Zzb2號", 2, "男");
        User user3 = new User("Zzb3號", 3, "男");
        User user4 = new User("Zzb4號", 4, "男");

        List<User> list = new ArrayList<User>();
        list.add(user1);
        list.add(user2);
        list.add(user3);
        list.add(user4);

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

測驗：

輸出時間物件

public String jsonTest3() throws JsonProcessingException {
    // 創建一個jackson的物件映射器，用來決議資料
    ObjectMapper mapper = new ObjectMapper();

    // 創建一個時間物件
    Date date = new Date();

    // 顯示結果為時間戳
    String str = mapper.writeValueAsString(date);
    return str;
}

測驗：

默認日期格式會變成一個數字，是1970年1月1日到當前日期的毫秒數！
Jackson 默認是會把時間轉成timestamps形式

自定義時間格式

    @RequestMapping("/json4")
    public String jsonTest4() throws JsonProcessingException {
        // 創建一個jackson的物件映射器，用來決議資料
        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;
    }

測驗：

抽取為工具類

將JSON的轉換封裝成工具類

package com.zzb.utils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

import java.text.SimpleDateFormat;

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){
        // 創建一個jackson的物件映射器，用來決議資料
        ObjectMapper mapper = new ObjectMapper();
        // 不使用時間戳的方式
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        // 自定義時間格式
        SimpleDateFormat sdf = new SimpleDateFormat("dateFormat");
        // 設定時間格式
        mapper.setDateFormat(sdf);

        // 顯示結果為時間戳
        String str = null;
        try {
            str = mapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return str;
    }
}

使用工具類撰寫代碼

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

測驗：

FastJson

FastJson 由阿里巴巴開發，專門用于java的包，可以方便的實作json物件與JavaBean物件的轉換，實作JavaBean物件與json字串的轉換，實作json物件與json字串的轉換，實作json的轉換方法很多，最后的實作結果都是一樣的，

jar包

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

FastJson 三個主要的類：

JSONObject 代表 json 物件

JSONObject實作了Map介面, JSONObject底層操作是由Map實作的，
JSONObject對應json物件，通過各種形式的get()方法可以獲取json物件中的資料，也可利用諸如size()，isEmpty()等方法獲取"鍵：值"對的個數和判斷是否為空，其本質是通過實作Map介面并呼叫介面中的方法完成的，

JSONArray 代表 json 物件陣列

內部是有List介面中的方法來完成操作的，

JSON代表 JSONObject和JSONArray的轉化

仔細觀察這些方法，主要是實作json物件，json物件陣列，javabean物件，json字串之間的相互轉化，

代碼測驗：

package com.zzb.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.zzb.pojo.User;

import java.util.ArrayList;
import java.util.List;

public class FastJsonTest {

    public static void main(String[] args) {
        // 創建物件
        User user1 = new User("Zzb1號", 1, "男");
        User user2 = new User("Zzb2號", 2, "男");
        User user3 = new User("Zzb3號", 3, "男");
        User user4 = new User("Zzb4號", 4, "男");

        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("java -> json (list)" + str1);
        String str2 = JSON.toJSONString(user1);
        System.out.println("java -> json (user1)" + str1);

        System.out.println("json字串轉java物件");
        User jUser1 = JSON.parseObject(str2, User.class);
        System.out.println("jUser1" + jUser1.toString());

        System.out.println("java物件轉json物件");
        JSONObject jsonObject1 = (JSONObject) JSON.toJSON(user2);
        System.out.println("JSONObject (user2)" + jsonObject1.getString("name"));

        System.out.println("json物件轉java物件");
        User jUser2 = JSON.toJavaObject(jsonObject1, User.class);
        System.out.println("jUser2 :" + jUser2.toString());
    }
}

測驗結果：

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/236399.html

標籤：其他

上一篇：C/C++學習筆記：基本運算子和運算式大全，案例演示詳解

下一篇：Erlang那些事兒之正兒八經的前言