Java SpecificDatumReader類代碼示例

import org.apache.avro.specific.SpecificDatumReader; //導入依賴的package包/類
public void jsonReadWriteExample() throws IOException {
	Employee employee = Employee.newBuilder().setFirstName("Gaurav")
			.setLastName("Mazra").setSex(SEX.MALE).build();

	DatumWriter<Employee> employeeWriter = new SpecificDatumWriter<>(Employee.class);
	byte[] data;
	try (ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
		Encoder jsonEncoder = EncoderFactory.get().jsonEncoder(Employee.getClassSchema(), baos);
		employeeWriter.write(employee, jsonEncoder);
		jsonEncoder.flush();
		data = baos.toByteArray();
	}
	
	// serialized data
	System.out.println(new String(data));
	
	DatumReader<Employee> employeeReader = new SpecificDatumReader<>(Employee.class);
	Decoder decoder = DecoderFactory.get().jsonDecoder(Employee.getClassSchema(), new String(data));
	employee = employeeReader.read(null, decoder);
	//data after deserialization
	System.out.println(employee);
}
 

import org.apache.avro.specific.SpecificDatumReader; //導入依賴的package包/類
public void binaryReadWriteExample() throws IOException {
	Employee employee = Employee.newBuilder().setFirstName("Gaurav")
			.setLastName("Mazra").setSex(SEX.MALE).build();

	DatumWriter<Employee> employeeWriter = new SpecificDatumWriter<>(Employee.class);
	byte[] data;
	try (ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
		Encoder binaryEncoder = EncoderFactory.get().binaryEncoder(baos, null);
		employeeWriter.write(employee, binaryEncoder);
		binaryEncoder.flush();
		data = baos.toByteArray();
	}
	
	// serialized data
	System.out.println(data);
	
	DatumReader<Employee> employeeReader = new SpecificDatumReader<>(Employee.class);
	Decoder binaryDecoder = DecoderFactory.get().binaryDecoder(data, null);
	employee = employeeReader.read(null, binaryDecoder);
	//data after deserialization
	System.out.println(employee);
}
 

import org.apache.avro.specific.SpecificDatumReader; //導入依賴的package包/類
@SuppressWarnings("unchecked")
@Override
public T deserialize(String topic, byte[] data) {
	try {
		T result = null;

		if (data != null) {
			LOGGER.debug("data='{}'", DatatypeConverter.printHexBinary(data));

			DatumReader<GenericRecord> datumReader = new SpecificDatumReader<>(
					targetType.newInstance().getSchema());
			Decoder decoder = DecoderFactory.get().binaryDecoder(data, null);

			result = (T) datumReader.read(null, decoder);
			LOGGER.debug("deserialized data='{}'", result);
		}
		return result;
	} catch (Exception ex) {
		throw new SerializationException(
				"Can't deserialize data '" + Arrays.toString(data) + "' from topic '" + topic + "'", ex);
	}
}
 

import org.apache.avro.specific.SpecificDatumReader; //導入依賴的package包/類
private Event deserializeValue(byte[] value, boolean parseAsFlumeEvent) throws IOException {
  Event e;
  if (parseAsFlumeEvent) {
    ByteArrayInputStream in =
            new ByteArrayInputStream(value);
    decoder = DecoderFactory.get().directBinaryDecoder(in, decoder);
    if (!reader.isPresent()) {
      reader = Optional.of(
              new SpecificDatumReader<AvroFlumeEvent>(AvroFlumeEvent.class));
    }
    AvroFlumeEvent event = reader.get().read(null, decoder);
    e = EventBuilder.withBody(event.getBody().array(),
            toStringMap(event.getHeaders()));
  } else {
    e = EventBuilder.withBody(value, Collections.EMPTY_MAP);
  }
  return e;
}
 

