yxx-blog

Appearance

JSON转换 ​

FastJSON ​

FastJSON是阿里巴巴开发的一个Java语言实现的JSON解析器和生成器，它具有高性能、丰富功能、简单易用的API、自定义序列化和反序列化、支持标准规范、支持日期格式、兼容Java标准库中的JSON API以及广泛应用等特点

pom.xml

xml
            <!-- fastjson -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.66</version>
            </dependency>

方法：

  • 序列化对象为JSON字符串：toJSONString方法可以将Java对象序列化为JSON字符串

    • java
              // 序列化对象转为JSON字符串
        String jsonStr = JSON.toJSONString(jsonUser);
        System.out.println("对象转JSON打印：" + jsonStr);

  • 反序列化JSON字符串为对象：parseObject方法可以将JSON字符串反序列化为Java对象，也可以转为Map对象(指定类型需要使用TypeReference对象)

    • java
              // 反序列化JSON字符串为对象
        JsonUser jsonUser = JSON.parseObject(jsonString, JsonUser.class);
        System.out.println("JSON转对象打印：" + jsonUser);
  
        // 反序列化JSON字符串为原始Map
        Map map = JSON.parseObject(jsonString, Map.class);
        System.out.println(map.get("address"));
  
        // 指定Map类型转换
        Map<String, String> jsonMap = JSON.parseObject(jsonString, new TypeReference<Map<String, String>>() {});
        System.out.println("JSON转Map对象：" + jsonMap);
        Address address = JSON.parseObject(jsonMap.get("address"), Address.class);
        System.out.println("从Map对象中再获取到Address对象：" + address);
        // 借助TypeReference对象可以实现复杂转换
        // Map<String, List<JsonUser>> stringListMap = JSON.parseObject(jsonString, new TypeReference<Map<String, List<JsonUser>>>(){});
        // System.out.println(stringListMap);

  • JSON字符串解析为JSONObject：parseObject方法可以将JSON字符串解析为FastJSON的JSONObject对象，方便进行后续的操作

    • java
      JSONObject jsonObject = JSON.parseObject(jsonString);

// 获取字段name的值，返回String
String name = jsonObject.getString("name");
// 获取字段age的值，返回int
int age = jsonObject.getIntValue("age");

  • JSON字符串解析为Java集合：parseArray方法可以将JSON数组字符串解析为Java集合

    • java
      List<User> userList = JSON.parseArray(jsonArray, User.class);

处理枚举值 ​

序列化规则

  • 默认行为：使用name()方法

  • 使用ordinal()方法

  • 自定义序列化名称：在序列化时会优先尝试匹配注解中指定的name值

    • java
      public enum Status {
    @JSONField(name = "pending")
    PENDING,
    @JSONField(name = "approved")
    APPROVED,
    @JSONField(name = "rejected")
    REJECTED
}

Status status = Status.APPROVED;
String json = JSON.toJSONString(status); // 输出: "approved"

反序列化规则

  • 默认行为：匹配name()

  • 使用ordinal()方法

  • 匹配@JSONField：在反序列化时会优先尝试匹配注解中指定的name值

    • java
      public enum Status {
    @JSONField(name = "pending")
    PENDING,
    @JSONField(name = "approved")
    APPROVED,
    @JSONField(name = "rejected")
    REJECTED
}

String json = "\"approved\"";
Status status = JSON.parseObject(json, Status.class); // 成功反序列化为 Status.APPROVED

String jsonUpper = "\"APPROVED\"";
Status statusUpper = JSON.parseObject(jsonUpper, Status.class); // 失败！抛出异常（除非配置了大小写不敏感）

Jackson ​

Jackson在处理大型对象和复杂数据结构时通常表现更为优秀，在将Java对象序列化为JSON并存入Redis时，Jackson可能会提供更好的性能和效率

在处理枚举值方面和FastJSON默认行为保持一致

pom.xml

xml
        <!-- jackson -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.13.0</version>
        </dependency>

方法：

  • 对象序列化为JSON字符串：使用writeValueAsString方法可以将Java对象序列化为JSON字符串

    • java
              // 序列化对象转为JSON字符串
        String s1 = objectMapper.writeValueAsString(new User("yxx", 20, 20000));
        System.out.println("对象转JSON打印：" + s1);

  • JSON字符串反序列化为对象：使用readValue方法可以将JSON字符串反序列化为Java对象

    • java
              // 反序列化JSON字符串为对象
        User user = objectMapper.readValue(jsonString, User.class);
        System.out.println("JSON转对象打印：" + user);

  • JSON字符串解析为JsonNode：使用readTree方法可以将JSON字符串解析为Jackson库中的JsonNode对象，方便进行后续的操作

    • java
      JsonNode jsonNode = objectMapper.readTree(jsonString);

