Come codificare avro in binario la mia stringa json in un array di byte?

Question

Ho una stringa JSON effettiva che ho bisogno di codificare in binario avro su un array di byte. Dopo aver esaminato lo Apache Avro specification, ho trovato il codice seguente.

Non sono sicuro se questo sia il modo giusto per farlo o no. Qualcuno può dare un'occhiata se il modo in cui sto provando ad avro codifica binaria mia stringa JSON è corretta o no ?. Sto usando la versione 1.7.7 di Apache Avro.

public class AvroTest { 

    private static final String json = "{" + "\"name\":\"Frank\"," + "\"age\":47" + "}"; 
    private static final String schema = "{ \"type\":\"record\", \"namespace\":\"foo\", \"name\":\"Person\", \"fields\":[ { \"name\":\"name\", \"type\":\"string\" }, { \"name\":\"age\", \"type\":\"int\" } ] }"; 

    public static void main(String[] args) throws IOException { 
     byte[] data = jsonToAvro(json, schema); 

     String jsonString = avroToJson(data, schema); 
     System.out.println(jsonString); 
    } 

    /** 
    * Convert JSON to avro binary array. 
    * 
    * @param json 
    * @param schemaStr 
    * @return 
    * @throws IOException 
    */ 
    public static byte[] jsonToAvro(String json, String schemaStr) throws IOException { 
     InputStream input = null; 
     GenericDatumWriter<Object> writer = null; 
     Encoder encoder = null; 
     ByteArrayOutputStream output = null; 
     try { 
      Schema schema = new Schema.Parser().parse(schemaStr); 
      DatumReader<Object> reader = new GenericDatumReader<Object>(schema); 
      input = new ByteArrayInputStream(json.getBytes()); 
      output = new ByteArrayOutputStream(); 
      DataInputStream din = new DataInputStream(input); 
      writer = new GenericDatumWriter<Object>(schema); 
      Decoder decoder = DecoderFactory.get().jsonDecoder(schema, din); 
      encoder = EncoderFactory.get().binaryEncoder(output, null); 
      Object datum; 
      while (true) { 
       try { 
        datum = reader.read(null, decoder); 
       } catch (EOFException eofe) { 
        break; 
       } 
       writer.write(datum, encoder); 
      } 
      encoder.flush(); 
      return output.toByteArray(); 
     } finally { 
      try { 
       input.close(); 
      } catch (Exception e) { 
      } 
     } 
    } 

    /** 
    * Convert Avro binary byte array back to JSON String. 
    * 
    * @param avro 
    * @param schemaStr 
    * @return 
    * @throws IOException 
    */ 
    public static String avroToJson(byte[] avro, String schemaStr) throws IOException { 
     boolean pretty = false; 
     GenericDatumReader<Object> reader = null; 
     JsonEncoder encoder = null; 
     ByteArrayOutputStream output = null; 
     try { 
      Schema schema = new Schema.Parser().parse(schemaStr); 
      reader = new GenericDatumReader<Object>(schema); 
      InputStream input = new ByteArrayInputStream(avro); 
      output = new ByteArrayOutputStream(); 
      DatumWriter<Object> writer = new GenericDatumWriter<Object>(schema); 
      encoder = EncoderFactory.get().jsonEncoder(schema, output, pretty); 
      Decoder decoder = DecoderFactory.get().binaryDecoder(input, null); 
      Object datum; 
      while (true) { 
       try { 
        datum = reader.read(null, decoder); 
       } catch (EOFException eofe) { 
        break; 
       } 
       writer.write(datum, encoder); 
      } 
      encoder.flush(); 
      output.flush(); 
      return new String(output.toByteArray()); 
     } finally { 

     } 
    } 

} 

Answer 1

Sembra funzionare almeno. Può essere tuttavia semplificato: i loop sono inutili poiché avere più di un oggetto risulterebbe in JSON non valido. Inoltre, potrebbe essere una buona idea evitare l'analisi non necessaria dello schema preparsing.

Ecco la mia versione:

public class AvroTest { 

    private static final String JSON = "{" + "\"name\":\"Frank\"," + "\"age\":47" + "}"; 
    private static final Schema SCHEMA = new Schema.Parser().parse("{ \"type\":\"record\", \"namespace\":\"foo\", \"name\":\"Person\", \"fields\":[ { \"name\":\"name\", \"type\":\"string\" }, { \"name\":\"age\", \"type\":\"int\" } ] }"); 

    public static void main(String[] args) throws IOException { 
     byte[] data = jsonToAvro(JSON, SCHEMA); 

     String jsonString = avroToJson(data, SCHEMA); 
     System.out.println(jsonString); 
    } 

    /** 
    * Convert JSON to avro binary array. 
    * 
    * @param json 
    * @param schema 
    * @return 
    * @throws IOException 
    */ 
    public static byte[] jsonToAvro(String json, Schema schema) throws IOException { 
     DatumReader<Object> reader = new GenericDatumReader<>(schema); 
     GenericDatumWriter<Object> writer = new GenericDatumWriter<>(schema); 
     ByteArrayOutputStream output = new ByteArrayOutputStream(); 
     Decoder decoder = DecoderFactory.get().jsonDecoder(schema, json); 
     Encoder encoder = EncoderFactory.get().binaryEncoder(output, null); 
     Object datum = reader.read(null, decoder); 
     writer.write(datum, encoder); 
     encoder.flush(); 
     return output.toByteArray(); 
    } 

    /** 
    * Convert Avro binary byte array back to JSON String. 
    * 
    * @param avro 
    * @param schema 
    * @return 
    * @throws IOException 
    */ 
    public static String avroToJson(byte[] avro, Schema schema) throws IOException { 
     boolean pretty = false; 
     GenericDatumReader<Object> reader = new GenericDatumReader<>(schema); 
     DatumWriter<Object> writer = new GenericDatumWriter<>(schema); 
     ByteArrayOutputStream output = new ByteArrayOutputStream(); 
     JsonEncoder encoder = EncoderFactory.get().jsonEncoder(schema, output, pretty); 
     Decoder decoder = DecoderFactory.get().binaryDecoder(avro, null); 
     Object datum = reader.read(null, decoder); 
     writer.write(datum, encoder); 
     encoder.flush(); 
     output.flush(); 
     return new String(output.toByteArray(), "UTF-8"); 
    } 
}