利用ByteBuddy实现抽象类的JSON序列化和反序列化

Builder模式

在实验室的一个项目中, 有一个将标准化YANG文件转化为JAVA类的工具, 这个工具采用的是Builder模式, 以下以Bar这个类做为示例

Bar: 作为抽象接口

package top.roccoshi.demo.builder;

public interface Bar {
    String getBarName();
}

Builder 和CheckedBuilder接口:

package top.roccoshi.demo.builder;

public interface Builder<T> extends CheckedBuilder<T, IllegalArgumentException> {
}


public interface CheckedBuilder<T, E extends Exception> {
    T build() throws E;
}

BarBuilder: Bar的Builder类

package top.roccoshi.demo.builder;

import java.util.Objects;

public class BarBuilder implements Builder<Bar> {
    private String _barName;

    @Override
    public Bar build() throws IllegalArgumentException {
        return new BarImpl(this);
    }

    public BarBuilder() {
    }

    public BarBuilder(Bar base) {
        this._barName = base.getBarName();
    }

    public String getBarName() {
        return _barName;
    }

    public BarBuilder setBarName(String _barName) {
        this._barName = _barName;
        return this;
    }

    private static final class BarImpl implements Bar {

        private final String _barName;

        private BarImpl(BarBuilder barBuilder) {
            _barName = barBuilder._barName;
        }

        @Override
        public String getBarName() {
            return _barName;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof BarImpl)) return false;
            BarImpl bar = (BarImpl) o;
            return Objects.equals(_barName, bar._barName);
        }

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

        @Override
        public String toString() {
            return "BarImpl{" +
                    "_barName='" + _barName + '\'' +
                    '}';
        }
    }
}

可以看到BarBuilder中先是实现了build方法, 然后通过builder通过实例化并返回一个内部类BarImpl的方式实现Bar的实例化

JSON的反序列化的问题

为了进一步阐述问题, 我们采用builder模式定义了一个包含Bar类成员的Foo类:

package top.roccoshi.demo.builder;

// Foo
public interface Foo {
    String getName();
    String getMessage();
    Bar getBar();
}

// Builder
public class FooBuilder implements Builder<Foo> {

    private String _name;
    private String _message;
    private Bar _bar;

    // 实现两种构造函数
    public FooBuilder() {
    }

    public FooBuilder(Foo base) {
        this._name = base.getName();
        this._message = base.getMessage();
        this._bar = base.getBar();
    }

    @Override
    public Foo build() throws IllegalArgumentException {
        return new FooImpl(this);
    }

    public String getName() {
        return _name;
    }

    public FooBuilder setName(String _name) {
        this._name = _name;
        return this;
    }

    public String getMessage() {
        return _message;
    }

    public FooBuilder setMessage(String _message) {
        this._message = _message;
        return this;
    }

    public Bar getBar() {
        return _bar;
    }

    public FooBuilder setBar(Bar _bar) {
        this._bar = _bar;
        return this;
    }

    private static final class FooImpl implements Foo {

        private final String _name;
        private final String _message;
        private final Bar _bar;

        FooImpl(FooBuilder base) {
            this._name = base.getName();
            this._bar = base.getBar();
            this._message = base.getMessage();
        }

        @Override
        public String getName() {
            return _name;
        }

        @Override
        public String getMessage() {
            return _message;
        }

        @Override
        public Bar getBar() {
            return _bar;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof FooImpl)) return false;
            FooImpl foo = (FooImpl) o;
            return Objects.equals(_name, foo._name) && Objects.equals(_message, foo._message) && Objects.equals(_bar, foo._bar);
        }

        @Override
        public int hashCode() {
            return Objects.hash(_name, _message, _bar);
        }

        @Override
        public String toString() {
            return "FooImpl{" +
                    "_name='" + _name + '\'' +
                    ", _message='" + _message + '\'' +
                    ", _bar=" + _bar +
                    '}';
        }
    }
}

然后我们使用jackson测试序列化的效果:

