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

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

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

Quarkus Core Runtime

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

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);
}