Flutter原理篇：硬核-从Platform到Dart通信原理分析之Android篇

哈喽大家好，新年又见面了，不知道大家有没有想我呢，我可是一有空就想着为大家更新博客呢，上一期给大家分享了 ，本来说这期应该是接上一期分享 ，但是今天咋们插入一篇《从Platform到Dart通信原理分析之Android篇》来说一说从Native也就是PlatForm端到Dart的通信原理，这个也是我一直都想写的内容了，好了让我们愉快的开始吧

其实经常逛论坛的都知道已经有一些文章分析过了这个的运行原理了为什么我还要写呢，

• 一个我觉得他们水平没有问题但是博客里面有一些小的漏洞，小瑕疵作为有洁癖，不将就的工程师，大家肯定不是很满意

• 第二也是最关键的一点就是那些文章基本上是一气呵成的要不就是作者没有设计到更深入的层次去分析，而是点到而止就“打道回府”了，要么就是水平很高但是内容不够详细丰富，特别是不够通俗易懂的去给讲解，导致大家看了他们写的文章以后有一种“失落”的感觉，觉得大致都能看懂但就是理解不了什么意思，于是就有了我们今天这篇文章，看我能不能带着大家 通·俗·易·懂· 的去理解一下这个原理的过程，我保证绝对会让大家看完以后长舒一口气感叹：“原来原理就是这么的‘简单’啊”，希望大家在末尾给我评论留言，every body let’s go

说到了运行原理，那么我们就带大家来复习一下从Platform到Dart的使用会基本用到的几个类，来作为文章的预热：首先我们要知道的是一般来说Native到Flutter端相互通信有三种调用的方式，也就是三种不同的Channel，两端通过同一个Channel来进行互相的通信，分别是一下三个Channel：

• BasicMessageChannel：用于传递字符串和半结构化的信息。
• MethodChannel：用于传递方法调用（method invocation）。
• EventChannel: 用于数据流（event streams）的通信。

三种Channel之间互相独立，各有用途，但它们在设计上却非常相近，所以我们分析的时候可能就只会分析几种情况即可，不会所有的情况都分析到

好了说了这么多，咋们再来看看这三个通道的基本使用：MethodChanel，BasicMessageChannel，EventChannel这三个通道在Dart端以及Platform端都有对应相同名字的类来作为双方通信/接收的使用，我们以BasicMessageChannel来举例子：Dart端以及Android端首先都需要实例化这个Channel并且名字也要一样，并且都需要提供一个send发送方法，以及一个接收的方法来作为监听，例如：

BasicMessageChannel Dart端代码片段：

//初始化
static const BasicMessageChannel _basicMessageChannel =
    const BasicMessageChannel('BasicMessageChannelPlugin', StringCodec());

//设置监听函数
_basicMessageChannel
    .setMessageHandler((String message) => Future(() {
          setState(() {
            showMessage = 'BasicMessageChannel:'+message;
          });
          return "收到Native的消息ab：" + message;
        }));


//向Native端发送消息
response = await _basicMessageChannel.send(value);

BasicMessageChannel Android端代码片段：

//初始化
this.messageChannel = new BasicMessageChannel<>(messenger, "BasicMessageChannelPlugin", StringCodec.INSTANCE);

//设置监听函数
@Override
public void onMessage(String s, BasicMessageChannel.Reply reply) {//处理Dart发来的消息
    reply.reply("BasicMessageChannel收到：" + s);//可以通过reply进行回复
    if (activity instanceof IShowMessage) {
        ((IShowMessage) activity).onShowMessage(s);
    }
    Toast.makeText(activity, s, Toast.LENGTH_SHORT).show();
}

//向Dart端发送消息
messageChannel.send(message, callback);

好了，使用就是这么简单，我们现从双方的构造方法开始说起，不论是Dart端还是Native端的构造函数都需要这三个元素：

• name: String类型，代表Channel的名字，也是其唯一标识符。
• messager：BinaryMessenger类型，代表消息信使，是消息的发送与接收的工具。
• codec: MessageCodec类型或MethodCodec类型，代表消息的编解码器。

1. Channel name
   一个Flutter应用中可能存在多个不同的Channel，每个Channel在创建时必须指定一个独一无二的name，Channel之间使用name来区分彼此，当有消息从Flutter端发送到Native端时会根据其传递过来的channel name找到该Channel对应的Handler（消息处理器）

