grpc-binder技术问询：如何从服务端向客户端发送Parcelable？

一、Metadata并非仅支持客户端→服务端 #

gRPC的Metadata是双向传递的：客户端发起请求时可以携带Header，服务端在响应过程中既可以通过响应Header发送数据，也可以在响应结束时通过Trailer传递信息，不存在单向限制。

二、服务端向客户端发送Parcelable数据的实现步骤 #

核心思路和客户端发送一致：将Parcelable序列化为字节数组，再通过Metadata传递，具体操作如下：

1. 定义统一的Metadata Key #

确保客户端和服务端使用相同的Key名称与类型，可直接复用ParcelableUtils.metadataKey，也可自定义：

// 自定义与客户端一致的Metadata Key，类型为字节数组
static final Metadata.Key<byte[]> PARCELABLE_DATA_KEY =
    Metadata.Key.of("grpc-parcelable-data", Metadata.BINARY_BYTE_MARSHALLER);

2. 服务端序列化Parcelable并写入Metadata #

在RPC方法实现中，完成Parcelable的序列化，再将其写入响应的Header或Trailer：

@Override
public void yourTargetRpcMethod(YourRequest request, StreamObserver<YourResponse> responseObserver) {
    // 1. 构造要发送的Parcelable对象
    YourParcelableBean parcelData = new YourParcelableBean();
    parcelData.setXXX("xxx");

    // 2. 将Parcelable序列化为字节数组
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    try {
        Parcel parcel = Parcel.obtain();
        parcelData.writeToParcel(parcel, 0);
        bos.write(parcel.marshall());
        parcel.recycle();
    } catch (IOException e) {
        responseObserver.onError(Status.INTERNAL.withCause(e).asException());
        return;
    }
    byte[] parcelBytes = bos.toByteArray();

    // 3. 写入Metadata并附加到响应
    Metadata responseMeta = new Metadata();
    responseMeta.put(PARCELABLE_DATA_KEY, parcelBytes);

    // 通过包装Observer实现Header/Trailer的发送
    responseObserver = new ForwardingStreamObserver<YourResponse>(responseObserver) {
        private boolean headersSent = false;

        @Override
        public void onNext(YourResponse value) {
            // 发送响应Header（在首次返回响应内容前发送）
            if (!headersSent) {
                headersSent = true;
                context().sendHeaders(responseMeta);
            }
            super.onNext(value);
        }

        @Override
        public void onCompleted() {
            // 若选择用Trailer发送，取消上方Header代码，启用此行
            // context().addTrailers(responseMeta);
            super.onCompleted();
        }
    };

    // 处理业务并返回主响应
    YourResponse response = YourResponse.newBuilder().build();
    responseObserver.onNext(response);
    responseObserver.onCompleted();
}

3. 客户端接收并反序列化 #

客户端在监听响应时，从Metadata中取出字节数组，反序列化为Parcelable对象：

yourGrpcStub.withWaitForReady().yourTargetRpcMethod(request, new StreamObserver<YourResponse>() {
    @Override
    public void onNext(YourResponse response) {
        // 处理主响应内容
    }

    @Override
    public void onError(Throwable t) {
        // 处理RPC错误
    }

    @Override
    public void onCompleted() {
        // 获取服务端返回的Trailer（若用Trailer传递）
        Metadata trailers = Status.fromThrowable(t).getTrailers();
        // 若用Header传递，需通过客户端拦截器或上下文获取Header
        // Metadata headers = ...

        if (trailers != null) {
            byte[] parcelBytes = trailers.get(PARCELABLE_DATA_KEY);
            if (parcelBytes != null) {
                Parcel parcel = Parcel.obtain();
                parcel.unmarshall(parcelBytes, 0, parcelBytes.length);
                parcel.setDataPosition(0);
                YourParcelableBean receivedData = YourParcelableBean.CREATOR.createFromParcel(parcel);
                parcel.recycle();
                // 使用反序列化后的对象
            }
        }
    }
});

关键注意事项 #

• 类一致性：客户端与服务端的Parcelable类必须完全一致（包名、字段、CREATOR实现），否则会反序列化失败。
• 数据大小：Metadata容量有限，不适合传递大体积的Parcelable对象，这类数据建议直接放入RPC响应体中。
• 异常处理：序列化、反序列化过程中要捕获异常，避免导致整个RPC调用失败。

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