or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

application-lifecycle.mdbuild-time.mdconfiguration.mdindex.mdlogging.mdnative-image.mdruntime-context.md
tile.json

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

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

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/io.quarkus/quarkus-core@3.23.x

To install, run

npx @tessl/cli install tessl/maven-io-quarkus--quarkus-core@3.23.0

index.mddocs/

Quarkus Core Runtime

Quarkus Core Runtime provides the foundational components for Quarkus, a Cloud Native and Container First Java framework designed for building high-performance applications with minimal footprint. It includes essential runtime services, dependency injection capabilities, configuration management, and core infrastructure needed to run Quarkus applications.

Package Information

  • Package Name: quarkus-core
  • Package Type: maven
  • Group ID: io.quarkus
  • Artifact ID: quarkus-core
  • Language: Java
  • Installation: Include in your Maven pom.xml:
<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-core</artifactId>
    <version>3.23.0</version>
</dependency>

Core Imports

// Application lifecycle and entry points
import io.quarkus.runtime.Quarkus;
import io.quarkus.runtime.QuarkusApplication;
import io.quarkus.runtime.Application;

// Lifecycle events
import io.quarkus.runtime.StartupEvent;
import io.quarkus.runtime.ShutdownEvent;

// Runtime context
import io.quarkus.runtime.LaunchMode;
import io.quarkus.runtime.ExecutionMode;

// Configuration annotations
import io.quarkus.runtime.annotations.ConfigRoot;
import io.quarkus.runtime.annotations.ConfigItem;

// Reflection and native image support
import io.quarkus.runtime.annotations.RegisterForReflection;

// Logging
import io.quarkus.logging.Log;

Basic Usage

Simple Application Startup

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

@QuarkusMain
public class MyApplication implements QuarkusApplication {
    @Override
    public int run(String... args) throws Exception {
        System.out.println("Application starting...");
        
        // Application logic here
        
        Quarkus.waitForExit();
        return 0;
    }
}

Lifecycle Event Handling

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

public class LifecycleHandler {
    
    void onStart(@Observes StartupEvent ev) {
        Log.info("Application starting up");
    }
    
    void onStop(@Observes ShutdownEvent ev) {
        Log.info("Application shutting down");
        if (ev.isStandardShutdown()) {
            Log.info("Standard shutdown");
        }
    }
}

Configuration

import io.quarkus.runtime.annotations.ConfigRoot;
import io.quarkus.runtime.annotations.ConfigItem;
import io.quarkus.runtime.annotations.ConfigPhase;

@ConfigRoot(phase = ConfigPhase.RUNTIME_INIT)
public class MyConfig {
    
    @ConfigItem(defaultValue = "default-value")
    public String property;
    
    @ConfigItem(defaultValue = "8080")
    public int port;
}

Architecture

Quarkus Core Runtime is organized into several key functional areas:

  • Application Lifecycle: Entry points, startup/shutdown management
  • Configuration System: Annotations and converters for application config
  • Reflection & Native Image: Registration for GraalVM native compilation
  • Build-Time Processing: Recorder annotations for bytecode generation
  • Logging: Simplified static logging facade
  • Threading Control: IO thread detection and blocking operation control
  • Runtime Context: Execution modes and launch mode detection

Capabilities

Application Lifecycle Management

Controls application startup, shutdown, and lifecycle events with support for both traditional and command-mode applications.

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

// Command-mode application interface
public interface QuarkusApplication {
    int run(String... args) throws Exception;
}

// Application lifecycle events
public class StartupEvent extends jakarta.enterprise.event.Startup {}
public class ShutdownEvent extends jakarta.enterprise.event.Shutdown {
    public boolean isStandardShutdown();
}

Application Lifecycle

Configuration System

Comprehensive configuration management with annotations, converters, and runtime configuration support.

// Configuration root annotation
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface ConfigRoot {
    ConfigPhase phase() default ConfigPhase.RUNTIME_INIT;
}

// Configuration item annotation
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.METHOD})
public @interface ConfigItem {
    String name() default "";
    String defaultValue() default "";
    boolean generateDocumentation() default true;
}

// Configuration phases
public enum ConfigPhase {
    BUILD_TIME, RUNTIME_INIT, BOOTSTRAP
}

Configuration System

Runtime Context and Threading

Provides execution mode detection, launch mode management, and threading control for optimal performance.

// Launch mode detection
public enum LaunchMode {
    NORMAL, DEVELOPMENT, TEST;
    
    public boolean isDevOrTest();
    public String getDefaultProfile();
    public static LaunchMode current();
    public static boolean isDev();
    public static boolean isRemoteDev();
}

// Execution mode tracking
public enum ExecutionMode {
    STATIC_INIT, RUNTIME_INIT, RUNNING, UNSET;
    
    public static ExecutionMode current();
}

// Blocking operation control
public final class BlockingOperationControl {
    public static boolean isBlockingAllowed();
    public static void setIoThreadDetector(IOThreadDetector... detectors);
}

Runtime Context and Threading

Native Image and Reflection Support

Registration system for GraalVM native image compilation with reflection and proxy support.

