仅持有接口时，如何将Java序列化字节数组反序列化为JSON？

当然可以用代理模拟实现类来搞定这个问题！我来给你拆解下思路和具体做法：

为什么反序列化会报错？ #

你遇到的ClassNotFoundException本质是：JVM反序列化时需要找到原始对象的实现类，但你的应用只持有对应的接口，没有实现类的字节码，所以没法完成对象还原。不过咱们的目标不是还原成原始Java对象，而是提取数据转成JSON，这就给了我们操作空间——只要能生成一个符合接口规范、能承载原始对象字段值的代理类，就能让反序列化顺利完成，再转成JSON。

核心思路 #

通过自定义ObjectInputStream拦截类加载过程：当JVM找不到原始实现类时，动态生成一个实现目标接口的代理类（可以用JDK动态代理或ByteBuddy/CGLIB这类字节码生成库），让这个代理类持有原始对象的所有字段值，并且能响应接口定义的方法（比如getter）。这样反序列化出来的代理对象，就能被JSON序列化库（比如Jackson）正常读取，转成JSON。

具体实现（用ByteBuddy生成代理类） #

ByteBuddy比JDK动态代理更灵活，能直接生成带字段的实现类，适配有getter的接口场景：

1. 先添加ByteBuddy依赖 #

如果用Maven，在pom.xml里加：

<dependency>
    <groupId>net.bytebuddy</groupId>
    <artifactId>byte-buddy</artifactId>
    <version>1.14.11</version>
</dependency>

2. 自定义ObjectInputStream处理类加载 #

import net.bytebuddy.ByteBuddy;
import net.bytebuddy.dynamic.loading.ClassLoadingStrategy;
import net.bytebuddy.implementation.FieldAccessor;
import net.bytebuddy.matcher.ElementMatchers;

import java.io.*;
import java.util.HashMap;
import java.util.Map;

public class SerializedToJsonConverter {

    public static String convert(byte[] serializedData, Class<?> targetInterface) throws IOException, ClassNotFoundException {
        try (ObjectInputStream ois = new ProxyObjectInputStream(new ByteArrayInputStream(serializedData), targetInterface)) {
            Object proxyObject = ois.readObject();
            // 用Jackson转成JSON
            com.fasterxml.jackson.databind.ObjectMapper mapper = new com.fasterxml.jackson.databind.ObjectMapper();
            // 若接口没有getter，可配置Jackson直接访问字段
            mapper.setVisibility(com.fasterxml.jackson.annotation.PropertyAccessor.FIELD, com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility.ANY);
            return mapper.writeValueAsString(proxyObject);
        }
    }

    static class ProxyObjectInputStream extends ObjectInputStream {
        private final Class<?> targetInterface;

        public ProxyObjectInputStream(InputStream in, Class<?> targetInterface) throws IOException {
            super(in);
            this.targetInterface = targetInterface;
        }

        @Override
        protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
            try {
                // 先尝试加载原始类
                return super.resolveClass(desc);
            } catch (ClassNotFoundException e) {
                // 验证原始类是否实现了目标接口
                boolean implementsTarget = false;
                for (Class<?> iface : desc.getInterfaces()) {
                    if (iface.getName().equals(targetInterface.getName())) {
                        implementsTarget = true;
                        break;
                    }
                }
                if (!implementsTarget) {
                    throw e; // 不是目标接口的实现类，直接抛出异常
                }

                // 收集原始类的字段信息
                Map<String, Class<?>> fieldMap = new HashMap<>();
                for (ObjectStreamField field : desc.getFields()) {
                    fieldMap.put(field.getName(), field.getType());
                }

                // 用ByteBuddy动态生成实现类：继承Object，实现目标接口，包含所有字段
                return new ByteBuddy()
                        .subclass(Object.class)
                        .implement(targetInterface)
                        // 定义所有字段
                        .defineFields(fieldMap.entrySet().stream()
                                .map(entry -> new net.bytebuddy.description.field.FieldDescription.Latent(
                                        entry.getKey(),
                                        net.bytebuddy.description.type.TypeDescription.ForLoadedType.of(entry.getValue()),
                                        net.bytebuddy.implementation.FieldAccessor.FieldNameTransformer.DEFAULT))
                                .toArray(net.bytebuddy.description.field.FieldDescription.Latent[]::new))
                        // 为所有getter方法生成字段访问逻辑
                        .method(ElementMatchers.isGetter())
                        .intercept(FieldAccessor.ofBeanProperty())
                        .make()
                        .load(targetInterface.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
                        .getLoaded();
            }
        }
    }
}

3. 使用示例 #

public class Main {
    public static void main(String[] args) throws Exception {
        byte[] dbData = ...; // 从数据库获取的序列化字节数组
        String json = SerializedToJsonConverter.convert(dbData, MyBusinessInterface.class);
        System.out.println(json);
    }
}

注意事项 #

• 如果原始对象的接口没有定义getter方法，记得配置Jackson直接访问字段（代码里已加相关配置）
• 若原始类有复杂的继承关系，需要额外处理父类的字段（可以在resolveClass中递归读取父类的字段信息）
• 这个方案只保证能提取数据转JSON，代理对象无法执行原始类的业务逻辑（但咱们本来也不需要这个）

内容的提问来源于stack exchange，提问作者panox