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

ObjectMapper objectMapper = new ObjectMapper();
byte[] val = new byte[] {}; // 空字节数组
// objectMapper.readValue(val, new TypeReference<Object>() {}); // 会抛出 MismatchedInputException

import java.util.Objects;

public 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 + ")";
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        MyPojo myPojo = (MyPojo) o;
        return Objects.equals(name, myPojo.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name);
    }
}

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Optional;

public class JacksonEmptyInputHandler {

    /**
     * 将字节数组反序列化为指定类型的对象，支持处理空字节数组。
     * 如果字节数组为空或解析后得到空节点，则返回 Optional.empty()。
     *
     * @param arr       待反序列化的字节数组
     * @param pojoClass 目标POJO的Class类型
     * @param mapper    ObjectMapper实例
     * @param <T>       目标POJO的类型
     * @return 包含反序列化对象的Optional，如果输入为空则返回Optional.empty()
     * @throws IOException 如果反序列化过程中发生IO异常
     */
    public static <T> Optional<T> convertBytes(byte[] arr,
                                               Class<T> pojoClass,
                                               ObjectMapper mapper) throws IOException {
        // 通过ObjectMapper的工厂创建JsonParser
        JsonParser parser = mapper.getFactory().createParser(arr);

        // 使用parser将输入解析为JsonNode
        // 如果输入为空，readValueAsTree() 将返回 null
        JsonNode node = parser.readValueAsTree();

        // 检查解析得到的JsonNode是否为null
        if (node != null) {
            // 如果JsonNode不为null，说明有内容，将其转换为目标POJO
            return Optional.of(mapper.treeToValue(node, pojoClass));
        } else {
            // 如果JsonNode为null，表示输入为空，返回Optional.empty()
            return Optional.empty();
        }
    }

    // 主方法用于测试
    public static void main(String[] args) throws IOException {
        // 示例JSON字符串
        String source = """
            {
                "name" : "Alice"
            }
            """;

        // 两种输入情况：空字节数组和有效JSON字节数组
        byte[] jsonBytesEmpty = {}; // 空字节数组
        byte[] jsonBytesValid = source.getBytes(StandardCharsets.UTF_8); // 有效JSON字节数组

        ObjectMapper mapper = new ObjectMapper();

        // 测试空字节数组
        System.out.println("处理空字节数组: " + convertBytes(jsonBytesEmpty, MyPojo.class, mapper));

        // 测试有效JSON字节数组
        System.out.println("处理有效JSON字节数组: " + convertBytes(jsonBytesValid, MyPojo.class, mapper));
    }
}

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