@Test
public void testBuilderSerializeJacksonNoAbstractClass() throws IOException {
    Bar bar = new BarBuilder().setBarName("bar").build();
    Foo foo = new FooBuilder().setMessage("hello").setBar(bar).build();
    ObjectMapper mapper = new ObjectMapper();
    try {
        // 序列化为JSON对象
        String s = mapper.writeValueAsString(foo);
        System.out.println("convert foo in String: " + s);
        // 输出: {"name":null,"message":"hello","bar":{"barName":"bar"}}
        
        // 反序列化并build
        Foo convertedFoo = mapper.readValue(s, FooBuilder.class).build();
        System.out.println("convertedFoo = " + convertedFoo);
        assertNotEquals(foo, convertedFoo);
    } catch (Exception e) {
        assertEquals(e.getClass(), JsonMappingException.class);
        System.out.println(e);
        /**
com.fasterxml.jackson.databind.JsonMappingException: Can not construct instance of top.roccoshi.demo.builder.Bar, problem: abstract types either need to be mapped to concrete types, have custom deserializer, or be instantiated with additional type information
 at [Source: {"name":null,"message":"hello","bar":{"barName":"bar"}}; line: 1, column: 38] (through reference chain: top.roccoshi.demo.builder.FooBuilder["bar"])
**/
    }
}

可以看到输出的原因在于Bar是一个抽象类型(interface), 没有被映射到具体的类型或者指定反序列化的方法

原因很简单, 光看Foo和Bar这俩接口:

// Foo
public interface Foo {
    String getName();
    String getMessage();
    Bar getBar();
}

// Bar
public interface Bar {
    String getBarName();
}

谁在解析字符串(反序列化)的时候知道你这个Bar怎么生成啊?

解决方式

• 第一种解决方式是用jackson对应的注解

但是问题在于: 这个项目的代码都是由工具生成在target中的, 除非修改工具库的源代码, 否则手动添加注解是个费事且麻烦的事情

有没有非侵入性修改源代码的方式, 能解决这种模式下的JSON序列化和反序列化问题呢?

有

在jackson中手动添加AbstractTypeMapping

这个方法相当于告诉jackson, 对于每一个抽象类型, 我应该用哪个实现类去实现序列化

方式如下:

• 首先定义一个继承了Bar和BarBuilder的类型

package top.roccoshi.demo.builder;

public class BarExtend extends BarBuilder implements Bar {
}

• 添加typeMapping

@Test
public void testBuilderSerializeJacksonAbstractClassWithoutSrcChanged() throws IOException {
    Bar bar = new BarBuilder().setBarName("bar").build();
    Foo foo = new FooBuilder().setMessage("hello").setBar(bar).build();
    ObjectMapper mapper = new ObjectMapper();
    // ========= this is the difference ==========
    SimpleModule mod = new SimpleModule();
    mod.addAbstractTypeMapping(Bar.class, BarExtend.class);
    mapper.registerModule(mod);
    // ========= this is the difference ==========
    String s = mapper.writeValueAsString(foo);
    System.out.println("convert foo in String: " + s);
    // convert foo in String: {"name":null,"message":"hello","bar":{"barName":"bar"}}
    Foo convertedFoo = mapper.readValue(s, FooBuilder.class).build();
    System.out.println("convertedFoo = " + convertedFoo);
    // convertedFoo = FooImpl{_name='null', _message='hello', _bar=top.roccoshi.demo.builder.BarExtend@5c5a1b69}
    assertEquals(mapper.writeValueAsString(foo), mapper.writeValueAsString(convertedFoo));
}

这样的方式不用修改BarBuilder和Bar的源代码, 但是问题是, 自己还是需要手动为每个类定义Extend类, 并且还要手动一个个将这些类的mapping关系添加进去

除了解决了入侵性, 工作量并没有减少

有没有什么方式, 可以实现不用手动做额外的事情呢?

这时候就想到了之前提到的ByteBuddy了: ByteBuddy — 简单介绍和入门 _

利用ByteBuddy动态生成类

基于ByteBuddy动态生成字节码的特性, 我们可否将上述思路转化为动态生成class的模式?

