tessl/maven-io-quarkus--quarkus-core

Quarkus core components - runtime library for the Cloud Native, Container First Java framework

—

Pending

Overview

Eval results

Files

Application Lifecycle

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

The Application Lifecycle capability manages the complete lifecycle of Quarkus applications, from startup to shutdown, including lifecycle events and application modes.

Core Classes

Main Application Entry Point

public final class Quarkus {
    // Run QuarkusApplication until completion
    public static int run(Class<? extends QuarkusApplication> quarkusApplication, String... args);
    
    // Run with custom exit handling
    public static int run(Class<? extends QuarkusApplication> quarkusApplication, 
                         BiConsumer<Integer, Throwable> exitHandler, String... args);
    
    // Start application that runs until signal or exit call
    public static void run(String... args);
    
    // Shutdown methods
    public static void asyncExit(int code);
    public static void asyncExit();
    public static void waitForExit();
    public static void blockingExit();
    
    // Manual lifecycle control for serverless environments
    public static void manualInitialize();
    public static void manualStart();
    
    // Thread checking
    public static boolean isMainThread(Thread thread);
}

Application Interface

// Interface for command-mode applications
public interface QuarkusApplication {
    /**
     * Main application entry point.
     * @param args Command line arguments
     * @return Exit code (0 for success, non-zero for error)
     * @throws Exception Any unhandled exception
     */
    int run(String... args) throws Exception;
}

Application Base Class

public abstract class Application implements Closeable {
    // Abstract methods for subclasses
    public abstract void doStart(String[] args) throws Exception;
    public abstract void doStop() throws Exception;
    public abstract String getName();
    
    // Lifecycle management
    public void start(String[] args) throws Exception;
    public void stop();
    public void stop(Runnable afterStopTask);
    public void close();
    public void awaitShutdown();
    
    // State checking
    public boolean isStarted();
    
    // Static access to current application
    public static Application currentApplication();
}

Lifecycle Events

Startup Event

public class StartupEvent extends jakarta.enterprise.event.Startup {
    // CDI event fired after application startup
    // Use with @Observes annotation
}

Shutdown Event

public class ShutdownEvent extends jakarta.enterprise.event.Shutdown {
    /**
     * Check if this is a standard shutdown (vs signal-based)
     * @return true for normal shutdown, false for signal interruption
     */
    public boolean isStandardShutdown();
    
    public enum ShutdownReason {
        STANDARD,      // Normal application shutdown
        NON_STANDARD   // Signal-based shutdown (SIGTERM, SIGINT)
    }
}

Startup Task Interface

public interface StartupTask {
    /**
     * Execute startup task during application initialization.
     * @param context Startup context for sharing data between tasks
     * @throws Exception Any initialization error
     */
    void deploy(StartupContext context) throws Exception;
}

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

Main Method Annotation

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface QuarkusMain {
    /**
     * Unique name for the main method (optional).
     * @return Main method name
     */
    String name() default "";
}

Usage Examples

Basic Application

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

@QuarkusMain
public class SimpleApplication implements QuarkusApplication {
    @Override
    public int run(String... args) throws Exception {
        System.out.println("Application started with args: " + Arrays.toString(args));
        
        // Application logic here
        doBusinessLogic();
        
        // Wait for shutdown signal
        Quarkus.waitForExit();
        return 0;
    }
    
    private void doBusinessLogic() {
        // Your application logic
    }
}

Lifecycle Event Handling

import jakarta.enterprise.context.ApplicationScoped;
import jakarta.enterprise.event.Observes;
import io.quarkus.runtime.StartupEvent;
import io.quarkus.runtime.ShutdownEvent;
import io.quarkus.logging.Log;

@ApplicationScoped
public class ApplicationLifecycleHandler {
    
    void onStart(@Observes StartupEvent event) {
        Log.info("Application is starting up");
        // Initialize resources, connections, etc.
        initializeResources();
    }
    
    void onStop(@Observes ShutdownEvent event) {
        Log.info("Application is shutting down");
        if (event.isStandardShutdown()) {
            Log.info("Normal shutdown process");
        } else {
            Log.warn("Emergency shutdown (signal received)");
        }
        // Cleanup resources
        cleanupResources();
    }
    
    private void initializeResources() {
        // Resource initialization logic
    }
    
    private void cleanupResources() {
        // Resource cleanup logic
    }
}

Custom Exit Handler

import io.quarkus.runtime.Quarkus;
import io.quarkus.runtime.QuarkusApplication;
import java.util.function.BiConsumer;

public class ApplicationWithCustomExit implements QuarkusApplication {
    @Override
    public int run(String... args) throws Exception {
        BiConsumer<Integer, Throwable> exitHandler = (exitCode, throwable) -> {
            if (throwable != null) {
                System.err.println("Application failed: " + throwable.getMessage());
            }
            System.out.println("Application exiting with code: " + exitCode);
        };
        
        Quarkus.run(MyMainApplication.class, exitHandler, args);
        return 0;
    }
}

class MyMainApplication implements QuarkusApplication {
    @Override
    public int run(String... args) throws Exception {
        // Main application logic
        return 0;
    }
}

Serverless Application (Lambda/Azure Functions)

import io.quarkus.runtime.Quarkus;

public class ServerlessHandler {
    private static boolean initialized = false;
    
    public String handleRequest(String input) {
        if (!initialized) {
            // Manual initialization for serverless
            Quarkus.manualInitialize();
            Quarkus.manualStart();
            initialized = true;
        }
        
        // Process request
        return processInput(input);
    }
    
    private String processInput(String input) {
        // Your business logic
        return "Processed: " + input;
    }
}

Multiple Main Methods

@QuarkusMain(name = "web-server")
public class WebServerApplication implements QuarkusApplication {
    @Override
    public int run(String... args) throws Exception {
        // Start web server
        return 0;
    }
}

@QuarkusMain(name = "batch-processor")
public class BatchProcessorApplication implements QuarkusApplication {
    @Override
    public int run(String... args) throws Exception {
        // Run batch processing
        return 0;
    }
}

Run specific main method:

java -jar app.jar -Dquarkus.main.name=batch-processor

Error Handling

The lifecycle system provides several exception types for different failure scenarios:

// Thrown when port binding fails during startup
public class QuarkusBindException extends RuntimeException {
    public QuarkusBindException(String message, Throwable cause);
}

// Internal exception to halt build steps
public class PreventFurtherStepsException extends RuntimeException {
    public PreventFurtherStepsException(String message);
}

Install with Tessl CLI

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

docs

application-lifecycle.md