2. 消息信使:BinaryMessenger

Pasted Graphic.png

虽然三种Channel各有用途，但是他们与Flutter通信的工具却是相同的，均为BinaryMessager，在Dart端默认是_DefaultBinaryMessenger，在Android端默认是DartExecutor

3. MessageCodec
   MessageCodec用于二进制格式数据与基础数据之间的编解码，BasicMessageChannel所使用的编解码器默认就是MessageCodec

---

我们重点看看后面两个，先来看看BinaryMessager的使用：

BinaryMessager:

在Dart端默认是_DefaultBinaryMessenger

class _DefaultBinaryMessenger extends BinaryMessenger {
}

在Android端默认是DartExecutor

public class DartExecutor implements BinaryMessenger {
  private static final String TAG = "DartExecutor";
}

BinaryMessenger是Platform端与Flutter端通信的中间人，其通信使用的消息格式为二进制格式数据（理解这个很重要，这个也是数据传递的核心），当我们初始化一个Channel，并向该Channel注册处理消息的Handler时，实际上会生成一个与之对应的BinaryMessageHandler，并以channel name为key，注册到BinaryMessenger中：

Android的注册步骤：

public class EventChannelPlugin implements EventChannel.StreamHandler {
    private EventChannel.EventSink eventSink;

    static EventChannelPlugin registerWith(BinaryMessenger messenger) {
        EventChannelPlugin plugin = new EventChannelPlugin();
        new EventChannel(messenger, "EventChannelPlugin").setStreamHandler(plugin);
        return plugin;
    }
}

Android的messenger 默认是DartExecutor

public void setStreamHandler(final StreamHandler handler) {
  messenger.setMessageHandler(
      name, handler == null ? null : new IncomingStreamRequestHandler(handler));
}

最终是存在DartMessenger里面的messageHandlers Map里面

class DartMessenger implements BinaryMessenger, PlatformMessageHandler {
  private static final String TAG = "DartMessenger";

  @NonNull private final FlutterJNI flutterJNI;
  @NonNull private final Map messageHandlers;
  @NonNull private final Map pendingReplies;
  private int nextReplyId = 1;

  DartMessenger(@NonNull FlutterJNI flutterJNI) {
    this.flutterJNI = flutterJNI;
    this.messageHandlers = new HashMap<>();
    this.pendingReplies = new HashMap<>();
  }

  @Override
  public void setMessageHandler(
      @NonNull String channel, @Nullable BinaryMessenger.BinaryMessageHandler handler) {
    if (handler == null) {
      Log.v(TAG, "Removing handler for channel '" + channel + "'");
      messageHandlers.remove(channel);
    } else {
      Log.v(TAG, "Setting handler for channel '" + channel + "'");
      messageHandlers.put(channel, handler);
    }
  }
}

差不多就是这两个方法了，很简单不再赘述，好了再说回来我们再看看Dart方面的BinaryMessenger与BinaryMessageHandler是怎么样的呢，上面说了BinaryMessenger默认是_DefaultBinaryMessenger，我们来看看他的注册setMessageHandler方法：

BasicMessageChannel.setMessageHandler：

/// Sets a callback for receiving messages from the platform plugins on this
/// channel. Messages may be null.
///
/// The given callback will replace the currently registered callback for this
/// channel, if any. To remove the handler, pass null as the `handler`
/// argument.
///
/// The handler's return value is sent back to the platform plugins as a
/// message reply. It may be null.
void setMessageHandler(Future Function(T? message)? handler) {
  if (handler == null) {
    binaryMessenger.setMessageHandler(name, null);
  } else {
    binaryMessenger.setMessageHandler(name, (ByteData? message) async {
      return codec.encodeMessage(await handler(codec.decodeMessage(message)));
    });
  }
}

_DefaultBinaryMessenger.setMessageHandler：

@override
void setMessageHandler(String channel, MessageHandler? handler) {
  if (handler == null) {
    _handlers.remove(channel);
  } else {
    _handlers[channel] = handler;
    ui.channelBuffers.drain(channel, (ByteData? data, ui.PlatformMessageResponseCallback callback) async {
      await handlePlatformMessage(channel, data, callback);
    });
  }
}