import org.apache.avro.specific.SpecificDatumReader; //導入依賴的package包/類
public void deserUserCompile(){
	// Deserialize Users from disk
	DatumReader<User> userDatumReader = new SpecificDatumReader<User>(User.class);
	DataFileReader<User> dataFileReader = null;
	User user = null;
	try {
		dataFileReader = new DataFileReader<User>(
										new File("/Users/a/Desktop/tmp/users.avro"),
										userDatumReader);
		while (dataFileReader.hasNext()) {
			// Reuse user object by passing it to next(). This saves us from
			// allocating and garbage collecting many objects for files with
			// many items.
			user = dataFileReader.next(user);
			System.out.println(user);
		}
	} catch (IOException e) {
		e.printStackTrace();
	}
}
 

import org.apache.avro.specific.SpecificDatumReader; //導入依賴的package包/類
/**
 * 動態反序列：通過Schema文件進行動態反序列化操作
 * 
 * @throws IOException
 */
public void MemberInfoDynDeser() throws IOException {
    // 1.schema文件解析
    Parser parser = new Parser();
    Schema mSchema = parser.parse(this.getClass().getResourceAsStream("/Members.avsc"));

    // 2.構建數據讀對象
    DatumReader<GenericRecord> mGr = new SpecificDatumReader<GenericRecord>(mSchema);
    DataFileReader<GenericRecord> mDfr = new DataFileReader<GenericRecord>(new File("/Users/a/Desktop/tmp/members.avro"), mGr);
    // 3.從序列化文件中進行數據反序列化取出數據
    GenericRecord gr = null;
    while (mDfr.hasNext()) {
        gr = mDfr.next();
        System.err.println("deser data:" + gr.toString());
    }
    mDfr.close();
    System.out.println("Dyn Builder Ser Start Complete.");
}
 

import org.apache.avro.specific.SpecificDatumReader; //導入依賴的package包/類
/**
 * Create a new Event Reader
 * @param in
 * @throws IOException
 */
@SuppressWarnings("deprecation")
public EventReader(DataInputStream in) throws IOException {
  this.in = in;
  this.version = in.readLine();

  Schema myschema = new SpecificData(Event.class.getClassLoader()).getSchema(Event.class);
  Schema.Parser parser = new Schema.Parser();
  this.schema = parser.parse(in.readLine());
  this.reader = new SpecificDatumReader(schema, myschema);
  if (EventWriter.VERSION.equals(version)) {
    this.decoder = DecoderFactory.get().jsonDecoder(schema, in);
  } else if (EventWriter.VERSION_BINARY.equals(version)) {
    this.decoder = DecoderFactory.get().binaryDecoder(in, null);
  } else {
    throw new IOException("Incompatible event log version: " + version);
  }
}
 

import org.apache.avro.specific.SpecificDatumReader; //導入依賴的package包/類
@SuppressWarnings("unchecked")
public static <T> T fromBytes( byte[] val, Schema schema
    , SpecificDatumReader<T> datumReader, T object)
throws IOException {
  Type type = schema.getType();
  switch (type) {
  case ENUM:
    String symbol = schema.getEnumSymbols().get(val[0]);
    return (T)Enum.valueOf(ReflectData.get().getClass(schema), symbol);
  case STRING:  return (T)new Utf8(toString(val));
  case BYTES:   return (T)ByteBuffer.wrap(val);
  case INT:     return (T)Integer.valueOf(bytesToVint(val));
  case LONG:    return (T)Long.valueOf(bytesToVlong(val));
  case FLOAT:   return (T)Float.valueOf(toFloat(val));
  case DOUBLE:  return (T)Double.valueOf(toDouble(val));
  case BOOLEAN: return (T)Boolean.valueOf(val[0] != 0);
  case RECORD:  //fall
  case MAP:
  case ARRAY:   return (T)IOUtils.deserialize(val, (SpecificDatumReader<SpecificRecord>)datumReader, schema, (SpecificRecord)object);
  default: throw new RuntimeException("Unknown type: "+type);
  }
}
 

