Serialization Avro日期对象的序列化异常（日期逻辑类型）

我有一个接受GenericRecord类的发布者

@Override
public Future<RecordMetadata> publish(GenericRecord genericRecord) {
    Future<RecordMetadata> recordMetadataFuture =
            getPublisher().send(new ProducerRecord<>(producerConfiguration.getProperties()
                    .getProperty(ProducerConfiguration.PROPERTY_NAME_TOPIC), "sample.key",genericRecord));

    return recordMetadataFuture;
}

private KafkaProducer<String, GenericRecord> getPublisher() {
    return new KafkaProducer<>(producerConfiguration.getProperties());
}

我已经构建了自己的序列化程序：

日期序列化程序：

@Component
public class SampleDateSerializer implements Serializer<GenericRecord> {

private AvroGenericSerializer serializer;

@Override
public void configure(Map<String, ?> configs, boolean isKey) {
    serializer = new AvroGenericSerializer(SampleDate.SCHEMA$);
}

@Override
public byte[] serialize(String topic, GenericRecord data) {
    return serializer.serialize(data);
}

@Override
public void close() {

}

public class AvroGenericSerializer {
private EncoderFactory avroEncoderFactory;
private DecoderFactory avroDecoderFactory;
private GenericDatumWriter<GenericRecord> avroWriter;
private GenericDatumReader<GenericRecord> avroReader;

public AvroGenericSerializer(Schema schema) {
    avroEncoderFactory = EncoderFactory.get();
    avroDecoderFactory = DecoderFactory.get();
    avroWriter = new GenericDatumWriter<>(schema);
    avroReader = new GenericDatumReader<>(schema);
}

public byte[] serialize(GenericRecord data) {
    final ByteArrayOutputStream stream = new ByteArrayOutputStream();
    final BinaryEncoder binaryEncoder = avroEncoderFactory.binaryEncoder(stream, null);
    try {
        avroWriter.write(data, binaryEncoder);
        binaryEncoder.flush();
        stream.close();
        return stream.toByteArray();
    } catch (IOException e) {
        throw new RuntimeException("Can't serialize Avro object", e);
    }
}

public GenericRecord deserialize(byte[] bytes) {
    try {
        return avroReader.read(null, avroDecoderFactory.binaryDecoder(bytes, null));
    } catch (IOException e) {
        throw new RuntimeException("Can't deserialize Avro object", e);
    }
 }
}

调试代码时，我发现

GenericDatumWriter.write()...

方法在调用

Conversion conversion = this.getData().getConversionByClass(datum.getClass(), logicalType);

这是从

    org.apache.avro.generic.GenericData

    public <T> Conversion<T> getConversionByClass(Class<T> datumClass, LogicalType logicalType) {
    Map conversions = (Map)this.conversionsByClass.get(datumClass);
    return conversions != null?(Conversion)conversions.get(logicalType.getName()):null;
}

映射，以便它可以返回正确的转换器以用于给定的

 date logicalType?

---

我通过在GenericDatumWriter中传递GenericData对象解决了这个问题

我的通用序列化程序现在如下所示：

    public AvroGenericSerializer(Schema schema) {
    avroEncoderFactory = EncoderFactory.get();
    avroDecoderFactory = DecoderFactory.get();
    final GenericData genericData = new GenericData();
    genericData.addLogicalTypeConversion(new TimeConversions.DateConversion());
    avroWriter = new GenericDatumWriter<>(schema, genericData);
    avroReader = new GenericDatumReader<>(schema);
}

public AvroGenericSerializer（模式）{
avroEncoderFactory=EncoderFactory.get（）；
avroDecoderFactory=DecoderFactory.get（）；
最终GenericData GenericData=新的GenericData（）；
genericData.addLogicalTypeConversion（新的TimeConversions.DateConversion（））；
avroWriter=新的GenericDatumWriter（模式，genericData）；
avroReader=新的GenericDatumReader（模式）；
}

我通过在GenericDatumWriter中传递GenericData对象解决了这个问题

我的通用序列化程序现在如下所示：

    public AvroGenericSerializer(Schema schema) {
    avroEncoderFactory = EncoderFactory.get();
    avroDecoderFactory = DecoderFactory.get();
    final GenericData genericData = new GenericData();
    genericData.addLogicalTypeConversion(new TimeConversions.DateConversion());
    avroWriter = new GenericDatumWriter<>(schema, genericData);
    avroReader = new GenericDatumReader<>(schema);
}

public AvroGenericSerializer（模式）{
avroEncoderFactory=EncoderFactory.get（）；
avroDecoderFactory=DecoderFactory.get（）；
最终GenericData GenericData=新的GenericData（）；
genericData.addLogicalTypeConversion（新的TimeConversions.DateConversion（））；
avroWriter=新的GenericDatumWriter（模式，genericData）；
avroReader=新的GenericDatumReader（模式）；
}

 date logicalType?

    public AvroGenericSerializer(Schema schema) {
    avroEncoderFactory = EncoderFactory.get();
    avroDecoderFactory = DecoderFactory.get();
    final GenericData genericData = new GenericData();
    genericData.addLogicalTypeConversion(new TimeConversions.DateConversion());
    avroWriter = new GenericDatumWriter<>(schema, genericData);
    avroReader = new GenericDatumReader<>(schema);
}