Javaweb基础之json

最新推荐文章于 2024-07-06 00:41:27 发布

教授.F

最新推荐文章于 2024-07-06 00:41:27 发布

阅读量334

点赞数 6

文章标签： json

本文链接：https://blog.csdn.net/FZYjiaoshou/article/details/138822100

版权

大家好，这里是教授.F

引入：

json就是前后端交互数据使用到的一种格式。

定义格式：

json规制：

字符串转json：

JSON.parse(string) 函数会返回对应的 json 对象, 并不会影响原来string.

json转字符串:

JSON.springify(json 对象) 会返回对应 string, 并不会影响原来json 对象, 演示json_string_detail.html

字符串和json转化细节：

1.在定义 Json 对象时, 可以使用 ' ' 表示字符串, 比如 var json_person = {"name": "jack", "age": 100}; 也可以写成 var json_person = {'name': 'jack', 'age': 100};

2、但是在把原生字符串转成 json 对象时, 必须使用 "", 否则会报错比如：var str_dog = "{'name':'小黄狗', 'age': 4}"; 转 json 就会报错

3、JSON.springify(json 对象) 返回的字符串, 都是 "" 表示的字符串, 所以在语法格式正确的情况下, 是可以重新转成 json 对象的

json在java中的使用:

1. java 中使用 json，需要引入到第 3 方的包 gson.jar

2. Gson 是 Google 提供的用来在 Java 对象和 JSON 数据之间进行映射的Java 类库。

3. 可以对 JSON 字符串和 Java 对象相互转换

应用实例：

JavaBean和json字符串的转换：

import com.fasterxml.jackson.databind.ObjectMapper;

public class Main {
    public static void main(String[] args) {
        // 创建一个Person对象
        Person person = new Person("John", 30);

        // 将Person对象转换为JSON字符串
        String json = convertObjectToJson(person);
        System.out.println("Person对象转换为JSON字符串:");
        System.out.println(json);

        // 将JSON字符串转换为Person对象
        Person personFromJson = convertJsonToObject(json, Person.class);
        System.out.println("\nJSON字符串转换为Person对象:");
        System.out.println("Name: " + personFromJson.getName());
        System.out.println("Age: " + personFromJson.getAge());
    }

    // 将JavaBean对象转换为JSON字符串
    public static String convertObjectToJson(Object object) {
        try {
            ObjectMapper mapper = new ObjectMapper();
            return mapper.writeValueAsString(object);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    // 将JSON字符串转换为JavaBean对象
    public static <T> T convertJsonToObject(String json, Class<T> valueType) {
        try {
            ObjectMapper mapper = new ObjectMapper();
            return mapper.readValue(json, valueType);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

list和json对象的转换：

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;

import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        // 创建一个Person列表
        List<Person> personList = new ArrayList<>();
        personList.add(new Person("John", 30));
        personList.add(new Person("Alice", 25));

        // 将List转换为JSON数组
        String jsonArray = convertListToJson(personList);
        System.out.println("List转换为JSON数组:");
        System.out.println(jsonArray);

        // 将JSON数组转换为List
        List<Person> personListFromJson = convertJsonToList(jsonArray);
        System.out.println("\nJSON数组转换为List:");
        for (Person person : personListFromJson) {
            System.out.println("Name: " + person.getName() + ", Age: " + person.getAge());
        }
    }

    // 将List转换为JSON数组
    public static String convertListToJson(List<?> list) {
        Gson gson = new Gson();
        return gson.toJson(list);
    }

    // 将JSON数组转换为List
    public static List<Person> convertJsonToList(String jsonArray) {
        Gson gson = new Gson();

        Type listType = new TypeToken<ArrayList<Person>>() {}.getType();
        return gson.fromJson(jsonArray, listType);
    }
}

补充：

    // gson需要得到类型的完整路径，然后进行底层反射
    // TypeToken()能得完整类型的路径
      
Type type = new TypeToken<List<Book>>(){}.getType();
    new TypeToken<List<Book>>()
    如果我们不加上{}，TypeToken调用的是TypeToken的无参构造器，但是TypeToken的无参构造器是所保护的。一个方法是protected，而且不在同一个包是不能直接访问的。
    那为什么加上了{}就能访问了呢？？？？
    这是因为涉及匿名内部类的知识。
    new TypeToken<List<Book>>(){}的类型就不是TypeToken，而是一个匿名内部类
    这个匿名内部类有自己的无参构造器（隐式），根据java基础规制，当执行子类的无参构造器时，默认super()

t1包
//A类
public class A{
   protected A(){
         System.out.println("aaaa");
    }
}

/*
    因为A类和Test不在同一个包，
    所以不能访问A类的protected方法，包括构造器
    A<String>(){}就是一个匿名内部类，可以理解是A类子类
    A<String>(){} 匿名内部类，有一个隐式的无参构造器，根据Java基础，
        无参构造器有默认super()
    当执行时，会调用A类的无参的protected构造器
    
*/

t2包
//Test类
public class Test{
    public static void main(String[] args){
        A a = new A(){};
        System.out.println("加上{}后就能用了");
    }
}

map和json的转换：

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;

import java.lang.reflect.Type;
import java.util.HashMap;
import java.util.Map;

public class MapJsonConverterWithTypeToken {
    private static final Gson gson = new Gson();

    // 将Map转换为JSON字符串
    public static String mapToJson(Map<String, Object> map) {
        Type type = new TypeToken<Map<String, Object>>() {}.getType();
        return gson.toJson(map, type);
    }

    // 将JSON字符串转换为Map
    public static Map<String, Object> jsonToMap(String json) {
        Type type = new TypeToken<Map<String, Object>>() {}.getType();
        return gson.fromJson(json, type);
    }

    public static void main(String[] args) {
        // 创建一个Map对象
        Map<String, Object> map = new HashMap<>();
        map.put("name", "John");
        map.put("age", 30);

        // 将Map转换为JSON字符串
        String json = mapToJson(map);
        System.out.println("Map转换为JSON字符串:");
        System.out.println(json);

        // 将JSON字符串转换为Map
        Map<String, Object> mapFromJson = jsonToMap(json);
        System.out.println("\nJSON字符串转换为Map:");
        for (Map.Entry<String, Object> entry : mapFromJson.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}