org.apache.avro.reflect (Apache Avro Java 1.7.7 API)

Class Summary
Class	Description
CustomEncoding<T>	Expert: a custom encoder and decoder that writes an object directly to avro.
DateAsLongEncoding	This encoder/decoder writes a java.util.Date object as a long to avro and reads a Date object from long.
ReflectData	Utilities to use existing Java classes and interfaces via reflection.
ReflectData.AllowNull	`ReflectData` implementation that permits null field values.
ReflectDatumReader<T>	`DatumReader` for existing classes via Java reflection.
ReflectDatumWriter<T>	`DatumWriter` for existing classes via Java reflection.

Annotation Types Summary
Annotation Type	Description
AvroAlias	Adds the given name and space as an alias to the schema.
AvroDefault	Specifies a default value for a field as a JSON string.
AvroEncode	Expert: Fields with this annotation are encoded using the given custom encoder.
AvroIgnore	Marks a field as transient.
AvroMeta	Adds the given key:Value pair as metadata into the schema, at the corresponding node.
AvroName	Sets the avroname for this java field.
AvroSchema	Declares that a Java type should have a specified Avro schema, overriding the normally inferred schema.
Nullable	Declares that null is a valid value for a Java type.
Stringable	Declares that a class or field should be represented by an Avro string.
Union	Declares that a Java type should be represented by an Avro union schema.

Package org.apache.avro.reflect Description

Use Java reflection to generate schemas and protocols for existing classes.

Java types are mapped to Avro schemas as follows:

Classes are mapped to Avro records. Only concrete classes with a no-argument constructor are supported. All inherited fields that are not static or transient are used. Fields are not permitted to be null unless annotated by Nullable or a Union containing null.
Arrays are mapped to Avro array schemas. If an array's elements are a union defined by the Union annotation, the "java-element" property is set to the union's class, e.g.:
```
{"type": "array", "java-element": "org.acme.Foo"}
```
Collection implementations are mapped to Avro array schemas with the "java-class" property set to the collection implementation, e.g.:
```
{"type": "array", "java-class": "java.util.ArrayList"}
```
String is mapped to an Avro string schema.
byte[] is mapped to an Avro bytes schema.
short is mapped to an Avro int schema with the "java-class" property set to "java.lang.Short", e.g.:
```
{"type": "int", "java-class": "java.lang.Short"}
```
BigDecimal, BigInteger, URI, URL, File are mapped to an Avro string schema as Stringable types and serialized via their toString method and de-serialized via their String constructor. This is done via the "java-class", "java-key-class" or "java-element-class" depending on whether it is a field, or map key or a list/map element, e.g.:
```
{"type": "string", "java-class": "java.math.BigDecimal"}
```
All other types are mapped as in the generic API.

The Union annotation can be used to support reflection of schemas for interfaces, abstract base classes and other uses of polymorphism.

The Stringable annotation will cause a type to be serialized via its toString method.

Fields annotated with AvroIgnore will not be written or read to.

The AvroName annotation renames the field in the schema to the given name. The reflect datum reader will look for a schema field with the given name, when trying to read into such an annotated java field.

The AvroMeta annotation adds an arbitrary key:value pair in the schema at the node of the java field.

The AvroSchema annotation forces the use of an custom schema.

The AvroEncode annotation forces the use of an custom encoder. This annotation overrides Stringable and Nullable.