将Avro SpecificRecord转JSON字符串时过滤指定字段的方案咨询

方法1：基于Avro Schema修改+内置JSON序列化器 #

Avro的JSON序列化逻辑依赖Schema，我们可以通过构建只包含目标字段的新Schema，再用它来序列化原始对象，实现字段过滤。

步骤与示例代码：

import org.apache.avro.Schema;
import org.apache.avro.generic.GenericDatumWriter;
import org.apache.avro.io.DatumWriter;
import org.apache.avro.io.Encoder;
import org.apache.avro.io.JsonEncoder;
import org.apache.avro.specific.SpecificRecord;

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

public class AvroJsonFilter {
    public static String filterSpecificRecord(SpecificRecord record, List<String> keepFields) throws IOException {
        // 获取原始对象的Schema
        Schema originalSchema = record.getSchema();
        // 筛选需要保留的字段
        List<Schema.Field> filteredFields = new ArrayList<>();
        for (Schema.Field field : originalSchema.getFields()) {
            if (keepFields.contains(field.name())) {
                filteredFields.add(field);
            }
        }
        // 构建新的过滤后Schema
        Schema filteredSchema = Schema.createRecord(
                originalSchema.getName(),
                originalSchema.getDoc(),
                originalSchema.getNamespace(),
                originalSchema.isError()
        );
        filteredSchema.setFields(filteredFields);

        // 用新Schema序列化对象
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        DatumWriter<SpecificRecord> writer = new GenericDatumWriter<>(filteredSchema);
        Encoder encoder = JsonEncoderFactory.get().jsonEncoder(filteredSchema, out);
        writer.write(record, encoder);
        encoder.flush();
        return out.toString();
    }

    // 调用示例
    public static void main(String[] args) throws IOException {
        Event event = new Event();
        event.setA("valueA");
        event.setB("valueB");
        event.setC(123L);

        List<String> keepFields = List.of("A", "C");
        String filteredJson = filterSpecificRecord(event, keepFields);
        System.out.println(filteredJson); // 输出 {"A": "valueA", "C": 123}
    }
}

方法2：手动构建JSON（适合字段较少的场景） #

如果需要保留的字段不多，直接用JSON库（如Jackson、Gson）手动提取目标字段构建JSON，代码更直观简洁。

示例（基于Jackson）：

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;

public class ManualJsonFilter {
    private static final ObjectMapper objectMapper = new ObjectMapper();

    public static String filterEvent(Event event) {
        ObjectNode jsonNode = objectMapper.createObjectNode();
        jsonNode.put("A", event.getA());
        jsonNode.put("C", event.getC());
        try {
            return objectMapper.writeValueAsString(jsonNode);
        } catch (Exception e) {
            throw new RuntimeException("序列化JSON失败", e);
        }
    }

    // 调用示例
    public static void main(String[] args) {
        Event event = new Event();
        event.setA("valueA");
        event.setB("valueB");
        event.setC(123L);
        System.out.println(filterEvent(event));
    }
}

方法3：Jackson Avro模块+动态字段过滤 #

如果项目已经用Jackson处理JSON，可以结合Jackson的Avro模块和字段过滤规则实现需求。

步骤与示例代码：

1. 给Event类添加Jackson过滤注解：

import com.fasterxml.jackson.annotation.JsonFilter;

@JsonFilter("eventFilter")
public class Event extends org.apache.avro.specific.SpecificRecordBase implements org.apache.avro.specific.SpecificRecord {
    // 原有字段与方法...
}

2. 编写序列化逻辑：

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter;
import com.fasterxml.jackson.databind.ser.impl.SimpleFilterProvider;
import com.fasterxml.jackson.dataformat.avro.AvroModule;

public class JacksonAvroFilter {
    private static final ObjectMapper objectMapper;

    static {
        objectMapper = new ObjectMapper();
        objectMapper.registerModule(new AvroModule());
        // 配置过滤器，指定保留的字段
        SimpleFilterProvider filterProvider = new SimpleFilterProvider();
        filterProvider.addFilter("eventFilter", SimpleBeanPropertyFilter.filterOutAllExcept("A", "C"));
        objectMapper.setFilterProvider(filterProvider);
    }

    public static String filterEvent(Event event) {
        try {
            return objectMapper.writeValueAsString(event);
        } catch (Exception e) {
            throw new RuntimeException("序列化JSON失败", e);
        }
    }
}

方案选型建议 #

• 通用Avro对象过滤需求选方法1：基于Avro原生机制，不依赖额外JSON库，适配所有SpecificRecord子类
• 字段数量少的场景选方法2：代码量最少，逻辑直观，无需处理Schema
• 已使用Jackson生态的项目选方法3：可无缝集成到现有序列化流程中

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