tessl/maven-io-quarkus--quarkus-arc-deployment

Quarkus ArC deployment module providing build-time CDI optimization and configuration capabilities

—

Pending

Overview

Eval results

Files

Processors

Name: tessl/maven-io-quarkus--quarkus-arc-deployment
Author: tessl

Processors contain the core build-time logic for CDI container construction, bean discovery, validation, and optimization. They implement @BuildStep methods that consume and produce build items to orchestrate the CDI build process.

Capabilities

Main ArC Processor

The central processor coordinating all aspects of CDI container build-time processing.

/**
 * Main ArC processor with CDI build steps
 */
public class ArcProcessor {
    /**
     * Core build step that creates the final CDI bean container
     */
    @BuildStep
    public BeanContainerBuildItem build(
        ArcConfig config,
        BeanArchiveIndexBuildItem beanArchiveIndex,
        List<AdditionalBeanBuildItem> additionalBeans,
        List<SyntheticBeanBuildItem> syntheticBeans,
        List<UnremovableBeanBuildItem> unremovableBeans,
        List<BeanContainerListenerBuildItem> containerListeners
    );
    
    /**
     * Bean discovery and registration build step
     */
    @BuildStep  
    public BeanRegistrationPhaseBuildItem registerBeans(
        BeanArchiveIndexBuildItem beanArchiveIndex,
        List<AdditionalBeanBuildItem> additionalBeans,
        List<BeanDefiningAnnotationBuildItem> beanDefiningAnnotations
    );
    
    /**
     * Validation phase build step
     */
    @BuildStep
    public ValidationPhaseBuildItem validate(
        BeanRegistrationPhaseBuildItem beanRegistration,
        List<ValidationPhaseBuildItem.ValidationErrorBuildItem> validationErrors
    );
    
    /**
     * Context optimization build step
     */
    @BuildStep
    public void optimizeContexts(
        ArcConfig config,
        BuildProducer<OptimizedContextBuildItem> optimizedContexts
    );
    
    /**
     * Unused bean removal build step
     */
    @BuildStep
    public void removeUnusedBeans(
        ArcConfig config,
        BeanArchiveIndexBuildItem beanArchiveIndex,
        List<UnremovableBeanBuildItem> unremovableBeans,
        BuildProducer<RemovedBeanBuildItem> removedBeans
    );
}

Usage Examples:

// Custom processor extending ArC functionality
public class MyArcExtensionProcessor {
    
    @BuildStep
    AdditionalBeanBuildItem addCustomBeans() {
        return AdditionalBeanBuildItem.builder()
            .addBeanClasses(MyCustomService.class)
            .setUnremovable()
            .build();
    }
    
    @BuildStep  
    UnremovableBeanBuildItem protectFrameworkBeans() {
        return UnremovableBeanBuildItem.beanClassAnnotation(
            DotName.createSimple("com.example.FrameworkComponent")
        );
    }
    
    @BuildStep
    @Record(ExecutionTime.RUNTIME_INIT)
    void configureRuntime(BeanContainerBuildItem beanContainer,
                         MyRecorder recorder) {
        recorder.initialize(beanContainer.getValue());
    }
}

Synthetic Bean Processor

Specialized processor for handling synthetic (programmatically created) beans.

/**
 * Processor for synthetic bean creation and management
 */
public class SyntheticBeansProcessor {
    /**
     * Process synthetic bean build items and create bean definitions
     */
    @BuildStep
    public void processSyntheticBeans(
        List<SyntheticBeanBuildItem> syntheticBeans,
        BuildProducer<GeneratedBeanBuildItem> generatedBeans
    );
    
    /**
     * Initialize synthetic beans at runtime
     */
    @BuildStep
    @Record(ExecutionTime.RUNTIME_INIT)
    public SyntheticBeansRuntimeInitBuildItem initializeSyntheticBeans(
        List<SyntheticBeanBuildItem> syntheticBeans,
        SyntheticBeansRecorder recorder
    );
}