答案是当然可以

首先我们需要知道

• 如何动态构建一个public class BarExtend extends BarBuilder implements Bar {}这样的类?

答案是

Class<?> dynamic = new ByteBuddy()
    .subclass(BarBuilder.class)
    .implement(Bar.class)
    .make()

就可以了

• 然后是如何动态添加一个abstractTypeMapping?

答案是实现一个SimpleAbstractTypeResolver就可以了,

该类具有一个findTypeMapping的方法, 目的是让jackson能在运行时找到abstractType对应的type, 注意到_mapping中保存了所有的typeMapping关系, 只有当_mapping找不到映射就会返回null, 那么我们只要覆写_mapping找不到映射关系时的逻辑即可

public JavaType findTypeMapping(DeserializationConfig config, JavaType type) {
    Class<?> src = type.getRawClass();
    Class<?> dst = (Class)this._mappings.get(new ClassKey(src));
    return dst == null ? null : config.getTypeFactory().constructSpecializedType(type, dst);
}

整个实现如下:

@Test    
public void testBuilderSerializeJacksonAbstractClassWithoutSrcChangedAndManuallyAdd() throws IOException {
        Bar bar = new BarBuilder().setBarName("bar").build();
        Foo foo = new FooBuilder().setMessage("hello").setBar(bar).build();
        ObjectMapper mapper = new ObjectMapper();
        // ========= this is the difference ==========
        SimpleModule mod = new SimpleModule();
        SimpleAbstractTypeResolver resolver = new SimpleAbstractTypeResolver() {
            private static final String Suffix = "$dynamicType$";

            @Override
            public JavaType findTypeMapping(DeserializationConfig config, JavaType type) {
                Class<?> srcClass = type.getRawClass();
                String srcClassName = srcClass.getName();
                JavaType t = super.findTypeMapping(config, type);
                if (t != null || srcClassName.endsWith(Suffix)) {
                    return t;
                }
                try {
                    Class<?> builder = Class.forName(srcClassName + "Builder");
                    System.out.println("find builder for " + srcClassName + ", builder = " + builder.getName());
                    Class<?> dynamic;
                    try {
                        dynamic = Class.forName(srcClassName + Suffix);
                    } catch (ClassNotFoundException e) {
                        dynamic = new ByteBuddy()
                                .subclass(builder)
                                .implement(srcClass)
                                .name(srcClassName + Suffix)
                                .make()
                                .load(getClass().getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
                                .getLoaded();
                    }
                    System.out.println("dynamic is loaded, className = " + dynamic.getName());
                    return config.getTypeFactory().constructSpecializedType(type, dynamic);
                } catch (Exception e) {
                    System.out.println("error in abstract types: " + e);
                    return null;
                }
            }
        };
        mod.setAbstractTypes(resolver);
        mapper.registerModule(mod);
        // ========= this is the difference ==========
        String s = mapper.writeValueAsString(foo);
        System.out.println("convert foo in String: " + s);
        Foo convertedFoo = mapper.readValue(s, FooBuilder.class).build();
        System.out.println("convertedFoo = " + convertedFoo);
        assertEquals(mapper.writeValueAsString(foo), mapper.writeValueAsString(convertedFoo));
        String json = " {\"message\":\"hello\",\"bar\":{\"barName\":\"bar\"}}";
        Foo fromJsonFoo = mapper.readValue(json, FooBuilder.class).build();
        assertEquals(fromJsonFoo.getBar().getClass().getName(), "top.roccoshi.demo.builder.Bar$dynamicType$");
    }
/**
convert foo in String: {"name":null,"message":"hello","bar":{"barName":"bar"}}

find builder for top.roccoshi.demo.builder.Bar, builder = top.roccoshi.demo.builder.BarBuilder

dynamic is loaded, className = top.roccoshi.demo.builder.Bar$dynamicType$

convertedFoo = FooImpl{_name='null', _message='hello', _bar=top.roccoshi.demo.builder.Bar$dynamicType$@149e0f5d}
**/