tessl/maven-io-quarkus--quarkus-bom

Cloud Native, Container First Java framework for building efficient Java applications with fast startup times and low memory usage

—

Pending

Overview

Eval results

Files

Core Runtime and Application Lifecycle

Name: tessl/maven-io-quarkus--quarkus-bom
Author: tessl

The Quarkus core runtime provides the fundamental classes and annotations for application lifecycle management, main entry points, and build-time processing configuration.

Core Application Classes

Quarkus Main Class

public class Quarkus {
    public static void run(Class<? extends QuarkusApplication> application, String... args);
    public static void run(Class<? extends QuarkusApplication> application, 
                           BiConsumer<Integer, Throwable> exitHandler, String... args);
    public static void run(String... args);
    public static void waitForExit();
    public static void blockingExit();
    public static void asyncExit();
    public static void asyncExit(int code);
    public static boolean isMainThread(Thread thread);
    public static void manualInitialize();
    public static void manualStart();
}

The primary entry point for Quarkus applications. Use run() to start an application and waitForExit() to block until shutdown.

Usage Example:

import io.quarkus.runtime.Quarkus;
import io.quarkus.runtime.QuarkusApplication;

public static void main(String... args) {
    Quarkus.run(MyApp.class, args);
}

public static class MyApp implements QuarkusApplication {
    @Override
    public int run(String... args) throws Exception {
        // Application logic here
        Quarkus.waitForExit();
        return 0;
    }
}

QuarkusApplication Interface

public interface QuarkusApplication {
    int run(String... args) throws Exception;
}

Interface for command-mode applications with custom startup logic. Implement this interface when you need to control the application lifecycle beyond simple REST services.

Application Abstract Class

public abstract class Application implements Closeable {
    public static final String APP_CLASS_NAME = "io.quarkus.runner.ApplicationImpl";
    
    // Public lifecycle methods
    public final void start(String[] args);
    public final void stop();
    public final void stop(Runnable afterStopTask);
    public final void close();
    public void awaitShutdown();
    public boolean isStarted();
    
    // Static access
    public static Application currentApplication();
    
    // Abstract methods for subclasses
    protected abstract void doStart(String[] args);
    protected abstract void doStop();
    public abstract String getName();
}

Base abstract class for Quarkus applications providing thread-safe lifecycle management. Generated application classes extend this to provide the actual implementation.

ApplicationLifecycleManager

public class ApplicationLifecycleManager {
    public static final String QUARKUS_APPCDS_GENERATE_PROP = "quarkus.appcds.generate";
    
    // Application lifecycle
    public static void run(Application application, String... args);
    public static void run(Application application, Class<? extends QuarkusApplication> quarkusApplication,
                          BiConsumer<Integer, Throwable> exitCodeHandler, String... args);
    
    // Application access and state
    public static Application getCurrentApplication();
    public static int getExitCode();
    public static boolean isVmShuttingDown();
    public static boolean isAppCDSGeneration();
    
    // Exit handling
    public static void exit();
    public static void exit(int code);
    public static void waitForExit();
    
    // Exit code handlers
    public static BiConsumer<Integer, Throwable> getDefaultExitCodeHandler();
    public static void setDefaultExitCodeHandler(BiConsumer<Integer, Throwable> defaultExitCodeHandler);
    public static void setDefaultExitCodeHandler(Consumer<Integer> defaultExitCodeHandler);
    
    // Callbacks
    public static void setAlreadyStartedCallback(Consumer<Boolean> alreadyStartedCallback);
}

Manages application lifecycle including startup, shutdown handling, exit code management, and signal handling for graceful termination.

Core Annotations

@QuarkusMain

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface QuarkusMain {
    String name() default "";
}

Marks the main entry point class for a Quarkus application. Use this when you need a custom main method instead of standard REST services.

Usage Example:

@QuarkusMain
public class Main {
    public static void main(String... args) {
        Quarkus.run(HelloApp.class, args);
    }
    
    public static class HelloApp implements QuarkusApplication {
        @Override
        public int run(String... args) throws Exception {
            System.out.println("Application started");
            Quarkus.waitForExit();
            return 0;
        }
    }
}

Build-Time Processing Annotations

@Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface RegisterForReflection {
    Class<?>[] value() default {};
    String[] classNames() default {};
    boolean methods() default true;
    boolean fields() default true;
    boolean ignoreNested() default false;
}

Registers classes for reflection in native image compilation.

Usage Example:

@RegisterForReflection(classNames = {"com.example.MyClass", "com.example.AnotherClass"})
public class ReflectionConfiguration {
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface RegisterForProxy {
    Class<?>[] value() default {};
}

Registers interfaces for dynamic proxy generation in native images.

@Target(ElementType.CONSTRUCTOR)
@Retention(RetentionPolicy.RUNTIME)
public @interface RecordableConstructor {
}

Marks constructors as recordable during build-time processing.

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Recorder {
}

Marks classes that participate in bytecode recording during the build process.

Initialization Phase Annotations

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface StaticInit {
}

Indicates that a recorder method should run during static initialization phase.

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RuntimeInit {
}

Indicates that a recorder method should run during runtime initialization phase.

Application Lifecycle Events

Startup and Shutdown Events

public class StartupEvent {
    // CDI event fired during application startup
}

public class ShutdownEvent {
    // CDI event fired during application shutdown
}

CDI events that can be observed to hook into application lifecycle.

Usage Example:

import jakarta.enterprise.event.Observes;

@ApplicationScoped
public class LifecycleBean {
    
