每日一问 | Gson中序列化对象的操作有低侵入的优化方案吗？

通过GsonBuilder的registerTypeAdapter方法设置的TypeAdapter，会包装成TypeAdapterFactory放在一个叫factories的List<TypeAdapterFactory>里面，当我们调用create方法创建Gson对象实例，这些TypeAdapterFactory最终会添加到Gson里面的同名成员变量factories。

我在想，应该可以弄一个TypeAdapterFactory，集合所有需要优化的实体类对应的TypeAdapter，然后通过ASM，在Gson的构造函数中把这个TypeAdapterFactory添加到factories里，这样的话，就不需要动原来的代码，就算原来的代码是直接new Gson()，也能享受到自定义TypeAdapter的效果。

我等下回去试试。

Gson这个类有两个构造函数（我的版本是2.8.8，目前最新）：

public final class Gson {

  public Gson() {
    this(
        ......,
        ......,
        Collections.<TypeAdapterFactory>emptyList(), 
        Collections.<TypeAdapterFactory>emptyList(),
        Collections.<TypeAdapterFactory>emptyList());
  }

这个无参构造函数最终也是会调用另一个有参数的：

public final class Gson {
  Gson(
      ......,
      ......,
      List<TypeAdapterFactory> builderFactories,
      List<TypeAdapterFactory> builderHierarchyFactories,
      List<TypeAdapterFactory> factoriesToBeAdded) {

    ......

    List<TypeAdapterFactory> factories = new ArrayList<TypeAdapterFactory>();

    ......

    // users' type adapters
    factories.addAll(factoriesToBeAdded);

    // type adapters for composite and user-defined types
    factories.add(new CollectionTypeAdapterFactory(constructorConstructor));
    factories.add(new MapTypeAdapterFactory(constructorConstructor, complexMapKeySerialization));
    this.jsonAdapterFactory = new JsonAdapterAnnotationTypeAdapterFactory(constructorConstructor);
    factories.add(jsonAdapterFactory);
    factories.add(TypeAdapters.ENUM_FACTORY);
    factories.add(new ReflectiveTypeAdapterFactory(
        constructorConstructor, fieldNamingStrategy, excluder, jsonAdapterFactory));

    this.factories = Collections.unmodifiableList(factories);
  }
}

这个构造函数，大部分代码都是在给本地变量factories添加各种TypeAdapterFactory，最后通过Collections.unmodifiableList包装了一下，赋值给了同名成员变量。

顺便提一下，通过GsonBuilder.create创建的Gson对象，也是调用Gson有参数的那个构造函数：

public final class GsonBuilder {

  ......

  public Gson create() {
    ......
    return new Gson(excluder, fieldNamingPolicy, instanceCreators,
        serializeNulls, complexMapKeySerialization,
        generateNonExecutableJson, escapeHtmlChars, prettyPrinting, lenient,
        serializeSpecialFloatingPointValues, longSerializationPolicy,
        datePattern, dateStyle, timeStyle,
        this.factories, this.hierarchyFactories, factories);
  }
}

也就是说，使用常规方式创建的Gson对象，始终都会走到这个有参的构造函数里面，这可以作为我们代码的注入点。

好。

我们的思路是，在Gson有参构造函数调用Collections.unmodifiableList之前，添加上我们自己的TypeAdapterFactory，即调用本地变量factories的add方法。

看下代码怎么写：

class Injection : Transform() {

    ......    