把MessageHandler存在了 static final Map _handlers = {}; 之中

上面说的是注册，我们看看监听是什么样子的：

当Dart端发送消息到Android端的BinaryMessenger时，BinaryMessenger会根据其入参channel找到对应的BinaryMessageHandler，并交由其处理，我们看看Android端是什么样的

DartMessenger.handleMessageFromDart

@Override
public void handleMessageFromDart(
    @NonNull final String channel, @Nullable byte[] message, final int replyId) {
  Log.v(TAG, "Received message from Dart over channel '" + channel + "'");
  BinaryMessenger.BinaryMessageHandler handler = messageHandlers.get(channel);
  if (handler != null) {
    try {
      Log.v(TAG, "Deferring to registered handler to process message.");
      final ByteBuffer buffer = (message == null ? null : ByteBuffer.wrap(message));
      handler.onMessage(buffer, new Reply(flutterJNI, replyId));
    } catch (Exception ex) {
      Log.e(TAG, "Uncaught exception in binary message listener", ex);
      flutterJNI.invokePlatformMessageEmptyResponseCallback(replyId);
    } catch (Error err) {
      handleError(err);
    }
  } else {
    Log.v(TAG, "No registered handler for message. Responding to Dart with empty reply message.");
    flutterJNI.invokePlatformMessageEmptyResponseCallback(replyId);
  }
}

他会通过messageHandlers取出来对应的BinaryMessageHandler，调用其注册的onMessage方法（如果忘记了使用的话，可以往上查看Android端的使用步骤）

现在再去看看当Android端发送消息到Dart端的BinaryMessenger时他的处理是怎么样的呢：

@override
Future handlePlatformMessage(
  String channel,
  ByteData? data,
  ui.PlatformMessageResponseCallback? callback,
) async {
  ByteData? response;
  try {
    final MessageHandler? handler = _handlers[channel];
    if (handler != null) {
      response = await handler(data);
    } else {
      ui.channelBuffers.push(channel, data, callback!);
      callback = null;
    }
  } catch (exception, stack) {
    FlutterError.reportError(FlutterErrorDetails(
      exception: exception,
      stack: stack,
      library: 'services library',
      context: ErrorDescription('during a platform message callback'),
    ));
  } finally {
    if (callback != null) {
      callback(response);
    }
  }
}

在Dart端通过也是根据channel的名字从_handlers取出MessageHandler直接调用await handler(data); 方法，等待监听方法返回数据然后再通过callback传回给Android端

好了上面我们看了Android与Dart两端简单注册以及收发消息的步骤，现在我们再来看看上面提到的另一个元素编解码器Codec：

---

MessageCodec：

MessageCodec用于二进制格式数据与基础数据之间的编解码，BasicMessageChannel所使用的编解码器默认就是MessageCodec，MessageCodec有多种不同的实现，分为以下几种：

• BinaryCodec

BinaryCodec是最为简单的一种Codec，因为其返回值类型和入参的类型相同，均为二进制格式（Android中为ByteBuffer，iOS中为NSData）实际上，BinaryCodec在编解码过程中什么都没做，只是原封不动将二进制数据消息返回而已，或许你会因此觉得BinaryCodec没有意义，但是在某些情况下它非常有用，比如使用BinaryCodec可以使传递内存数据块时在编解码阶段免于内存拷贝

Android部分

public final class BinaryCodec implements MessageCodec {
  // This codec must match the Dart codec of the same name in package flutter/services.
  public static final BinaryCodec INSTANCE = new BinaryCodec();

  private BinaryCodec() {}

  @Override
  public ByteBuffer encodeMessage(ByteBuffer message) {
    return message;
  }

  @Override
  public ByteBuffer decodeMessage(ByteBuffer message) {
    return message;
  }
}

Dart部分

class BinaryCodec implements MessageCodec {
  /// Creates a [MessageCodec] with unencoded binary messages represented using
  /// [ByteData].
  const BinaryCodec();

  @override
  ByteData? decodeMessage(ByteData? message) => message;

  @override
  ByteData? encodeMessage(ByteData? message) => message;
}

都是直接返回数据，代码太简单不解释了

• StringCodec
  StringCodec用于字符串与二进制数据之间的编解码，其编码格式默认为UTF-8 ：