Bean Archive Processor

Handles bean archive discovery, indexing, and Jandex integration.

/**
 * Processor for bean archive discovery and indexing
 */
public class BeanArchiveProcessor {
    /**
     * Build the bean archive index from discovered classes
     */
    @BuildStep
    public BeanArchiveIndexBuildItem buildBeanArchiveIndex(
        CombinedIndexBuildItem combinedIndex,
        List<BeanArchivePredicateBuildItem> beanArchivePredicates,
        List<AdditionalBeanBuildItem> additionalBeans
    );
    
    /**
     * Discover bean archives from the application classpath
     */
    @BuildStep
    public void discoverBeanArchives(
        ApplicationArchivesBuildItem archives,
        BuildProducer<BeanArchivePredicateBuildItem> beanArchivePredicates
    );
}

Auto-Scoping Processor

Automatically adds scope annotations to classes based on configured rules.

/**
 * Processor for automatic scope addition
 */
public class AutoAddScopeProcessor {
    /**
     * Process auto-scope rules and transform matching classes
     */
    @BuildStep
    public AnnotationsTransformerBuildItem autoAddScopes(
        List<AutoAddScopeBuildItem> autoAddScopes,
        BeanArchiveIndexBuildItem beanArchiveIndex
    );
    
    /**
     * Validate auto-scope configuration
     */
    @BuildStep
    public void validateAutoScope(
        List<AutoAddScopeBuildItem> autoAddScopes,
        BuildProducer<ValidationPhaseBuildItem.ValidationErrorBuildItem> errors
    );
}

Observer Validation Processor

Validates CDI observer methods and event handling configuration.

/**
 * Processor for observer method validation
 */
public class ObserverValidationProcessor {
    /**
     * Validate observer method signatures and configuration
     */
    @BuildStep
    public void validateObservers(
        BeanArchiveIndexBuildItem beanArchiveIndex,
        List<ObserverTransformerBuildItem> observerTransformers,
        BuildProducer<ValidationPhaseBuildItem.ValidationErrorBuildItem> errors
    );
    
    /**
     * Process observer method transformations
     */
    @BuildStep
    public TransformedAnnotationsBuildItem transformObservers(
        List<ObserverTransformerBuildItem> observerTransformers,
        BeanArchiveIndexBuildItem beanArchiveIndex
    );
}

Split Package Processor

Detects and handles split package scenarios in CDI applications.

/**
 * Processor for split package detection and handling
 */
public class SplitPackageProcessor {
    /**
     * Detect split packages across bean archives
     */
    @BuildStep
    public void detectSplitPackages(
        BeanArchiveIndexBuildItem beanArchiveIndex,
        ArcConfig config,
        BuildProducer<ValidationPhaseBuildItem.ValidationErrorBuildItem> errors
    );
    
    /**
     * Configure split package handling
     */
    @BuildStep
    public SplitPackageConfigBuildItem configureSplitPackages(
        ArcConfig config
    );
}

Configuration Processors

Handle build-time configuration processing and validation.

/**
 * Configuration processing build step
 */
public class ConfigBuildStep {
    /**
     * Process ArC configuration and validate settings
     */
    @BuildStep
    public ArcConfigBuildItem processConfig(
        ArcConfig config,
        BuildProducer<ValidationPhaseBuildItem.ValidationErrorBuildItem> errors
    );
}

/**
 * Command line arguments processor for build-time configuration
 */
public class CommandLineArgumentsProcessor {
    /**
     * Process command line arguments affecting CDI configuration
     */
    @BuildStep
    public void processCommandLineArgs(
        List<CommandLineArgumentBuildItem> args,
        BuildProducer<ConfigPropertyBuildItem> configProperties
    );
}

Lookup Conditions Processor

Handles conditional bean lookup and activation based on runtime conditions.

/**
 * Processor for lookup conditions and conditional beans
 */
