4. MethodChannel 进阶：复杂参数传递与自定义编解码器

上一章我们聊了 MethodChannel 的基础用法，说白了就是传个字符串、数字这些小玩意儿。但实际项目中，哪有这么简单？

我记得刚接手一个电商项目时，Flutter 端要传一个完整的商品对象给 Android——里面有嵌套的 SKU 列表、图片地址数组、还有价格精度问题。直接用 Map 传？能跑，但维护起来简直噩梦。今天我们就来彻底解决这类问题。

4.1 复杂参数传递的三种姿势

先说说我常用的三种方式。每种都有适用场景，别死磕一种。

4.1.1 纯 Map 传递（简单粗暴）

最直接的方式。Flutter 端把数据塞进 Map<String, dynamic>，Android 端用 HashMap 接。

// Flutter 端
final result = await platform.invokeMethod('submitOrder', {
  'orderId': 'ORD2024001',
  'items': [
    {'sku': 'SKU001', 'quantity': 2, 'price': 99.9},
    {'sku': 'SKU002', 'quantity': 1, 'price': 199.9},
  ],
  'address': {
    'province': '广东',
    'city': '深圳',
    'detail': '南山区科技园'
  }
});

// Android 端
@Override
public void onMethodCall(@NonNull MethodCall call, @NonNull Result result) {
    if (call.method.equals("submitOrder")) {
        HashMap<String, Object> order = call.argument("order");
        ArrayList<HashMap<String, Object>> items = 
            (ArrayList<HashMap<String, Object>>) order.get("items");
        // 处理业务...
    }
}

4.1.2 JSON 字符串传递（通用但啰嗦）

把对象序列化成 JSON 字符串再传。好处是两端都能用成熟的 JSON 库，坏处是每次都要手动序列化/反序列化。

// Flutter 端
import 'dart:convert';

final jsonStr = jsonEncode({
  'orderId': 'ORD2024001',
  'items': [...]
});
final result = await platform.invokeMethod('submitOrderJson', jsonStr);

// Android 端
@Override
public void onMethodCall(@NonNull MethodCall call, @NonNull Result result) {
    if (call.method.equals("submitOrderJson")) {
        String jsonStr = call.argument("orderJson");
        // 用 Gson 或 Moshi 解析
        Order order = new Gson().fromJson(jsonStr, Order.class);
    }
}

我个人不太推荐这种方式。为什么？因为每次调用都要多一次序列化开销，而且 JSON 字符串在日志里看着特别长，调试起来眼睛疼。

4.1.3 二进制数据传递（高性能场景）

如果你要传图片、音频或者大量结构化数据，用 Uint8List 走二进制通道。我做过一个实时滤镜 App，每帧图像数据就是这么传的。

// Flutter 端
final imageBytes = await getImageAsBytes(); // Uint8List
final result = await platform.invokeMethod('processImage', imageBytes);

// Android 端
@Override
public void onMethodCall(@NonNull MethodCall call, @NonNull Result result) {
    if (call.method.equals("processImage")) {
        byte[] imageData = call.argument("imageData");
        // 直接操作字节数组，性能最优
    }
}

4.2 自定义编解码器：解决类型映射的终极方案

上面三种方式都有各自的痛点。有没有一种方法，能让 Flutter 的 Order 对象自动映射成 Android 的 Order 对象？

有。自定义 MessageCodec。

4.2.1 什么时候需要自定义编解码器？

• 你需要传递自定义对象，且不想手动拆 Map
• 标准类型映射满足不了你（比如传 BigInteger、UUID）
• 你想优化传输性能，减少不必要的装箱拆箱

4.2.2 实现一个自定义编解码器

我以传递 Order 对象为例，给你看看完整实现。

第一步：定义消息类型

// Flutter 端
class Order {
  final String orderId;
  final List<OrderItem> items;
  final double totalAmount;

  Order({required this.orderId, required this.items, required this.totalAmount});

  // 序列化
  Map<String, dynamic> toMap() => {
    'orderId': orderId,
    'items': items.map((e) => e.toMap()).toList(),
    'totalAmount': totalAmount,
  };