Dart部分

class StringCodec implements MessageCodec {
  /// Creates a [MessageCodec] with UTF-8 encoded String messages.
  const StringCodec();

  @override
  String? decodeMessage(ByteData? message) {
    if (message == null)
      return null;
    return utf8.decoder.convert(message.buffer.asUint8List(message.offsetInBytes, message.lengthInBytes));
  }

  @override
  ByteData? encodeMessage(String? message) {
    if (message == null)
      return null;
    final Uint8List encoded = utf8.encoder.convert(message);
    return encoded.buffer.asByteData();
  }
}

Android部分

public final class StringCodec implements MessageCodec {
  private static final Charset UTF8 = Charset.forName("UTF8");
  public static final StringCodec INSTANCE = new StringCodec();

  private StringCodec() {}

  @Override
  public ByteBuffer encodeMessage(String message) {
    if (message == null) {
      return null;
    }
    // TODO(mravn): Avoid the extra copy below.
    final byte[] bytes = message.getBytes(UTF8);
    final ByteBuffer buffer = ByteBuffer.allocateDirect(bytes.length);
    buffer.put(bytes);
    return buffer;
  }

  @Override
  public String decodeMessage(ByteBuffer message) {
    if (message == null) {
      return null;
    }
    final byte[] bytes;
    final int offset;
    final int length = message.remaining();
    if (message.hasArray()) {
      bytes = message.array();
      offset = message.arrayOffset();
    } else {
      // TODO(mravn): Avoid the extra copy below.
      bytes = new byte[length];
      message.get(bytes);
      offset = 0;
    }
    return new String(bytes, offset, length, UTF8);
  }
}

StringCodec默认都是UTF8进行编解码，代码也很简单不详细叙述

• JSONMessageCodec
  JSONMessageCodec用于基础数据与二进制数据之间的编解码，其支持基础数据类型以及列表、字典，在Android端则使用了其自定义的JSONTokener与StringCodec作为序列化工具。

Android部分 JsonCodec.encode / JsonCodec.decode

class JSONMessageCodec implements MessageCodec {
  // The codec serializes messages as defined by the JSON codec of the
  // dart:convert package. The format used must match the Android and
  // iOS counterparts.

  /// Creates a [MessageCodec] with UTF-8 encoded JSON messages.
  const JSONMessageCodec();

  @override
  ByteData? encodeMessage(Object? message) {
    if (message == null)
      return null;
    return const StringCodec().encodeMessage(json.encode(message));
  }

  @override
  dynamic decodeMessage(ByteData? message) {
    if (message == null)
      return message;
    return json.decode(const StringCodec().decodeMessage(message)!);
  }
}

Dart部分 JsonCodec.encode / JsonCodec.decode

String encode(Object? value, {Object? toEncodable(dynamic object)?}) {
  toEncodable ??= _toEncodable;
  if (toEncodable == null) return encoder.convert(value);
  return JsonEncoder(toEncodable).convert(value);
}


dynamic decode(String source,
    {Object? reviver(Object? key, Object? value)?}) {
  reviver ??= _reviver;
  if (reviver == null) return decoder.convert(source);
  return JsonDecoder(reviver).convert(source);
}

Dart与Android部分原理是一样的，编码首先通过JsonCodec.encode进行编码，然后再通过StringCodec 编码成ByteData；解码部分首先通过StringCodec解码成字符串再通过JsonCodec.decode解码Json字符串

• StandardMessageCodec
  StandardMessageCodec是BasicMessageChannel的默认编解码器，常见类型基本上都支持，使用方式稍微复杂一点我们重点介绍下

Dart部分StandardMessageCodec.encodeMessage / StandardMessageCodec.decodeMessage

@override
ByteData? encodeMessage(Object? message) {
  if (message == null)
    return null;
  final WriteBuffer buffer = WriteBuffer();
  writeValue(buffer, message);
  return buffer.done();
}


@override
dynamic decodeMessage(ByteData? message) {
  if (message == null)
    return null;
  final ReadBuffer buffer = ReadBuffer(message);
  final Object? result = readValue(buffer);
  if (buffer.hasRemaining)
    throw const FormatException('Message corrupted');
  return result;
}

Dart端通过WriteBuffer，ReadBuffer作为字符的基本写入与读取的数据结构的封装，然后通过writeValue，readValue写入以及读取数据