// Reflection registration
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface RegisterForReflection {
    boolean methods() default true;
    boolean fields() default true;
    boolean ignoreNested() default false;
    Class<?>[] targets() default {};
    String[] classNames() default {};
    boolean serialization() default false;
    boolean registerFullHierarchy() default false;
}

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

Native Image Support

Build-Time Processing

Recorder system for build-time code generation and bytecode manipulation.

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

// Initialization phase markers
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface StaticInit {}

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

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

Build-Time Processing

Logging System

Static logging facade with build-time optimization and multiple log levels.

public final class Log {
    // Level checking
    public static boolean isTraceEnabled();
    public static boolean isDebugEnabled();
    public static boolean isInfoEnabled();
    public static boolean isWarnEnabled();
    public static boolean isErrorEnabled();
    public static boolean isFatalEnabled();
    public static boolean isEnabled(Logger.Level level);
    
    // Logging methods (trace, debug, info, warn, error, fatal)
    public static void trace(Object message);
    public static void trace(Object message, Throwable t);
    public static void tracef(String format, Object... params);
    public static void tracev(String format, Object... params);
    // Similar methods for debug, info, warn, error, fatal
    
    // Generic logging
    public static void log(Logger.Level level, Object message);
    public static void log(Logger.Level level, Object message, Throwable t);
}

Logging System

CDI and Dependency Injection

Arc CDI container integration providing access to CDI context and bean management.

// CDI container access
public final class Arc {
    public static ArcContainer initialize();
    public static ArcContainer initialize(ArcInitConfig config);
    public static ArcContainer container();
    public static void shutdown();
    public static void setExecutor(ExecutorService executor);
}

// Main CDI container interface
public interface ArcContainer {
    // Bean access
    <T> InstanceHandle<T> instance(Class<T> type, Annotation... qualifiers);
    <T> InstanceHandle<T> instance(TypeLiteral<T> type, Annotation... qualifiers);
    <T> InjectableInstance<T> select(Class<T> type, Annotation... qualifiers);
    <T> InjectableInstance<T> select(TypeLiteral<T> type, Annotation... qualifiers);
    <T> Supplier<InstanceHandle<T>> instanceSupplier(Class<T> type, Annotation... qualifiers);
    
    // Bean listing
    <T> List<InstanceHandle<T>> listAll(Class<T> type, Annotation... qualifiers);
    <T> List<InstanceHandle<T>> listAll(TypeLiteral<T> type, Annotation... qualifiers);
    
    // Context management
    ManagedContext requestContext();
    InjectableContext getActiveContext(Class<? extends Annotation> scopeType);
    Collection<InjectableContext> getContexts(Class<? extends Annotation> scopeType);
    
    // CDI integration
    BeanManager beanManager();
    void shutdown();
}

// Instance handle for managed beans
interface InstanceHandle<T> extends AutoCloseable {
    T get();
    InjectableBean<T> getBean();
    void destroy();
    void close();
    boolean isAvailable();
}

// Injectable instance for programmatic lookup
interface InjectableInstance<T> extends Instance<T>, Iterable<T> {
    <U extends T> InjectableInstance<U> select(Class<U> subtype, Annotation... qualifiers);
    <U extends T> InjectableInstance<U> select(TypeLiteral<U> subtype, Annotation... qualifiers);
    InjectableInstance<T> select(Annotation... qualifiers);
    InstanceHandle<T> getHandle();
    Iterable<InstanceHandle<T>> handles();
}

Types

Core Types

// Application base class
public abstract class Application implements Closeable {
    public abstract void doStart(String[] args) throws Exception;
    public abstract void doStop() throws Exception;
    public abstract String getName();
    
    // Instance methods
    public void start(String[] args) throws Exception;
    public void stop();
    public void stop(Runnable afterStopTask);
    public void close();
    public void awaitShutdown();
    public boolean isStarted();
    public static Application currentApplication();
}

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

// Shutdown task context
public interface ShutdownContext {
    void addShutdownTask(Runnable runnable);
    void addLastShutdownTask(Runnable runnable);
}

// IO thread detector interface
public interface IOThreadDetector {
    boolean isInIOThread();
}

Configuration Types

// Memory size representation
public final class MemorySize {
    public MemorySize(long bytes);
    public long getBytes();
    public static MemorySize parse(String input);
    
    // String representation methods
    public String toString();
    public String toHumanReadableString();
}

// Configuration converters
public class DurationConverter implements Converter<Duration> {
    public Duration convert(String value);
}

public class MemorySizeConverter implements Converter<MemorySize> {
    public MemorySize convert(String value);
}

public class PathConverter implements Converter<Path> {
    public Path convert(String value);
}

public class InetAddressConverter implements Converter<InetAddress> {
    public InetAddress convert(String value);
}

Exception Types

// Runtime exceptions
public class BlockingOperationNotAllowedException extends IllegalStateException {
    public BlockingOperationNotAllowedException(String message);
}

public class QuarkusBindException extends RuntimeException {
    public QuarkusBindException(String message, Throwable cause);
}

public class ConfigurationException extends RuntimeException {
    public ConfigurationException(String message);
    public ConfigurationException(String message, Throwable cause);
}

public class PreventFurtherStepsException extends RuntimeException {
    public PreventFurtherStepsException(String message);
}