如何使用AWS Ion序列化IonStruct并通过BLE传输？

1. 引入AWS Ion依赖 #

以Android/Java项目为例，先引入ion-java库（Python项目可使用ion-python，核心逻辑一致），Gradle依赖配置如下：

implementation 'software.amazon.ion:ion-java:1.10.1'

2. 序列化IonStruct为二进制数据 #

AWS Ion自带自描述特性，无需预定义Schema，直接构建IonStruct并序列化即可。示例代码：

import software.amazon.ion.IonStruct;
import software.amazon.ion.IonSystem;
import software.amazon.ion.IonWriter;
import software.amazon.ion.system.IonSystemBuilder;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

public class IonSerialization {
    private static final IonSystem ION_SYSTEM = IonSystemBuilder.standard().build();

    public static byte[] serializeStruct() throws IOException {
        // 构建自描述结构体，支持多数据类型字段
        IonStruct dataStruct = ION_SYSTEM.newEmptyStruct();
        dataStruct.put("sensor_id", ION_SYSTEM.newString("temp_001"));
        dataStruct.put("reading", ION_SYSTEM.newFloat(25.6));
        dataStruct.put("timestamp", ION_SYSTEM.newTimestamp(System.currentTimeMillis()));
        dataStruct.put("is_active", ION_SYSTEM.newBool(true));

        // 序列化为二进制Ion数据
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        try (IonWriter writer = ION_SYSTEM.newBinaryWriter(outputStream)) {
            writer.writeValue(dataStruct);
        }
        return outputStream.toByteArray();
    }
}

3. BLE传输的帧处理（分片与重组） #

BLE存在MTU（最大传输单元）限制（通常20-512字节），需将序列化后的二进制数据拆分为符合MTU的帧，同时添加帧标识保证重组：

发送端分片逻辑

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class BleFrameHandler {
    public static List<byte[]> splitIntoBleFrames(byte[] ionData, int mtuSize) {
        List<byte[]> frames = new ArrayList<>();
        int framePayloadSize = mtuSize - 3; // 预留3字节帧头：总帧数、当前帧号、结束标记
        int totalFrames = (int) Math.ceil((double) ionData.length / framePayloadSize);

        for (int i = 0; i < totalFrames; i++) {
            int start = i * framePayloadSize;
            int end = Math.min(start + framePayloadSize, ionData.length);
            byte[] payload = Arrays.copyOfRange(ionData, start, end);
            
            // 构建帧：[总帧数][当前帧号][是否最后一帧（1是/0否）]+负载
            byte[] frame = new byte[3 + payload.length];
            frame[0] = (byte) totalFrames;
            frame[1] = (byte) (i + 1); // 帧号从1开始计数
            frame[2] = (i == totalFrames - 1) ? (byte) 1 : (byte) 0;
            System.arraycopy(payload, 0, frame, 3, payload.length);
            
            frames.add(frame);
        }
        return frames;
    }
}

发送时遍历帧列表，逐个通过BLE特征发送即可。

接收端重组逻辑

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.io.ByteArrayOutputStream;

public class BleFrameHandler {
    public static byte[] reassembleIonData(List<byte[]> receivedFrames) {
        // 按帧号排序，确保重组顺序正确
        receivedFrames.sort(Comparator.comparing(f -> f[1]));
        
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        for (byte[] frame : receivedFrames) {
            byte[] payload = Arrays.copyOfRange(frame, 3, frame.length);
            outputStream.write(payload, 0, payload.length);
            
            // 检测到最后一帧时终止重组
            if (frame[2] == 1) {
                break;
            }
        }
        return outputStream.toByteArray();
    }
}

4. 反序列化与随机访问 #

拿到重组后的完整二进制数据后，可反序列化为IonStruct，或直接随机访问目标字段（无需解析整个结构体）：

import software.amazon.ion.IonStruct;
import software.amazon.ion.IonReader;
import software.amazon.ion.system.IonSystemBuilder;
import java.io.IOException;

public class IonDeserialization {
    private static final IonSystem ION_SYSTEM = IonSystemBuilder.standard().build();

    // 完整反序列化结构体
    public static IonStruct deserializeStruct(byte[] ionData) throws IOException {
        try (IonReader reader = ION_SYSTEM.newBinaryReader(ionData)) {
            reader.next();
            return (IonStruct) ION_SYSTEM.newValue(reader);
        }
    }

    // 随机访问指定字段示例：直接读取传感器读数
    public static float getSensorReading(byte[] ionData) throws IOException {
        try (IonReader reader = ION_SYSTEM.newBinaryReader(ionData)) {
            reader.next();
            reader.stepIn(); // 进入结构体内部
            while (reader.next() != null) {
                if ("reading".equals(reader.getFieldName())) {
                    return reader.floatValue();
                }
            }
            return Float.NaN;
        }
    }
}

关键注意事项 #

• 自描述特性：二进制Ion自带类型元信息，接收端无需提前知晓字段结构即可解析。
• 随机访问：通过IonReader可直接定位目标字段，无需遍历整个结构体，适合资源受限的BLE设备。
• MTU适配：实际传输前需协商BLE设备的MTU大小，避免帧过大导致传输失败。

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