    override fun transform(transformInvocation: TransformInvocation) {
        // 删掉上一次复制的文件
        transformInvocation.outputProvider.deleteAll()
        transformInvocation.inputs.forEach {
            // 遍历所有jar包
            it.jarInputs.forEach { jar ->
                jar.processGsonJar(transformInvocation.outputProvider.getContentLocation(jar.name, jar.contentTypes, jar.scopes, Format.JAR))
            }
            // 把编译好的class直接复制到transforms下（无需修改）
            it.directoryInputs.forEach { dir ->
                FileUtils.copyDirectory(
                    dir.file, transformInvocation.outputProvider.getContentLocation(dir.name, dir.contentTypes, dir.scopes, Format.DIRECTORY)
                )
            }
        }
    }
}

通常我们使用Gson都是直接引用的jar包，所以这里只对jar文件作处理。

看看processGsonJar方法是怎么写的：

private fun JarInput.processGsonJar(transformJarFile: File) {
    val jarFile = JarFile(file)
    // JarOutputStream用于写入新jar包
    val jos = JarOutputStream(FileOutputStream(transformJarFile))
    val entries = jarFile.entries()
    // 遍历zip包里面的元素
    while (entries.hasMoreElements()) {
        val jarEntry = entries.nextElement()
        // 在新jar包里创建同名文件
        jos.putNextEntry(ZipEntry(jarEntry.name))

        // 我们的目标是Gson这个class
        if (jarEntry.name == "com/google/gson/Gson.class") {
            ClassWriter(ClassWriter.COMPUTE_MAXS).apply {
                ClassReader(jarFile.getInputStream(jarEntry)).accept(object : ClassVisitor(Opcodes.ASM9, this) {
                    override fun visitMethod(
                        access: Int, name: String?, descriptor: String?, signature: String?, exceptions: Array<out String>?
                    ): MethodVisitor = super.visitMethod(access, name, descriptor, signature, exceptions).let { methodVisitor ->
                        // 只需要修改有参数的那个构造函数
                        if (name == "<init>" && signature?.isEmpty() == false) {
                            GsonMethodVisitor(methodVisitor, access, name, descriptor)
                        } else methodVisitor
                    }
                }, ClassReader.EXPAND_FRAMES)
                // 单独输出到指定路径下，便于查看
                File("/home/wuyr/Desktop", "Gson.class").writeBytes(toByteArray())
                // 把修改后的class内容写入到新jar包里
                jos.write(toByteArray())
            }
        } else {
            // 其他文件直接写入到新jar包里，不做修改
            jos.write(jarFile.getInputStream(jarEntry).readAllBytes())
        }
        jos.closeEntry()
    }
    jos.close()
    jarFile.close()
}

我们会对每一个jar包的内容进行检查，目标是com/google/gson路径下的Gson.class，一旦找到这个文件，则进入【下一个环节】，其他文件无需修改。

【下一个环节】，就是借助ClassReader和ClassVisitor对这个class文件进行访问，我们需要找的是构造函数，所以重写了ClassVisitor的visitMethod方法，并在里面进一步判断（是有参数的那个），找到这个有参的构造函数之后，会返回一个GsonMethodVisitor，等下会说。

可以看到在ClassReader的accept方法调用完之后，还把新的Gson.class写出到一个单独的文件里，这是方便后面查看修改结果的。

来想一下，我们注入的代码，应该是怎么样的呢？

其实只需要知道Factory的完整类名就行了。

可以用一行代码搞定：

factories.add((TypeAdapterFactory) Class.forName("Factory完整类名").getField("INSTANCE").get(null));

转换成ASM的操作代码：

mv.visitVarInsn(ALOAD, 1)
mv.visitLdcInsn("Factory完整类名")
mv.visitMethodInsn(INVOKESTATIC, "java/lang/Class", "forName", "(Ljava/lang/String;)Ljava/lang/Class;", false)
mv.visitLdcInsn("INSTANCE")
mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Class", "getField", "(Ljava/lang/String;)Ljava/lang/reflect/Field;", false)
mv.visitInsn(ACONST_NULL)
mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/reflect/Field", "get", "(Ljava/lang/Object;)Ljava/lang/Object;", false)
mv.visitTypeInsn(CHECKCAST, "com/google/gson/TypeAdapterFactory")
mv.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "add", "(Ljava/lang/Object;)Z", true)
mv.visitInsn(POP)

注意！

第一行的ALOAD 1，后面的索引1，在实际应用中可能并不是这个数，因为我们刚刚写的是模拟代码，没有其他多余的局部变量所以通过插件转换时这个数会小很多，但是当真正放在Gson构造函数中就不一样了。

这怎么办呢？

可以先看一次Gson.class的字节码，确定好factories这个局部变量的索引是多少。

慢着，直接看字节码很会头疼，不如先看一遍源码，确定好factories的大致位置：

public final class Gson {
  Gson(......) {
    ......
    ......

    this.builderHierarchyFactories = builderHierarchyFactories;

    List<TypeAdapterFactory> factories = new ArrayList<TypeAdapterFactory>();

    ......
    ......
  }
}

嗯，就在成员变量builderHierarchyFactories赋值豫剧的下面。

那现在来javap -v看一下字节码：

看highlight部分，刚好是在builderHierarchyFactories下面创建的ArrayList实例，证明这就是factories引用的对象了。

重点来了，看最后一句astore 18，把栈顶的值保存到局部变量表中，索引是18。