void writeValue(WriteBuffer buffer, Object? value) {
  if (value == null) {
    buffer.putUint8(_valueNull);
  } else if (value is bool) {
    buffer.putUint8(value ? _valueTrue : _valueFalse);
  } else if (value is double) {  // Double precedes int because in JS everything is a double.
                                 // Therefore in JS, both `is int` and `is double` always
                                 // return `true`. If we check int first, we'll end up treating
                                 // all numbers as ints and attempt the int32/int64 conversion,
                                 // which is wrong. This precedence rule is irrelevant when
                                 // decoding because we use tags to detect the type of value.
    buffer.putUint8(_valueFloat64);
    buffer.putFloat64(value);
  } else if (value is int) {
    if (-0x7fffffff - 1 <= value && value <= 0x7fffffff) {
      buffer.putUint8(_valueInt32);
      buffer.putInt32(value);
    } else {
      buffer.putUint8(_valueInt64);
      buffer.putInt64(value);
    }
  } else if (value is String) {
    buffer.putUint8(_valueString);
    final Uint8List bytes = utf8.encoder.convert(value);
    writeSize(buffer, bytes.length);
    buffer.putUint8List(bytes);
  } else if (value is Uint8List) {
    buffer.putUint8(_valueUint8List);
    writeSize(buffer, value.length);
    buffer.putUint8List(value);
  } else if (value is Int32List) {
    buffer.putUint8(_valueInt32List);
    writeSize(buffer, value.length);
    buffer.putInt32List(value);
  } else if (value is Int64List) {
    buffer.putUint8(_valueInt64List);
    writeSize(buffer, value.length);
    buffer.putInt64List(value);
  } else if (value is Float64List) {
    buffer.putUint8(_valueFloat64List);
    writeSize(buffer, value.length);
    buffer.putFloat64List(value);
  } else if (value is List) {
    buffer.putUint8(_valueList);
    writeSize(buffer, value.length);
    for (final Object? item in value) {
      writeValue(buffer, item);
    }
  } else if (value is Map) {
    buffer.putUint8(_valueMap);
    writeSize(buffer, value.length);
    value.forEach((Object? key, Object? value) {
      writeValue(buffer, key);
      writeValue(buffer, value);
    });
  } else {
    throw ArgumentError.value(value);
  }
}

writeValue首先先写入1个字节作为数据的类型，然后再写入数据本身的值；如果是“复杂”数据类型比如String，Uint8List，Int32List等等写入数据类型的同时还会写入数据的长度再写入数据的值；如果数据再“复杂”点比如List，Map最后会对他们的值（Map会对Key，value）分别再调用writeValue去写入；

Object? readValue(ReadBuffer buffer) {
  if (!buffer.hasRemaining)
    throw const FormatException('Message corrupted');
  final int type = buffer.getUint8();
  return readValueOfType(type, buffer);
}

/// Reads a value of the indicated [type] from [buffer].
///
/// The codec can be extended by overriding this method, calling super for
/// types that the extension does not handle. See the discussion at
/// [writeValue].
Object? readValueOfType(int type, ReadBuffer buffer) {
  switch (type) {
    case _valueNull:
      return null;
    case _valueTrue:
      return true;
    case _valueFalse:
      return false;
    case _valueInt32:
      return buffer.getInt32();
    case _valueInt64:
      return buffer.getInt64();
    case _valueFloat64:
      return buffer.getFloat64();
    case _valueLargeInt:
    case _valueString:
      final int length = readSize(buffer);
      return utf8.decoder.convert(buffer.getUint8List(length));
    case _valueUint8List:
      final int length = readSize(buffer);
      return buffer.getUint8List(length);
    case _valueInt32List:
      final int length = readSize(buffer);
      return buffer.getInt32List(length);
    case _valueInt64List:
      final int length = readSize(buffer);
      return buffer.getInt64List(length);
    case _valueFloat64List:
      final int length = readSize(buffer);
      return buffer.getFloat64List(length);
    case _valueList:
      final int length = readSize(buffer);
      final List result = List.filled(length, null, growable: false);
      for (int i = 0; i < length; i++)
        result[i] = readValue(buffer);
      return result;
    case _valueMap:
      final int length = readSize(buffer);
      final Map result = {};
      for (int i = 0; i < length; i++)
        result[readValue(buffer)] = readValue(buffer);
      return result;
    default: throw const FormatException('Message corrupted');
  }
}