  // 反序列化
  factory Order.fromMap(Map<String, dynamic> map) => Order(
    orderId: map['orderId'],
    items: (map['items'] as List).map((e) => OrderItem.fromMap(e)).toList(),
    totalAmount: map['totalAmount'],
  );
}

// Android 端
public class Order implements Serializable {
    public String orderId;
    public List<OrderItem> items;
    public double totalAmount;
    
    // 构造方法、getter/setter 省略
}

第二步：实现自定义编解码器

// Android 端
public class OrderMessageCodec implements MessageCodec<Object> {
    
    private static final byte TYPE_ORDER = 100;  // 自定义类型标识
    private static final byte TYPE_ORDER_ITEM = 101;
    
    @Override
    public ByteBuffer encodeMessage(Object message) {
        if (message instanceof Order) {
            Order order = (Order) message;
            // 手动编码为字节流
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            buffer.put(TYPE_ORDER);
            writeString(buffer, order.orderId);
            writeList(buffer, order.items);
            buffer.putDouble(order.totalAmount);
            buffer.flip();
            return buffer;
        }
        // 其他类型走默认编码
        return null;
    }
    
    @Override
    public Object decodeMessage(ByteBuffer message) {
        if (message == null) return null;
        byte type = message.get();
        if (type == TYPE_ORDER) {
            String orderId = readString(message);
            List<OrderItem> items = readOrderItemList(message);
            double totalAmount = message.getDouble();
            return new Order(orderId, items, totalAmount);
        }
        return null;
    }
    
    // 辅助方法：读写字符串、列表等
    private void writeString(ByteBuffer buffer, String str) { ... }
    private String readString(ByteBuffer buffer) { ... }
    private void writeList(ByteBuffer buffer, List<?> list) { ... }
    private List<OrderItem> readOrderItemList(ByteBuffer buffer) { ... }
}

第三步：使用自定义编解码器创建 MethodChannel

// Android 端
MethodChannel channel = new MethodChannel(
    flutterEngine.getDartExecutor().getBinaryMessenger(),
    "com.example/order_channel",
    new OrderMessageCodec()  // 传入自定义编解码器
);

// Flutter 端
// 注意：Flutter 端目前不支持直接传入自定义 MessageCodec
// 需要配合 BinaryMessenger 的 send 方法手动编解码
// 或者使用 MethodChannel 的默认编解码器 + 手动转换

4.3 实战：传递带泛型的复杂对象

有一次我在做数据报表功能，需要传递 List<Map<String, dynamic>> 这种嵌套结构。标准 MethodChannel 其实能处理，但有个隐藏问题——泛型擦除。

你想想看，Flutter 端传过来一个 List，Android 端拿到的是 ArrayList，但里面的元素类型是什么？没人知道。如果你期望里面是 Map，结果混进来一个 String，运行时直接 ClassCastException。

我的解决方案是：在自定义编解码器里加一层类型校验。

// 在 decodeMessage 中增加类型检查
@Override
public Object decodeMessage(ByteBuffer message) {
    // ... 解码逻辑
    if (decodedObject instanceof List) {
        List<?> list = (List<?>) decodedObject;
        for (Object item : list) {
            if (!(item instanceof Map)) {
                throw new IllegalArgumentException("列表元素必须是 Map 类型");
            }
        }
    }
    return decodedObject;
}

4.4 性能对比与选型建议

传递方式	开发效率	运行时性能	类型安全	适用场景
纯 Map	高	中	低	简单数据、快速原型
JSON 字符串	中	低（多一次序列化）	中	跨平台通用、调试方便
二进制数据	低	高	高	图片、音频、大量数据
自定义编解码器	低（开发成本高）	最高	最高	核心业务、高频调用、复杂对象

我个人建议：80% 的场景用纯 Map 就够了。别一开始就上自定义编解码器，那是杀鸡用牛刀。等你发现 Map 传递导致性能瓶颈或者维护困难时，再针对性地优化那 20% 的热点路径。

嗯，关于 MethodChannel 的进阶内容就这些。记住一点：通信机制是为业务服务的，别为了炫技而过度设计。代码写得再漂亮，跑不起来也是白搭。

---

公众号:蓝海资料掘金营，微信deep3321