import org.apache.avro.specific.SpecificDatumReader; //導入依賴的package包/類
@Override
public void initialize(Class<K> keyClass, Class<T> persistentClass,
    Properties properties) {
  setKeyClass(keyClass);
  setPersistentClass(persistentClass);
  if (this.beanFactory == null) {
    this.beanFactory = new BeanFactoryImpl<>(keyClass, persistentClass);
  }
  schema = this.beanFactory.getCachedPersistent().getSchema();
  fieldMap = AvroUtils.getFieldMap(schema);

  autoCreateSchema = DataStoreFactory.getAutoCreateSchema(properties, this);
  this.properties = properties;

  datumReader = new SpecificDatumReader<>(schema);
  datumWriter = new SpecificDatumWriter<>(schema);
}
 

import org.apache.avro.specific.SpecificDatumReader; //導入依賴的package包/類
private DataFileReader<E> initReader(FileInputSplit split) throws IOException {
	DatumReader<E> datumReader;

	if (org.apache.avro.generic.GenericRecord.class == avroValueType) {
		datumReader = new GenericDatumReader<E>();
	} else {
		datumReader = org.apache.avro.specific.SpecificRecordBase.class.isAssignableFrom(avroValueType)
			? new SpecificDatumReader<E>(avroValueType) : new ReflectDatumReader<E>(avroValueType);
	}
	if (LOG.isInfoEnabled()) {
		LOG.info("Opening split {}", split);
	}

	SeekableInput in = new FSDataInputStreamWrapper(stream, split.getPath().getFileSystem().getFileStatus(split.getPath()).getLen());
	DataFileReader<E> dataFileReader = (DataFileReader) DataFileReader.openReader(in, datumReader);

	if (LOG.isDebugEnabled()) {
		LOG.debug("Loaded SCHEMA: {}", dataFileReader.getSchema());
	}

	end = split.getStart() + split.getLength();
	recordsReadSinceLastSync = 0;
	return dataFileReader;
}
 

import org.apache.avro.specific.SpecificDatumReader; //導入依賴的package包/類
private void initializeAvro() {
	final ClassLoader cl = Thread.currentThread().getContextClassLoader();

	if (SpecificRecord.class.isAssignableFrom(type)) {
		this.avroData = new SpecificData(cl);
		this.schema = this.avroData.getSchema(type);
		this.reader = new SpecificDatumReader<>(schema, schema, avroData);
		this.writer = new SpecificDatumWriter<>(schema, avroData);
	}
	else {
		final ReflectData reflectData = new ReflectData(cl);
		this.avroData = reflectData;
		this.schema = this.avroData.getSchema(type);
		this.reader = new ReflectDatumReader<>(schema, schema, reflectData);
		this.writer = new ReflectDatumWriter<>(schema, reflectData);
	}

	this.encoder = new DataOutputEncoder();
	this.decoder = new DataInputDecoder();
}
 

import org.apache.avro.specific.SpecificDatumReader; //導入依賴的package包/類
/**
 * This test validates proper serialization with specific (generated POJO) types.
 */
@Test
public void testDeserializeToSpecificType() throws IOException {

	DatumReader<User> datumReader = new SpecificDatumReader<User>(userSchema);

	try (FileReader<User> dataFileReader = DataFileReader.openReader(testFile, datumReader)) {
		User rec = dataFileReader.next();

		// check if record has been read correctly
		assertNotNull(rec);
		assertEquals("name not equal", TEST_NAME, rec.get("name").toString());
		assertEquals("enum not equal", TEST_ENUM_COLOR.toString(), rec.get("type_enum").toString());

		// now serialize it with our framework:
		ExecutionConfig ec = new ExecutionConfig();
		TypeInformation<User> te = TypeExtractor.createTypeInfo(User.class);

		Assert.assertEquals(AvroTypeInfo.class, te.getClass());
		TypeSerializer<User> tser = te.createSerializer(ec);

		ByteArrayOutputStream out = new ByteArrayOutputStream();
		try (DataOutputViewStreamWrapper outView = new DataOutputViewStreamWrapper(out)) {
			tser.serialize(rec, outView);
		}

		User newRec;
		try (DataInputViewStreamWrapper inView = new DataInputViewStreamWrapper(
				new ByteArrayInputStream(out.toByteArray())))
		{
			newRec = tser.deserialize(inView);
		}

		// check if it is still the same
		assertNotNull(newRec);
		assertEquals("name not equal", TEST_NAME, newRec.getName().toString());
		assertEquals("enum not equal", TEST_ENUM_COLOR.toString(), newRec.getTypeEnum().toString());
	}
}
 