// 获取字符name的值，作为String返回
System.out.println(jsonNode.get("name").asText());

  • JSON字符串解析为Java集合：使用readValue方法可以将JSON数组字符串解析为Java集合

    • java
      ObjectMapper objectMapper = new ObjectMapper();
List<User> userList = objectMapper.readValue(jsonArray, new TypeReference<List<User>>(){});

对象转Map ​

ObjectToMapConverter.java

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

public class ObjectToMapConverter {
    // 将Java对象转化为Map对象
    public static <T> Map<String, Object> convertToMap(T object) throws IllegalAccessException {
        Map<String, Object> map = new HashMap<>();
        Class<?> clazz = object.getClass();
        for (Field field : clazz.getDeclaredFields()) {
            field.setAccessible(true); // 允许访问私有字段
            map.put(field.getName(), field.get(object)); // 将字段名和值添加到Map中  
        }
        return map;
    }
}

示例代码 ​

JSONTest.java

java
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.Test;
import pojo.Address;
import pojo.JsonUser;
import pojo.User;

import java.util.Map;

public class JSONTest {

    @Test
    public void testJSON() {
        String jsonString = "{\n" +
                "  \"name\": \"John Doe\",\n" +
                "  \"age\": 30,\n" +
                "  \"email\": \"johndoe@example.com\",\n" +
                "  \"address\": {\n" +
                "    \"city\": \"New York\",\n" +
                "    \"zipCode\": \"10001\"\n" +
                "  },\n" +
                "  \"hobbies\": [\"reading\", \"hiking\", \"photography\"]\n" +
                "}";

        // 反序列化JSON字符串为对象
        JsonUser jsonUser = JSON.parseObject(jsonString, JsonUser.class);
        System.out.println("JSON转对象打印：" + jsonUser);

        // 反序列化JSON字符串为原始Map
        Map map = JSON.parseObject(jsonString, Map.class);
        System.out.println(map.get("address"));

        // 指定Map类型转换
        Map<String, String> jsonMap = JSON.parseObject(jsonString, new TypeReference<Map<String, String>>() {});
        System.out.println("JSON转Map对象：" + jsonMap);
        Address address = JSON.parseObject(jsonMap.get("address"), Address.class);
        System.out.println("从Map对象中再获取到Address对象：" + address);

        // 序列化对象转为JSON字符串
        String jsonStr = JSON.toJSONString(jsonUser);
        System.out.println("对象转JSON打印：" + jsonStr);

        // 转JSON字符串为JSONObject对象
        JSONObject jsonObject = JSON.parseObject(jsonString);
        String age = jsonObject.getString("age");
        System.out.println(age);
    }

    @Test
    public void testObjectMapper() throws JsonProcessingException {
        String jsonString = "{\"age\":20,\"name\":\"yuuuuu\",\"salary\":2222}";

        ObjectMapper objectMapper = new ObjectMapper();

        // 反序列化JSON字符串为对象
        User user = objectMapper.readValue(jsonString, User.class);
        System.out.println("JSON转对象打印：" + user);

        // 序列化对象转为JSON字符串
        String s1 = objectMapper.writeValueAsString(new User("yxx", 20, 20000));
        System.out.println("对象转JSON打印：" + s1);

        // 转JSON字符串转为JsonNode对象
        JsonNode jsonNode = objectMapper.readTree(jsonString);
        System.out.println(jsonNode.get("name").asText());
    }

    @Test
    public void myObject() throws IllegalAccessException {
        User user = new User("yuuuu", 23, 24444);
        Map<String, Object> stringObjectMap = ObjectToMapConverter.convertToMap(user);
        System.out.println("对象转Map：" + stringObjectMap);
    }
}
JSON转对象打印：JsonUser{name='John Doe', age='30', email='johndoe@example.com', address=Address{city='New York', zipCode='10001'}, hobbies=[reading, hiking, photography]}
{"zipCode":"10001","city":"New York"}
JSON转Map对象：{address={"zipCode":"10001","city":"New York"}, hobbies=["reading","hiking","photography"], name=John Doe, age=30, email=johndoe@example.com}
从Map对象中再获取到Address对象：Address{city='New York', zipCode='10001'}
对象转JSON打印：{"address":{"city":"New York","zipCode":10001},"age":30,"email":"johndoe@example.com","hobbies":["reading","hiking","photography"],"name":"John Doe"}
30
对象转Map：{name=yuuuu, salary=24444, age=23}
JSON转对象打印：User{name='yuuuuu', age=20, salary=2222}
对象转JSON打印：{"name":"yxx","age":20,"salary":20000}
yuuuuu