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

Class Summary
Class	Description
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
Nullable	Declares that null is a valid value for a Java type.
Stringable	Declares that a class 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.

This API is not recommended except as a stepping stone for systems that currently uses Java interfaces to define RPC protocols. For new RPC systems, the specific API is preferred. For systems that process dynamic data, the generic API is probably best.

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. Fields are not permitted to be null. All inherited fields that are not static or transient are used.
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"}
```
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.