import org.apache.avro.specific.SpecificDatumReader; //導入依賴的package包/類
/**
 * From byte array.
 *
 * @param bytes the bytes
 * @return the iote 2 e request
 * @throws Exception the exception
 */
public Iote2eRequest fromByteArray( byte[] bytes ) throws Exception {

	try {
		if( this.datumReaderIote2eRequest == null ) {
			this.datumReaderIote2eRequest = new SpecificDatumReader<Iote2eRequest>(Iote2eRequest.getClassSchema());
		}
		this.binaryDecoder = DecoderFactory.get().binaryDecoder( bytes, this.binaryDecoder );
		this.iote2eRequest = this.datumReaderIote2eRequest.read (null, this.binaryDecoder );
		return this.iote2eRequest;
	} catch (Exception e) {
		logger.error(e.getMessage(),e);
		throw e;
	} finally {
	}
}
 

import org.apache.avro.specific.SpecificDatumReader; //導入依賴的package包/類
/**
 * From byte array.
 *
 * @param bytes the bytes
 * @return the iote 2 e result
 * @throws Exception the exception
 */
public Iote2eResult fromByteArray( byte[] bytes ) throws Exception {

	try {
		if( this.datumReaderIote2eResult == null ) {
			this.datumReaderIote2eResult = new SpecificDatumReader<Iote2eResult>(Iote2eResult.getClassSchema());
		}
		this.binaryDecoder = DecoderFactory.get().binaryDecoder(bytes, this.binaryDecoder);
		this.iote2eResult = this.datumReaderIote2eResult.read(null,this.binaryDecoder);
		return this.iote2eResult;
	} catch (Exception e) {
		logger.error(e.getMessage(),e);
		throw e;
	} finally {
	}
}
 

import org.apache.avro.specific.SpecificDatumReader; //導入依賴的package包/類
/**
 * Process list.
 *
 * @param weathers the weathers
 * @throws Exception the exception
 */
public void processList(List<Weather> weathers) throws Exception {
	long before = System.currentTimeMillis();
	BinaryEncoder binaryEncoder = null;
	BinaryDecoder binaryDecoder = null;
	Weather weatherRead = null;
	for (Weather weather : weathers) {
		DatumWriter<Weather> datumWriterWeather = new SpecificDatumWriter<Weather>(Weather.getClassSchema());
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		byte[] byteData = null;
		try {
			binaryEncoder = EncoderFactory.get().binaryEncoder(baos, binaryEncoder);
			datumWriterWeather.write(weather, binaryEncoder);
			binaryEncoder.flush();
			byteData = baos.toByteArray();
		} finally {
			baos.close();
		}

		DatumReader<Weather> datumReaderWeather = new SpecificDatumReader<Weather>(Weather.getClassSchema());
		binaryDecoder = DecoderFactory.get().binaryDecoder(byteData, binaryDecoder);
		weatherRead = datumReaderWeather.read(weatherRead, binaryDecoder);
		// System.out.println("After Binary Read: " + weatherRead.toString());
	}
	System.out.println("size=" + weathers.size() + ", elapsed: " + (System.currentTimeMillis()-before));
}