Jackson处理空字节数组/流的优雅之道

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.core.JsonParser;
import java.io.IOException;

public class EmptyBytesDeserialization {

    public static void main(String[] args) throws IOException {
        byte[] jsonBytes1 = {}; // 空字节数组
        byte[] jsonBytes2 = "{\"name\":\"Alice\"}".getBytes(); // 有效JSON

        ObjectMapper mapper = new ObjectMapper();

        // 处理空字节数组
        JsonParser parser1 = mapper.getFactory().createParser(jsonBytes1);
        JsonNode node1 = parser1.readValueAsTree(); // 空输入会返回null

        MyPojo myPojo1 = null;
        if (node1 != null) {
            myPojo1 = mapper.treeToValue(node1, MyPojo.class);
        }
        System.out.println("Result for empty bytes: " + myPojo1); // 输出 null

        // 处理有效JSON
        JsonParser parser2 = mapper.getFactory().createParser(jsonBytes2);
        JsonNode node2 = parser2.readValueAsTree(); // 有效JSON会返回对应的JsonNode

        MyPojo myPojo2 = null;
        if (node2 != null) {
            myPojo2 = mapper.treeToValue(node2, MyPojo.class);
        }
        System.out.println("Result for valid JSON: " + myPojo2); // 输出 MyPojo(name=Alice)
    }
}

// 示例POJO
class MyPojo {
    private String name;

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

    @Override
    public String toString() { return "MyPojo(name=" + name + ")"; }
}

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.core.JsonParser;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Optional;

public class JacksonEmptyBytesHandler {

    /**
     * 将字节数组转换为指定类型的POJO，能够优雅地处理空字节数组。
     * 如果字节数组为空或不包含有效JSON，则返回Optional.empty()。
     *
     * @param arr 待转换的字节数组
     * @param pojoClass 目标POJO的Class对象
     * @param mapper Jackson ObjectMapper实例
     * @param <T> 目标POJO的类型
     * @return 包含转换结果的Optional，如果输入为空或无效则为Optional.empty()
     * @throws IOException 如果JSON解析或转换过程中发生其他I/O错误
     */
    public static <T> Optional<T> convertBytes(byte[] arr,
                                               Class<T> pojoClass,
                                               ObjectMapper mapper) throws IOException {
        // 创建JsonParser，用于低级流处理
        JsonParser parser = mapper.getFactory().createParser(arr);
        // 尝试将输入解析为JsonNode树
        JsonNode node = parser.readValueAsTree();

        // 如果node为null，表示输入为空或无内容，返回Optional.empty()
        // 否则，将JsonNode转换为目标POJO，并封装在Optional中
        return node != null && !node.isNull() ? Optional.of(mapper.treeToValue(node, pojoClass)) : Optional.empty();
    }

    // 示例POJO
    public static class MyPojo {
        private String name;

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

        @Override
        public String toString() { return "MyPojo(name=" + name + ")"; }
    }

    public static void main(String[] args) throws IOException {
        String source = """
            {
                "name" : "Alice"
            }
            """;

        byte[] jsonBytes1 = {}; // 空字节数组
        byte[] jsonBytes2 = source.getBytes(StandardCharsets.UTF_8); // 有效JSON字节数组

        ObjectMapper mapper = new ObjectMapper();

        // 使用通用方法处理空字节数组
        Optional<MyPojo> result1 = convertBytes(jsonBytes1, MyPojo.class, mapper);
        System.out.println("处理空字节数组: " + result1); // 输出 Optional.empty

        // 使用通用方法处理有效JSON字节数组
        Optional<MyPojo> result2 = convertBytes(jsonBytes2, MyPojo.class, mapper);
        System.out.println("处理有效JSON字节数组: " + result2); // 输出 Optional[MyPojo(name=Alice)]
    }
}

处理空字节数组: Optional.empty
处理有效JSON字节数组: Optional[MyPojo(name=Alice)]