好，得到真正的索引值之后，可以继续写代码了：

private class GsonMethodVisitor(methodVisitor: MethodVisitor, access: Int, name: String?, descriptor: String?) :
    AdviceAdapter(Opcodes.ASM9, methodVisitor, access, name, descriptor) {

    override fun visitMethodInsn(opcode: Int, owner: String?, name: String?, descriptor: String?, isInterface: Boolean) {
        // 在它调用unmodifiableList方法之前插入字节码
        if (name == "unmodifiableList") {
            // 局部变量入栈，索引是18
            mv.visitVarInsn(ALOAD, 18)
            mv.visitLdcInsn("Factory完整类名")
            mv.visitMethodInsn(INVOKESTATIC, "java/lang/Class", "forName", "(Ljava/lang/String;)Ljava/lang/Class;", false)
            mv.visitLdcInsn("INSTANCE")
            mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Class", "getField", "(Ljava/lang/String;)Ljava/lang/reflect/Field;", false)
            mv.visitInsn(ACONST_NULL)
            mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/reflect/Field", "get", "(Ljava/lang/Object;)Ljava/lang/Object;", false)
            mv.visitTypeInsn(CHECKCAST, "com/google/gson/TypeAdapterFactory")
            mv.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "add", "(Ljava/lang/Object;)Z", true)
            mv.visitInsn(POP)
        }
        super.visitMethodInsn(opcode, owner, name, descriptor, isInterface)
    }
}

好，执行assembleDebug这个Task，会在刚刚指定的路径下看到Gson.class：

把它拖到AS里面：

看到了没有！！！已经成功注入代码了！

现在把那个TypeAdapterFactory定义好：

object RectAdapterFactory : TypeAdapterFactory {

    override fun <T> create(gson: Gson?, type: TypeToken<T>?) = object : TypeAdapter<Rect>() {
        override fun write(out: JsonWriter, value: Rect?) {
            value?.let { rect ->
                out.beginObject()
                out.name("left").value(rect.left)
                out.name("top").value(rect.top)
                out.name("right").value(rect.right)
                out.name("bottom").value(rect.bottom)
                out.endObject()
            }
        }

        override fun read(reader: JsonReader) = reader.run {
            Rect().apply {
                val readNext = { nextName().let { nextInt() * 2 } }
                beginObject()
                left = readNext()
                top = readNext()
                right = readNext()
                bottom = readNext()
                endObject()
            }
        }
    } as TypeAdapter<T>
}

我们就拿现成的Rect来作为实体类测试。

可以看到现在重写的create方法是直接返回一个匿名的TypeAdapter对象，实际应用当然不建议那么做，这里只是为了代码更加简洁。

在自定义的TypeAdapter中，重写的write方法把Rect的四个属性：left、top、right、bottom按顺序写入，这个逻辑是没有问题的；

我们主要是想验证反序列化，也就是read的效果，所以在重写的read方法里面，故意把读取出来的四个属性值都翻倍了一下，比如本来是10的，反序列化后会变成20。

噢，这里有同学可能会有疑问：刚刚注入的代码，不是通过反射获取到目标类中一个叫INSTANCE的静态变量嘛？怎么这里没有声明？

哈哈哈，快往上翻看一下RectAdapterFactory用的什么关键字。

我们在声明RectAdapterFactory这个类的时候，用object代替class，就已经是单例模式了，在编译的时候会自动生成一个叫INSTANCE的静态变量，不信你反编译看一下代码。

好，现在把刚刚GsonMethodVisitor里面的那个类名，替换成我们新写的这个RectAdapterFactory完整类名。

再到MainActivity里加入测试的代码：

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val rect = Rect(10, 10, 10, 10)
        Log.i("origin rect", rect.toShortString())
        Gson().run {
            Log.i("restored rect", fromJson(toJson(rect), Rect::class.java).toShortString())
        }
    }
}

注意这里在创建Gson对象时是完全没有进行过配置的，是最直接的创建方式。

按照预期的输出结果，应该是：

[10,10][10,10]
[20,20][20,20]

对吧？

好，编译运行：

咦？怎么没有效果？也没有报错啊！

难道是我们注入的代码有问题？

再次看看输出的Gson.class：

好像也没有问题啊，类名都填对了的。

噢！！！快看上面一句的Factory叫什么？！ReflectiveTypeAdapterFactory！！Reflective！！！反射啊！这不就是默认的对象类处理方式嘛，这个factories是一个ArrayList，估计在反序列化的时候，也是按顺序从里面去找合适的TypeAdapter，怪不得它放在最后才添加。

