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

—

Pending

Overview

Eval results

Files

Protocol Code Generation

Name: tessl/maven-org-apache-avro--avro-compiler
Author: tessl

Generate Java interfaces and classes from Avro protocol definitions, supporting RPC-style service definitions with message types and error handling.

Capabilities

SpecificCompiler Protocol Support

The SpecificCompiler class supports protocol compilation in addition to schema compilation.

/**
 * Create compiler from Protocol
 * @param protocol Avro protocol definition
 */
public SpecificCompiler(Protocol protocol);

Static Protocol Compilation Methods

Convenience methods for compiling protocol files directly.

/**
 * Compile single protocol file to Java interfaces and classes
 * @param src Source protocol file (.avpr)
 * @param dest Destination directory for generated code
 * @throws IOException if compilation fails
 */
public static void compileProtocol(File src, File dest) throws IOException;

/**
 * Compile multiple protocol files to Java interfaces and classes
 * @param srcFiles Array of source protocol files
 * @param dest Destination directory for generated code
 * @throws IOException if compilation fails
 */
public static void compileProtocol(File[] srcFiles, File dest) throws IOException;

Protocol Compilation Process

When compiling protocols, the compiler generates:

Service Interface: Java interface representing the protocol's messages
Message Classes: Java classes for request/response message types
Error Classes: Java classes for protocol-defined error types
Callback Interface: Asynchronous callback interface for non-blocking RPC

All protocol compilation uses the same configuration options as schema compilation (field visibility, setters, optional getters, etc.).

Usage Examples

Basic Protocol Compilation

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

// Parse and compile a protocol
Protocol.Parser parser = new Protocol.Parser();
Protocol protocol = parser.parse(new File("email-service.avpr"));

SpecificCompiler compiler = new SpecificCompiler(protocol);
compiler.compileToDestination(new File("email-service.avpr"), new File("src/main/java"));

Static Protocol Compilation

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

// Direct protocol compilation
SpecificCompiler.compileProtocol(
    new File("email-service.avpr"), 
    new File("src/main/java")
);

Multiple Protocol Compilation

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

// Compile multiple protocols
File[] protocolFiles = {
    new File("user-service.avpr"),
    new File("order-service.avpr"),
    new File("inventory-service.avpr")
};

SpecificCompiler.compileProtocol(protocolFiles, new File("src/main/java"));

Configured Protocol Compilation

import org.apache.avro.Protocol;
import org.apache.avro.compiler.specific.SpecificCompiler;
import org.apache.avro.compiler.specific.SpecificCompiler.FieldVisibility;

Protocol protocol = new Protocol.Parser().parse(new File("service.avpr"));
SpecificCompiler compiler = new SpecificCompiler(protocol);

// Configure the same options as schema compilation
compiler.setFieldVisibility(FieldVisibility.PRIVATE);
compiler.setCreateSetters(true);
compiler.setCreateOptionalGetters(true);

compiler.compileToDestination(new File("service.avpr"), new File("src/main/java"));

Example Protocol Definition

A typical Avro protocol file (.avpr) might look like:

{
  "protocol": "EmailService",
  "namespace": "com.example.email",
  "types": [
    {
      "name": "EmailMessage",
      "type": "record",
      "fields": [
        {"name": "to", "type": "string"},
        {"name": "from", "type": "string"},
        {"name": "subject", "type": "string"},
        {"name": "body", "type": "string"}
      ]
    },
    {
      "name": "SendResult",
      "type": "record",
      "fields": [
        {"name": "messageId", "type": "string"},
        {"name": "success", "type": "boolean"}
      ]
    }
  ],
  "messages": {
    "sendEmail": {
      "request": [{"name": "message", "type": "EmailMessage"}],
      "response": "SendResult",
      "errors": ["string"]
    }
  }
}

This generates:

EmailService interface with sendEmail method
EmailMessage record class
SendResult record class
EmailServiceCallback interface for async operations

Generated Code Structure

For the protocol above, the compiler generates:

// Service interface
public interface EmailService {
    SendResult sendEmail(EmailMessage message) throws org.apache.avro.AvroRemoteException;
}

// Callback interface
public interface EmailServiceCallback {
    void sendEmail(EmailMessage message, 
                   org.apache.avro.ipc.Callback<SendResult> callback);
}

// Record classes (EmailMessage, SendResult) with configured options

Integration with RPC

Generated protocol classes integrate with Avro's RPC system:

// Server-side implementation
public class EmailServiceImpl implements EmailService {
    @Override
    public SendResult sendEmail(EmailMessage message) throws AvroRemoteException {
        // Implementation logic
        return SendResult.newBuilder()
            .setMessageId(UUID.randomUUID().toString())
            .setSuccess(true)
            .build();
    }
}

// Client-side usage (with Avro RPC framework)
// EmailService client = SpecificRequestor.getClient(EmailService.class, transceiver);
// SendResult result = client.sendEmail(emailMessage);

Install with Tessl CLI

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

docs

build-integration.md

configuration.md

index.md

protocol-code-generation.md

schema-code-generation.md

schema-utilities.md

tile.json

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