readValue读取数据的时候就是一个逆向操作，先读取1个字节的数据类型，再读取数据的值，读取值的时候如果遇到“复杂”数据类型先读取他的长度在读取他的值，总之就是writeValue的逆操作，说完了Dart部分，让我们再来看看Android部分：

Android部分 StandardMessageCodec.encodeMessage / StandardMessageCodec.decodeMessage

@Override
public ByteBuffer encodeMessage(Object message) {
  if (message == null) {
    return null;
  }
  final ExposedByteArrayOutputStream stream = new ExposedByteArrayOutputStream();
  writeValue(stream, message);
  final ByteBuffer buffer = ByteBuffer.allocateDirect(stream.size());
  buffer.put(stream.buffer(), 0, stream.size());
  return buffer;
}


@Override
public Object decodeMessage(ByteBuffer message) {
  if (message == null) {
    return null;
  }
  message.order(ByteOrder.nativeOrder());
  final Object value = readValue(message);
  if (message.hasRemaining()) {
    throw new IllegalArgumentException("Message corrupted");
  }
  return value;
}

Android端通过ExposedByteArrayOutputStream作为字符的基本写入与读取的数据结构的封装，然后通过writeValue，readValue写入以及读取数据，ExposedByteArrayOutputStream 其实就是ByteArrayOutputStream的子类

protected void writeValue(ByteArrayOutputStream stream, Object value) {
  if (value == null || value.equals(null)) {
    stream.write(NULL);
  } else if (value instanceof Boolean) {
    stream.write(((Boolean) value).booleanValue() ? TRUE : FALSE);
  } else if (value instanceof Number) {
    if (value instanceof Integer || value instanceof Short || value instanceof Byte) {
      stream.write(INT);
      writeInt(stream, ((Number) value).intValue());
    } else if (value instanceof Long) {
      stream.write(LONG);
      writeLong(stream, (long) value);
    } else if (value instanceof Float || value instanceof Double) {
      stream.write(DOUBLE);
      writeAlignment(stream, 8);
      writeDouble(stream, ((Number) value).doubleValue());
    } else if (value instanceof BigInteger) {
      stream.write(BIGINT);
      writeBytes(stream, ((BigInteger) value).toString(16).getBytes(UTF8));
    } else {
      throw new IllegalArgumentException("Unsupported Number type: " + value.getClass());
    }
  } else if (value instanceof String) {
    stream.write(STRING);
    writeBytes(stream, ((String) value).getBytes(UTF8));
  } else if (value instanceof byte[]) {
    stream.write(BYTE_ARRAY);
    writeBytes(stream, (byte[]) value);
  } else if (value instanceof int[]) {
    stream.write(INT_ARRAY);
    final int[] array = (int[]) value;
    writeSize(stream, array.length);
    writeAlignment(stream, 4);
    for (final int n : array) {
      writeInt(stream, n);
    }
  } else if (value instanceof long[]) {
    stream.write(LONG_ARRAY);
    final long[] array = (long[]) value;
    writeSize(stream, array.length);
    writeAlignment(stream, 8);
    for (final long n : array) {
      writeLong(stream, n);
    }
  } else if (value instanceof double[]) {
    stream.write(DOUBLE_ARRAY);
    final double[] array = (double[]) value;
    writeSize(stream, array.length);
    writeAlignment(stream, 8);
    for (final double d : array) {
      writeDouble(stream, d);
    }
  } else if (value instanceof List) {
    stream.write(LIST);
    final List list = (List) value;
    writeSize(stream, list.size());
    for (final Object o : list) {
      writeValue(stream, o);
    }
  } else if (value instanceof Map) {
    stream.write(MAP);
    final Map map = (Map) value;
    writeSize(stream, map.size());
    for (final Entry entry : map.entrySet()) {
      writeValue(stream, entry.getKey());
      writeValue(stream, entry.getValue());
    }
  } else {
    throw new IllegalArgumentException("Unsupported value: " + value);
  }
}