这样的话，就不能把我们的Factory放在最后了，可以把它放到最前面。

改一下GsonMethodVisitor.visitMethodInsn里面的代码：

private class GsonMethodVisitor(methodVisitor: MethodVisitor, access: Int, name: String?, descriptor: String?) :
    AdviceAdapter(Opcodes.ASM9, methodVisitor, access, name, descriptor) {

    override fun visitMethodInsn(opcode: Int, owner: String?, name: String?, descriptor: String?, isInterface: Boolean) {
        // 在它调用unmodifiableList方法之前插入字节码
        if (name == "unmodifiableList") {
            // 局部变量入栈，索引是18
            mv.visitVarInsn(ALOAD, 18)
            // 常量0入栈，因为我们要添加到最前面
            mv.visitInsn(ICONST_0)
            mv.visitLdcInsn("com.wuyr.gsonoptimizer.RectAdapterFactory")
            mv.visitMethodInsn(INVOKESTATIC, "java/lang/Class", "forName", "(Ljava/lang/String;)Ljava/lang/Class;", false)
            mv.visitLdcInsn("INSTANCE")
            mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Class", "getField", "(Ljava/lang/String;)Ljava/lang/reflect/Field;", false)
            mv.visitInsn(ACONST_NULL)
            mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/reflect/Field", "get", "(Ljava/lang/Object;)Ljava/lang/Object;", false)
            mv.visitTypeInsn(CHECKCAST, "com/google/gson/TypeAdapterFactory")
            // 改成调用add(int index, E element)方法
            mv.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "add", "(ILjava/lang/Object;)V", true)
        }
        super.visitMethodInsn(opcode, owner, name, descriptor, isInterface)
    }
}

注意看注释，主要改动的地方有2个：

1. 在factories入栈后再入栈了一个0（iconst_0）；

2. 把List.add方法的签名由(Ljava/lang/Object;)Z改成了(ILjava/lang/Object;)V；

还有个地方要注意的是！这次是没有弹栈的，没有了原来mv.visitInsn(POP)这一句，因为这次调用的add(int index, E element)方法返回值是void，不需要弹栈！

好，执行一下assembleDebug，会发现Gson.class变成这样了：

factories.add(0, (TypeAdapterFactory) Class.forName("com.wuyr.gsonoptimizer.RectAdapterFactory").getField("INSTANCE").get(null));

安装到手机上运行：

可以了！

现在，我们已经成功地在不修改源代码的前提下，去掉了Gson反序列化时的反射操作。

噢对了，上面demo的代码在这里：GsonOptimizer.zip ，感兴趣的同学可以下载下来运行看看效果，或者自己尝试改一下其他地方。

不知不觉又写了340多行，冲凉睡觉。

1. Gson解析主要慢在首次解析；
2. 首次解析过程中，慢在反射上；具体来说，用到反射的地方主要有

   2.1. 反射遍历类及其超类的字段

   2.2. 反射构造实例

   2.3. 反射设置值

3. 同一实例非首次解析，由于2.1已经被缓存下来了，所以会解析会快点，但因为仍然存在反射，所以还是慢。

基于以上三点，可以考虑书写TypeAdapter来进行优化。但是书写TypeAdapter十分麻烦，故可以考虑生成代码来解决。

另外，如果生成的TypeAdapter太多，需要一个一个的注入到Gson实例中，也十分麻烦，故可以考虑再生成一个TypeAdapterFactory来解决。

下班时间写了一个库，使用kapt生成TypeAdapter + TypeAdapterFactory，可以参考一下~

GsonBooster

`

从开始设计的时候就应该考虑到了，同一功能有很多开源库可供选择的时候都应该使用中间层，调用中间层来实现功能。

比如json解析，图片加载，网络请求，数据库这些，实现都在中间层，有修改就改那一个类。

每个类里都夸嚓一下new Gson怕是就废废了`

简单实现了下，如下：

package com.example.gson

import com.google.gson.*
import com.google.gson.reflect.TypeToken
import com.google.gson.stream.JsonReader
import com.google.gson.stream.JsonToken
import com.google.gson.stream.JsonWriter

class GsonDemo {

}

class OutBean(var outName: String, var age: Int, var bean: InnerBean, var list: MutableList<String>) {


    class InnerBean(var innerName: String) {
        override fun toString(): String {
            return "InnerBean(innerName='$innerName')"
        }
    }