public class LookupConditionsProcessor {
    /**
     * Process lookup conditions for conditional bean activation
     */
    @BuildStep
    public void processLookupConditions(
        List<BuildTimeConditionBuildItem> buildTimeConditions,
        BeanArchiveIndexBuildItem beanArchiveIndex,
        BuildProducer<ConditionalBeanBuildItem> conditionalBeans
    );
}

Bytecode Generation

Handles bytecode generation for optimized CDI components.

/**
 * Adaptor for Gizmo bytecode generation during bean creation
 */
public class GeneratedBeanGizmoAdaptor implements ClassOutput {
    public GeneratedBeanGizmoAdaptor(BuildProducer<GeneratedBeanBuildItem> generatedBeans,
                                    boolean applicationClass);
    
    /**
     * Write generated class bytecode
     */
    @Override
    public void write(String name, byte[] data);
    
    /**
     * Get the generated class source information
     */
    public String getSource();
    
    /**
     * Check if this generates application classes
     */
    public boolean isApplicationClass();
}

Usage Examples:

// Custom bytecode generation
@BuildStep
void generateCustomBeans(BuildProducer<GeneratedBeanBuildItem> generatedBeans) {
    GeneratedBeanGizmoAdaptor adaptor = new GeneratedBeanGizmoAdaptor(
        generatedBeans, true);
    
    try (ClassCreator creator = ClassCreator.builder()
            .classOutput(adaptor)
            .className("com.example.GeneratedService")
            .build()) {
        
        // Generate bean class
        creator.addAnnotation(ApplicationScoped.class);
        
        // Add methods
        MethodCreator method = creator.getMethodCreator("process", void.class);
        method.returnValue(null);
    }
}

Development UI Processors

Processors for development mode UI and debugging capabilities.

/**
 * Development UI processor for ArC information
 */
public class ArcDevUIProcessor {
    /**
     * Generate development UI data for CDI beans
     */
    @BuildStep
    public ArcBeanInfoBuildItem generateDevUIData(
        BeanContainerBuildItem beanContainer,
        BeanArchiveIndexBuildItem beanArchiveIndex
    );
}

Lifecycle Processors

Handle application lifecycle events and build phase coordination.

/**
 * Startup build steps processor
 */
public class StartupBuildSteps {
    /**
     * Configure startup event handling
     */
    @BuildStep
    @Record(ExecutionTime.STATIC_INIT)
    public void configureStartup(StartupRecorder recorder);
}

/**
 * Shutdown build steps processor
 */
public class ShutdownBuildSteps {
    /**
     * Configure shutdown event handling
     */
    @BuildStep  
    @Record(ExecutionTime.STATIC_INIT)
    public void configureShutdown(ShutdownRecorder recorder);
}

Processor Patterns

Build Step Dependencies

@BuildStep
public OutputBuildItem processData(
    // Consumed build items (dependencies)
    InputBuildItem input,
    List<MultiBuildItem> multiples,
    
    // Produced build items (outputs)
    BuildProducer<ProducedBuildItem> producer
) {
    // Process inputs
    // Produce outputs via producer
    // Return single build item
}

Recorder Integration

@BuildStep
@Record(ExecutionTime.RUNTIME_INIT)
public void configureRuntime(
    BeanContainerBuildItem beanContainer,
    MyRecorder recorder
) {
    // Use recorder to capture runtime initialization logic
    recorder.initialize(beanContainer.getValue());
}

Conditional Processing

@BuildStep(onlyIf = DatabaseEnabled.class)
public DatabaseBuildItem setupDatabase() {
    return new DatabaseBuildItem();
}

public static class DatabaseEnabled implements BooleanSupplier {
    @Override
    public boolean getAsBoolean() {
        return ConfigProvider.getConfig()
            .getOptionalValue("database.enabled", Boolean.class)
            .orElse(false);
    }
}

Processors form the backbone of Quarkus's build-time CDI processing, enabling the creation of optimized, GraalVM-native compatible applications with fast startup times.

Install with Tessl CLI

npx tessl i tessl/maven-io-quarkus--quarkus-arc-deployment

docs