writeValue首先先写入1个字节作为数据的类型，然后再写入数据本身的值；如果是“复杂”数据类型比如String，写入数据类型的同时还会写入数据的长度再写入数据的值；如果是数组的话还会先写入对齐字符，他的长度大小是数据元素的单个长度大小；如果数据再“复杂”点比如List，Map最后会对他们的值（Map会对Key，value）分别再调用writeValue去写入；

Object? readValue(ReadBuffer buffer) {
  if (!buffer.hasRemaining)
    throw const FormatException('Message corrupted');
  final int type = buffer.getUint8();
  return readValueOfType(type, buffer);
}

/// Reads a value of the indicated [type] from [buffer].
///
/// The codec can be extended by overriding this method, calling super for
/// types that the extension does not handle. See the discussion at
/// [writeValue].
Object? readValueOfType(int type, ReadBuffer buffer) {
  switch (type) {
    case _valueNull:
      return null;
    case _valueTrue:
      return true;
    case _valueFalse:
      return false;
    case _valueInt32:
      return buffer.getInt32();
    case _valueInt64:
      return buffer.getInt64();
    case _valueFloat64:
      return buffer.getFloat64();
    case _valueLargeInt:
    case _valueString:
      final int length = readSize(buffer);
      return utf8.decoder.convert(buffer.getUint8List(length));
    case _valueUint8List:
      final int length = readSize(buffer);
      return buffer.getUint8List(length);
    case _valueInt32List:
      final int length = readSize(buffer);
      return buffer.getInt32List(length);
    case _valueInt64List:
      final int length = readSize(buffer);
      return buffer.getInt64List(length);
    case _valueFloat64List:
      final int length = readSize(buffer);
      return buffer.getFloat64List(length);
    case _valueList:
      final int length = readSize(buffer);
      final List result = List.filled(length, null, growable: false);
      for (int i = 0; i < length; i++)
        result[i] = readValue(buffer);
      return result;
    case _valueMap:
      final int length = readSize(buffer);
      final Map result = {};
      for (int i = 0; i < length; i++)
        result[readValue(buffer)] = readValue(buffer);
      return result;
    default: throw const FormatException('Message corrupted');
  }
}

/** Reads a value as written by writeValue. */
protected final Object readValue(ByteBuffer buffer) {
  if (!buffer.hasRemaining()) {
    throw new IllegalArgumentException("Message corrupted");
  }
  final byte type = buffer.get();
  return readValueOfType(type, buffer);
}

/**
 * Reads a value of the specified type.
 *
 * 
Subclasses may extend the codec by overriding this method, calling super for types that the
 * extension does not handle.
 */
protected Object readValueOfType(byte type, ByteBuffer buffer) {
  final Object result;
  switch (type) {
    case NULL:
      result = null;
      break;
    case TRUE:
      result = true;
      break;
    case FALSE:
      result = false;
      break;
    case INT:
      result = buffer.getInt();
      break;
    case LONG:
      result = buffer.getLong();
      break;
    case BIGINT:
      {
        final byte[] hex = readBytes(buffer);
        result = new BigInteger(new String(hex, UTF8), 16);
        break;
      }
    case DOUBLE:
      readAlignment(buffer, 8);
      result = buffer.getDouble();
      break;
    case STRING:
      {
        final byte[] bytes = readBytes(buffer);
        result = new String(bytes, UTF8);
        break;
      }
    case BYTE_ARRAY:
      {
        result = readBytes(buffer);
        break;
      }
    case INT_ARRAY:
      {
        final int length = readSize(buffer);
        final int[] array = new int[length];
        readAlignment(buffer, 4);
        buffer.asIntBuffer().get(array);
        result = array;
        buffer.position(buffer.position() + 4 * length);
        break;
      }
    case LONG_ARRAY:
      {
        final int length = readSize(buffer);
        final long[] array = new long[length];
        readAlignment(buffer, 8);
        buffer.asLongBuffer().get(array);
        result = array;
        buffer.position(buffer.position() + 8 * length);
        break;
      }
    case DOUBLE_ARRAY:
      {
        final int length = readSize(buffer);
        final double[] array = new double[length];
        readAlignment(buffer, 8);
        buffer.asDoubleBuffer().get(array);
        result = array;
        buffer.position(buffer.position() + 8 * length);
        break;
      }
    case LIST:
      {
        final int size = readSize(buffer);
        final List