    override fun toString(): String {
        return "OutBean(outName='$outName', age=$age, bean=$bean, list=$list)"
    }
}

fun main() {

    val gson = Gson()
    val json = gson.toJson(mutableListOf(OutBean("xujiafeng", 12, OutBean.InnerBean("innerXujiafeng"), mutableListOf("1", "3")),
            OutBean("lihua", 24, OutBean.InnerBean("innerLihua"), mutableListOf("asd", "eds"))))

    val goodGson = GsonBuilder()
            .registerTypeAdapterFactory(NoReflectTypeAdapterFactory())
            .create()
    var list: List<OutBean> = goodGson.fromJson(json, (object : TypeToken<List<OutBean>>() {}).getType())
    println(list)
    //效率测试
    val mutableList = mutableListOf<OutBean>()
    for (i in 0..1000000) {
        mutableList.add(OutBean("xujiafeng" + i, i, OutBean.InnerBean("innerxujiafeng" + i), mutableListOf("1", "2")))
    }

    val bigJson = gson.toJson(mutableList)

    var a = {
        val startTime = System.currentTimeMillis()
        var goodResult: List<OutBean> = goodGson.fromJson(bigJson, (object : TypeToken<List<OutBean>>() {}).getType())
        val endTime = System.currentTimeMillis()
        println("take time good " + (endTime - startTime))
    }.invoke()

    var badGson = Gson()
    var b = {
        val startTime = System.currentTimeMillis()
        var result: List<OutBean> = badGson.fromJson(bigJson, (object : TypeToken<List<OutBean>>() {}).getType())
        val endTime = System.currentTimeMillis()
        println("take time " + (endTime - startTime))
    }.invoke()


}

class NoReflectTypeAdapterFactory : TypeAdapterFactory {
    override fun <T : Any?> create(gson: Gson?, type: TypeToken<T>?): TypeAdapter<T>? {
        if (OutBean::class.java.equals(type?.rawType)) {
            return NoReflectTypeAdapter(gson, type?.rawType)
        }
        if (OutBean.InnerBean::class.java.equals(type?.rawType)) {
            return NoReflectTypeAdapter(gson, type?.rawType)
        }
        return null
    }
}

class NoReflectTypeAdapter<T>(var gson: Gson?, var rawType: Class<in T>?) : TypeAdapter<T>() {
    override fun write(out: JsonWriter?, value: T) {

    }
    init {
        println("invoke")
    }

    var obj: TypeToken<List<String>> = object : TypeToken<List<String>>() {}
    val adapter: TypeAdapter<in List<String>>? = gson?.getAdapter(obj.rawType)

    override fun read(input: JsonReader?): T? {
        if (input!!.peek() == JsonToken.NULL) {
            input.nextNull()
            return null
        }

        try {
            when (rawType) {
                OutBean::class.java -> {
                    var outName = ""
                    var age = 0
                    var bean: OutBean.InnerBean? = null
                    var list: MutableList<String>? = null
                    input.beginObject()
                    while (input.hasNext()) {
                        when (input.nextName()) {
                            "outName" -> outName = input.nextString()
                            "age" -> age = input.nextInt()
                            "bean" -> bean = gson?.getAdapter(OutBean.InnerBean::class.java)?.read(input)
                            "list" -> {
                                list = adapter?.read(input) as MutableList<String>
                            }
                        }
                    }
//                    println("init TestBean")
                    return OutBean(outName, age, bean!!, list!!) as T
                }
                OutBean.InnerBean::class.java -> {
                    var innerName = ""
                    input.beginObject()
                    while (input.hasNext()) {
                        when (input.nextName()) {
                            "innerName" -> innerName = input.nextString()
                        }
                    }
//                    println("init InnerBean")
                    return OutBean.InnerBean(innerName) as T
                }
            }
        } catch (e: IllegalStateException) {
            throw JsonSyntaxException(e)
        } catch (e: IllegalAccessException) {
            throw AssertionError(e)
        } finally {
            input.endObject()
        }
        return null
    }


}

但是目前的实现，跟原本的比起来耗时并没有减少。。。。所以还需要优化

然后就是自动化的问题，目前有两个想法，第一，apt生成如上代码，第二，asm来实现。

本来也想用小缘的方案，但是实际测试了一下，json转成bean，log打印 systemclock 线程时间，主线程耗时不超过1ms。。pass了 ，是我统计有问题？