从Java对象创建Avro字符串

我正在构建一个MapR ES Java producer，它通过JDBC连接到Oracle，并将结果集发布到流中

我想将填充的类对象序列化为Avro字符串，作为发布者的消息

我已经使用Maven Apache Avro插件为我的类对象生成了一个Avro字符串

Schema Schema=ReflectionData.get（）.getSchema（MyClass.class）

但是，如果我有一个完全填充的MyClass对象，如何生成一个带有模式和填充数据的Avro字符串

我还没有找到这方面的好例子。感谢您的帮助
 假设我在java中反射了Customer类

import org.apache.avro.reflect.Nullable;

public class ReflectedCustomer {

private String firstName;
private String lastName;
@Nullable private String nickName;

// needed by the reflection
public ReflectedCustomer(){}

public ReflectedCustomer(String firstName, String lastName, String nickName) {
    this.firstName = firstName;
    this.lastName = lastName;
    this.nickName = nickName;
}

public String getFirstName() {
    return firstName;
}

public void setFirstName(String firstName) {
    this.firstName = firstName;
}

public String fullName(){
    return this.firstName + " " + this.lastName + " " + this.nickName;
}

public String getNickName() {
    return nickName;
}

public void setNickName(String nickName) {
    this.nickName = nickName;
}
}

下面的代码将使用上面的ReflectedCustomer并生成Avro字符串，然后将其读回

import org.apache.avro.Schema;
import org.apache.avro.file.CodecFactory;
import org.apache.avro.file.DataFileReader;
import org.apache.avro.file.DataFileWriter;
import org.apache.avro.io.DatumReader;
import org.apache.avro.io.DatumWriter;
import org.apache.avro.reflect.ReflectData;
import org.apache.avro.reflect.ReflectDatumReader;
import org.apache.avro.reflect.ReflectDatumWriter;
import java.io.File;
import java.io.IOException;

public class ReflectionExamples {

    public static void main(String[] args) {

        // here we use reflection to determine the schema
        Schema schema = ReflectData.get().getSchema(ReflectedCustomer.class);
        System.out.println("schema = " + schema.toString(true));


        // create a file of ReflectedCustomers
        try {
            System.out.println("Writing customer-reflected.avro");
            File file = new File("customer-reflected.avro");
            DatumWriter<ReflectedCustomer> writer = new ReflectDatumWriter<>(ReflectedCustomer.class);
            DataFileWriter<ReflectedCustomer> out = new DataFileWriter<>(writer)
                    .setCodec(CodecFactory.deflateCodec(9))
                    .create(schema, file);

            out.append(new ReflectedCustomer("Bill", "Clark", "The Rocket"));
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

        // read from an avro into our Reflected class
        // open a file of ReflectedCustomers
        try {
            System.out.println("Reading customer-reflected.avro");
            File file = new File("customer-reflected.avro");
            DatumReader<ReflectedCustomer> reader = new ReflectDatumReader<>(ReflectedCustomer.class);
            DataFileReader<ReflectedCustomer> in = new DataFileReader<>(file, reader);

            // read ReflectedCustomers from the file & print them as JSON
            for (ReflectedCustomer reflectedCustomer : in) {
                System.out.println(reflectedCustomer.fullName());
            }
            // close the input file
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }



    }
}

import org.apache.avro.Schema；
导入org.apache.avro.file.CodecFactory；
导入org.apache.avro.file.DataFileReader；
导入org.apache.avro.file.DataFileWriter；
导入org.apache.avro.io.DatumReader；
导入org.apache.avro.io.DatumWriter；
导入org.apache.avro.reflect.ReflectData；
导入org.apache.avro.reflect.ReflectDatumReader；
导入org.apache.avro.reflect.ReflectDatumWriter；
导入java.io.File；
导入java.io.IOException；
公共类ReflectionExamples{
公共静态void main（字符串[]args）{
//这里我们使用反射来确定模式
Schema Schema=ReflectData.get（）.getSchema（ReflectedCustomer.class）；
System.out.println（“schema=“+schema.toString（true））；
//创建反射客户的文件
试一试{
System.out.println（“Writing customer reflected.avro”）；
文件File=新文件（“customer reflected.avro”）；
DatumWriter=新的ReflectDatumWriter（ReflectedCustomer.class）；
DataFileWriter out=新的DataFileWriter（writer）
.setCodec（CodecFactory.deflateCodec（9））
.create（模式、文件）；
追加（新的反射客户（“比尔”、“克拉克”、“火箭”）；
out.close（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
//从avro读入我们的课堂
//打开反射客户的文件
试一试{
System.out.println（“Reading customer reflected.avro”）；
文件File=新文件（“customer reflected.avro”）；
DatumReader=新的ReflectDatumReader（ReflectedCustomer.class）；
DataFileReader in=新的DataFileReader（文件，读取器）；
//从文件中读取ReflectedCustomers并将其打印为JSON
for（ReflectedCustomer ReflectedCustomer:in）{
System.out.println（reflectedCustomer.fullName（））；
}
//关闭输入文件
in.close（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
}