    void onStart(@Observes StartupEvent ev) {
        System.out.println("The application is starting...");
    }

    void onStop(@Observes ShutdownEvent ev) {
        System.out.println("The application is stopping...");
    }
}

Lifecycle Annotations

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Startup {
    int value() default 0;  // Priority
}

Marks methods to execute during application startup.

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Shutdown {
    int value() default 0;  // Priority
}

Marks methods to execute during application shutdown.

Usage Example:

@ApplicationScoped
public class AppInitializer {
    
    @Startup
    void init() {
        System.out.println("Initializing application resources...");
    }
    
    @Shutdown
    void cleanup() {
        System.out.println("Cleaning up application resources...");
    }
}

StartupTask Interface

public interface StartupTask {
    void deploy(StartupContext context);
}

Interface for implementing build-time startup initialization tasks. Generally provided by generated bytecode during Quarkus build process.

public class StartupContext implements Closeable {
    public void putValue(String name, Object value);
    public Object getValue(String name);
    public void close();
    public void setCommandLineArguments(String[] commandLineArguments);
    public String getCurrentBuildStepName();
    public void setCurrentBuildStepName(String currentBuildStepName);
}

ExecutionModeManager

public final class ExecutionModeManager {
    public static void staticInit();
    public static void runtimeInit();
    public static void running();
    public static void unset();
    public static ExecutionMode getExecutionMode();
}

public enum ExecutionMode {
    STATIC_INIT,      // Static initialization phase
    RUNTIME_INIT,     // Runtime initialization phase  
    RUNNING,          // Application is running
    UNSET;            // Unset state
    
    public static ExecutionMode current();
}

Manages the current execution phase during Quarkus application lifecycle. The ExecutionMode enum tracks whether the application is in static initialization, runtime initialization, running, or unset state.

Configuration Runtime Support

QuarkusConfigFactory

public final class QuarkusConfigFactory extends SmallRyeConfigFactory {
    @Override
    public SmallRyeConfig getConfigFor(SmallRyeConfigProviderResolver configProviderResolver, 
                                       ClassLoader classLoader);
    public static void setConfig(SmallRyeConfig config);
    public static void releaseTCCLConfig();
}

Factory for creating and managing SmallRye configuration instances with Quarkus-specific enhancements.

ConfigUtils

public final class ConfigUtils {
    public static SmallRyeConfigBuilder configBuilder();
    public static SmallRyeConfigBuilder emptyConfigBuilder();
    public static List<String> getProfiles();
    public static boolean isProfileActive(String profile);
    public static boolean isPropertyPresent(String propertyName);
    public static boolean isPropertyNonEmpty(String propertyName);
    public static boolean isAnyPropertyPresent(Collection<String> propertyNames);
    public static <T> Optional<T> getFirstOptionalValue(List<String> propertyNames, Class<T> propertyType);
}

Utility methods for configuration management, profile checking, and property validation.

ConfigurationException

public class ConfigurationException extends RuntimeException implements ConfigurationProblem {
    public ConfigurationException(Set<String> configKeys);
    public ConfigurationException(String msg);
    public ConfigurationException(String msg, Set<String> configKeys);
    public ConfigurationException(Throwable cause, Set<String> configKeys);
    public ConfigurationException(String msg, Throwable cause);
    public ConfigurationException(String msg, Throwable cause, Set<String> configKeys);
    public ConfigurationException(Throwable cause);
    
    public Set<String> getConfigKeys();
}

Exception thrown for configuration-related errors with support for tracking problematic configuration keys.

Install with Tessl CLI

npx tessl i tessl/maven-io-quarkus--quarkus-bom

docs

cdi-dependency-injection.md

reactive-programming.md

tessl/maven-io-quarkus--quarkus-bom

core-runtime.md.css-3qkkll{font-size:var(--chakra-font-sizes-sm);font-weight:var(--chakra-font-weights-normal);color:var(--chakra-colors-gray-300);}docs/

Core Runtime and Application Lifecycle

Core Application Classes

Quarkus Main Class

QuarkusApplication Interface

Application Abstract Class

ApplicationLifecycleManager

Core Annotations

@QuarkusMain

Build-Time Processing Annotations

Initialization Phase Annotations

Application Lifecycle Events

Startup and Shutdown Events

Lifecycle Annotations

StartupTask Interface

ExecutionModeManager

Configuration Runtime Support

QuarkusConfigFactory

ConfigUtils

ConfigurationException

core-runtime.mddocs/