@Override protected Encoder getEncoder(Schema schema, OutputStream outputStream) throws IOException { return EncoderFactory.get().jsonEncoder(schema, outputStream); } }
public Serializer(Schema schema) { try { this.writer = new GenericDatumWriter<>(schema); this.outputStream = new ByteArrayOutputStream(); this.encoder = EncoderFactory.get().jsonEncoder(schema, this.outputStream); } catch (IOException ioe) { throw new RuntimeException("Could not initialize avro json encoder."); } }
private void dumpJson(PrintStream out, Schema schema, Object datum) throws IOException { DatumWriter<Object> writer = new GenericDatumWriter<>(schema); JsonEncoder jsonEncoder = EncoderFactory.get().jsonEncoder(schema, out, true); writer.write(datum, jsonEncoder); jsonEncoder.flush(); out.println(); out.flush(); }
/** * Encode record to Json and then convert to byte array. * * @param record the object to encode * @return the byte[] * @throws IOException Signals that an I/O exception has occurred. */ public byte[] encodeToJsonBytes(T record) throws IOException { ByteArrayOutputStream baos = new ByteArrayOutputStream(); jsonEncoder = EncoderFactory.get().jsonEncoder(this.schema, baos, true); datumWriter.write(record, jsonEncoder); jsonEncoder.flush(); baos.flush(); return baos.toByteArray(); }
public AvroFileInputStream(FileStatus status) throws IOException { pos = 0; buffer = new byte[0]; GenericDatumReader<Object> reader = new GenericDatumReader<Object>(); FileContext fc = FileContext.getFileContext(new Configuration()); fileReader = DataFileReader.openReader(new AvroFSInput(fc, status.getPath()),reader); Schema schema = fileReader.getSchema(); writer = new GenericDatumWriter<Object>(schema); output = new ByteArrayOutputStream(); encoder = EncoderFactory.get().jsonEncoder(schema, output); }
/** * Encode record to Json and then convert to byte array. * * @param record the object to encode * @return the byte[] * @throws IOException Signals that an I/O exception has occurred. */ public byte[] encodeToJsonBytes(T record) throws IOException { ByteArrayOutputStream baos = new ByteArrayOutputStream(); jsonEncoder = EncoderFactory.get().jsonEncoder(this.schema, baos, true); avroWriter.write(record, jsonEncoder); jsonEncoder.flush(); baos.flush(); return baos.toByteArray(); }
out.print("\t"); try { JsonEncoder jsonEncoder = EncoderFactory.get().jsonEncoder(message.getRequest(), out); GenericDatumWriter<Object> writer = new GenericDatumWriter<>(
private byte[] encodeGenericBlob(GenericRecord data) throws IOException { DatumWriter<GenericRecord> writer = new GenericDatumWriter<>(data.getSchema()); ByteArrayOutputStream outStream = new ByteArrayOutputStream(); Encoder encoder = encoderType == EncoderType.BINARY ? EncoderFactory.get().binaryEncoder(outStream, null) : EncoderFactory.get().jsonEncoder(data.getSchema(), outStream); writer.write(data, encoder); encoder.flush(); outStream.close(); return outStream.toByteArray(); }
@Test public void testJsonEncoderInit() throws IOException { Schema s = Schema.parse("\"int\""); OutputStream out = new ByteArrayOutputStream(); factory.jsonEncoder(s, out); JsonEncoder enc = factory.jsonEncoder(s, new JsonFactory().createJsonGenerator(out, JsonEncoding.UTF8)); enc.configure(out); }
private <T> byte[] testJsonEncoder (String testType, T entityObj) throws IOException { ReflectData rdata = ReflectData.AllowNull.get(); Schema schema = rdata.getSchema(entityObj.getClass()); ByteArrayOutputStream os = new ByteArrayOutputStream(); Encoder encoder = EncoderFactory.get().jsonEncoder(schema, os); ReflectDatumWriter<T> datumWriter = new ReflectDatumWriter<>(schema, rdata); datumWriter.write(entityObj, encoder); encoder.flush(); byte[] bytes = os.toByteArray(); System.out.println ("JSON encoder output:\n" + new String(bytes)); return bytes; }
@Test(expected=NullPointerException.class) public void testBadJsonEncoderInitOS() throws IOException { factory.jsonEncoder(Schema.create(Type.INT), (OutputStream)null); }
@Test(expected=NullPointerException.class) public void testBadJsonEncoderInit() throws IOException { factory.jsonEncoder(Schema.create(Type.INT), (JsonGenerator)null); }
private static void checkJson(Schema schema, Object datum, String json) throws Exception { ByteArrayOutputStream out = new ByteArrayOutputStream(); Encoder encoder = EncoderFactory.get().jsonEncoder(schema, out); DatumWriter<Object> writer = new GenericDatumWriter<>(); writer.setSchema(schema); writer.write(datum, encoder); encoder.flush(); byte[] data = out.toByteArray(); String encoded = new String(data, StandardCharsets.UTF_8); assertEquals("Encoded data does not match.", json, encoded); DatumReader<Object> reader = new GenericDatumReader<>(); reader.setSchema(schema); Object decoded = reader.read(null, DecoderFactory.get() .jsonDecoder(schema, new ByteArrayInputStream(data))); assertEquals("Decoded data does not match.", datum, decoded); }
@Test(expected=AvroTypeException.class) public void writeDoesNotAllowJavaEnumForGenericEnum() throws IOException { final String json = "{\"type\": \"record\", \"name\": \"recordWithEnum\"," + "\"fields\": [ " + "{\"name\": \"field\", \"type\": " + "{\"type\": \"enum\", \"name\": \"enum\", \"symbols\": " + "[\"ONE\",\"TWO\",\"THREE\"] " + "}" + "}" + "]}"; Schema schema = Schema.parse(json); GenericRecord record = new GenericData.Record(schema); record.put("field", AnEnum.ONE); ByteArrayOutputStream bao = new ByteArrayOutputStream(); GenericDatumWriter<GenericRecord> writer = new GenericDatumWriter<>(schema); Encoder encoder = EncoderFactory.get().jsonEncoder(schema, bao); writer.write(record, encoder); }
private static void checkJson(Schema schema, Object datum, DatumWriter<Object> writer, DatumReader<Object> reader) throws IOException { ByteArrayOutputStream out = new ByteArrayOutputStream(); Encoder encoder = EncoderFactory.get().jsonEncoder(schema, out); writer.setSchema(schema); writer.write(datum, encoder); writer.write(datum, encoder); encoder.flush(); byte[] data = out.toByteArray(); reader.setSchema(schema); Decoder decoder = DecoderFactory.get().jsonDecoder(schema, new ByteArrayInputStream(data)); Object decoded = reader.read(null, decoder); assertEquals("Decoded data does not match.", datum, decoded); decoded = reader.read(decoded, decoder); assertEquals("Decoded data does not match.", datum, decoded); }
@Test public void testJsonEncoderNewlineDelimited() throws IOException { OutputStream out = new ByteArrayOutputStream(); Schema ints = Schema.create(Type.INT); Encoder e = factory.jsonEncoder(ints, out); String separator = System.getProperty("line.separator"); GenericDatumWriter<Integer> writer = new GenericDatumWriter<>(ints); writer.write(1, e); writer.write(2, e); e.flush(); Assert.assertEquals("1"+separator+"2", out.toString()); }
@Test(expected=AvroTypeException.class) public void writeDoesNotAllowStringForGenericEnum() throws IOException { final String json = "{\"type\": \"record\", \"name\": \"recordWithEnum\"," + "\"fields\": [ " + "{\"name\": \"field\", \"type\": " + "{\"type\": \"enum\", \"name\": \"enum\", \"symbols\": " + "[\"ONE\",\"TWO\",\"THREE\"] " + "}" + "}" + "]}"; Schema schema = Schema.parse(json); GenericRecord record = new GenericData.Record(schema); record.put("field", "ONE"); ByteArrayOutputStream bao = new ByteArrayOutputStream(); GenericDatumWriter<GenericRecord> writer = new GenericDatumWriter<>(schema); Encoder encoder = EncoderFactory.get().jsonEncoder(schema, bao); writer.write(record, encoder); }
@Test public void testWrite() throws IOException { String json = "{\"type\": \"record\", \"name\": \"r\", \"fields\": [" + "{ \"name\": \"f1\", \"type\": \"long\" }" + "]}"; Schema s = Schema.parse(json); GenericRecord r = new GenericData.Record(s); r.put("f1", 100L); ByteArrayOutputStream bao = new ByteArrayOutputStream(); GenericDatumWriter<GenericRecord> w = new GenericDatumWriter<>(s); Encoder e = EncoderFactory.get().jsonEncoder(s, bao); w.write(r, e); e.flush(); Object o = new GenericDatumReader<GenericRecord>(s).read(null, DecoderFactory.get().jsonDecoder(s, new ByteArrayInputStream(bao.toByteArray()))); assertEquals(r, o); }
public static byte[] make(Schema sc, String calls, Object[] values, Encoding encoding) throws IOException { EncoderFactory factory = EncoderFactory.get(); ByteArrayOutputStream ba = new ByteArrayOutputStream(); Encoder bvo = null; switch (encoding) { case BINARY: bvo = factory.binaryEncoder(ba, null); break; case BLOCKING_BINARY: bvo = factory.blockingBinaryEncoder(ba, null); break; case JSON: bvo = factory.jsonEncoder(sc, ba); break; } Encoder vo = factory.validatingEncoder(sc, bvo); generate(vo, calls, values); vo.flush(); return ba.toByteArray(); }
@Test public void testResolveUnion() throws IOException { final SpecificDatumWriter<TestRecordWithUnion> writer = new SpecificDatumWriter<>(); Schema schema = TestRecordWithUnion.SCHEMA$; ByteArrayOutputStream out = new ByteArrayOutputStream(); JsonEncoder encoder = EncoderFactory.get().jsonEncoder(schema, out); writer.setSchema(schema); TestRecordWithUnion c = TestRecordWithUnion.newBuilder(). setKind(Kind.BAR).setValue("rab").build(); writer.write(c, encoder); encoder.flush(); out.close(); String expectedJson = String.format( "{'kind':{'org.apache.avro.test.Kind':'%s'},'value':{'string':'%s'}}", c.getKind().toString(), c.getValue()).replace('\'', '"'); assertEquals(expectedJson, out.toString("UTF-8")); }