or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

build-integration.mdconfiguration.mdindex.mdprotocol-code-generation.mdschema-code-generation.mdschema-utilities.md
tile.json

tessl/maven-org-apache-avro--avro-compiler

Compilers for Avro IDL and Avro Specific Java API - provides code generation tools for converting Avro schemas and IDL definitions into Java classes

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/org.apache.avro/avro-compiler@1.12.x

To install, run

npx @tessl/cli install tessl/maven-org-apache-avro--avro-compiler@1.12.0

index.mddocs/

Apache Avro Compiler

Apache Avro Compiler provides comprehensive code generation capabilities for the Avro data serialization system. It transforms Avro schema definitions and IDL (Interface Definition Language) files into Java classes, enabling type-safe serialization and deserialization of data with schema evolution support.

Package Information

  • Package Name: avro-compiler
  • Package Type: maven
  • Language: Java
  • Installation: <dependency><groupId>org.apache.avro</groupId><artifactId>avro-compiler</artifactId><version>1.12.0</version></dependency>

Core Imports

import org.apache.avro.compiler.specific.SpecificCompiler;
import org.apache.avro.compiler.specific.SchemaTask;
import org.apache.avro.compiler.specific.ProtocolTask;
import org.apache.avro.compiler.schema.Schemas;
import org.apache.avro.compiler.schema.SchemaVisitor;
import org.apache.avro.compiler.schema.SchemaVisitorAction;
import org.apache.avro.compiler.schema.CloningVisitor;
import org.apache.avro.compiler.idl.ResolvingVisitor;
import org.apache.avro.compiler.idl.IsResolvedSchemaVisitor;
import org.apache.avro.generic.GenericData.StringType;

Basic Usage

import org.apache.avro.Schema;
import org.apache.avro.compiler.specific.SpecificCompiler;
import java.io.File;
import java.io.IOException;

// Compile a schema file to Java classes
File schemaFile = new File("user.avsc");
File outputDir = new File("src/main/java");

Schema.Parser parser = new Schema.Parser();
Schema schema = parser.parse(schemaFile);

SpecificCompiler compiler = new SpecificCompiler(schema);
compiler.compileToDestination(schemaFile, outputDir);

// Or use static convenience methods
SpecificCompiler.compileSchema(schemaFile, outputDir);

Architecture

The Avro Compiler is built around several key components:

  • Code Generation Engine: SpecificCompiler class that generates Java code from schemas and protocols
  • Build Integration: Ant tasks (SchemaTask, ProtocolTask) for build system integration
  • Schema Utilities: Schemas utility class for schema traversal and manipulation
  • Visitor Pattern: SchemaVisitor interface for custom schema processing
  • Template Engine: Apache Velocity integration for customizable code generation
  • IDL Processing: Support for Avro IDL parsing and compilation (deprecated, use avro-idl)

Capabilities

Code Generation from Schemas

Core functionality for generating Java classes from Avro schemas. Supports customizable field visibility, getter/setter generation, and logical type conversions.

// Constructors for schema compilation
SpecificCompiler(Schema schema);
SpecificCompiler(Collection<Schema> schemas);
SpecificCompiler(Iterable<Schema> schemas);

// Main compilation method
void compileToDestination(File src, File dst) throws IOException;

// Static convenience methods
static void compileSchema(File src, File dest) throws IOException;
static void compileSchema(File[] srcFiles, File dest) throws IOException;

Schema Code Generation

Code Generation from Protocols

Generate Java interfaces and classes from Avro protocol definitions, supporting RPC-style service definitions.

// Constructor for protocol compilation
SpecificCompiler(Protocol protocol);

// Static convenience methods for protocols
static void compileProtocol(File src, File dest) throws IOException;
static void compileProtocol(File[] srcFiles, File dest) throws IOException;

Protocol Code Generation

Build System Integration

Ant tasks for integrating Avro compilation into build processes, with support for filesets and batch processing.

// Ant task for schema compilation
public class SchemaTask extends ProtocolTask {
    static void main(String[] args) throws IOException;
}

// Base Ant task for protocol compilation
public class ProtocolTask extends Task {
    void setFile(File file);
    void setDestdir(File dir);
    void execute() throws BuildException;
}

Build Integration

Schema Manipulation Utilities

Utility functions for schema traversal, cloning, and manipulation operations.

// Schema traversal and visiting
static <T> T visit(Schema start, SchemaVisitor<T> visitor);

// Schema utility operations
static void copyAliases(Schema from, Schema to);
static void copyLogicalTypes(Schema from, Schema to);
static boolean hasGeneratedJavaClass(Schema schema);
static String getJavaClassName(Schema schema);

Schema Utilities

Customization and Configuration

Configuration options for controlling code generation behavior, including field visibility, annotations, and template customization.

// Field visibility configuration
void setFieldVisibility(FieldVisibility fieldVisibility);
boolean publicFields();
boolean privateFields();

// Getter/setter configuration  
boolean isCreateSetters();
void setCreateSetters(boolean createSetters);
void setCreateOptionalGetters(boolean createOptionalGetters);
boolean isGettersReturnOptional();
void setGettersReturnOptional(boolean gettersReturnOptional);
void setOptionalGettersForNullableFieldsOnly(boolean optionalGettersForNullableFieldsOnly);

// String type configuration
void setStringType(StringType stringType);
StringType getStringType();

// Logical type support
void setEnableDecimalLogicalType(boolean enableDecimalLogicalType);
void addCustomConversion(Class<?> conversionClass);

Configuration Options

Common Types

// Field visibility options
enum FieldVisibility {
    PUBLIC, PRIVATE
}

// String type options (from org.apache.avro.generic.GenericData)
enum StringType {
    CharSequence, String, Utf8
}

// Schema visitor for traversal operations
interface SchemaVisitor<T> {
    SchemaVisitorAction visitTerminal(Schema terminal);
    SchemaVisitorAction visitNonTerminal(Schema nonTerminal);
    SchemaVisitorAction afterVisitNonTerminal(Schema nonTerminal);
    T get();
}

// Actions for controlling schema traversal
enum SchemaVisitorAction {
    CONTINUE, SKIP_SUBTREE, SKIP_SIBLINGS, TERMINATE
}

// Built-in visitor implementations
class CloningVisitor implements SchemaVisitor<Schema> {
    CloningVisitor(Schema root);
    CloningVisitor(PropertyCopier copyProperties, boolean copyDocs, Schema root);
}

// Note: The following visitor classes are in org.apache.avro.compiler.idl package
class ResolvingVisitor implements SchemaVisitor<Schema> {
    ResolvingVisitor(Schema root, IdentityHashMap<Schema, Schema> replace,
                    Function<String, Schema> symbolTable);
}

class IsResolvedSchemaVisitor implements SchemaVisitor<Boolean> {
    IsResolvedSchemaVisitor();
}