Application Runtime

/**
 * Main entry point for running a Micronaut application
 * Extends DefaultApplicationContextBuilder for configuration chaining
 */
public class Micronaut extends DefaultApplicationContextBuilder implements ApplicationContextBuilder {
    
    /** 
     * Run application with automatic class discovery 
     * @param args Command line arguments
     * @return Started ApplicationContext
     */
    public static ApplicationContext run(String... args);
    
    /**
     * Run application with specific main class
     * @param cls The application class to run
     * @param args Command line arguments
     * @return Started ApplicationContext
     */
    public static ApplicationContext run(Class<?> cls, String... args);
    
    /**
     * Run application with multiple classes
     * @param classes Array of application classes
     * @param args Command line arguments
     * @return Started ApplicationContext
     */
    public static ApplicationContext run(Class<?>[] classes, String... args);
    
    /**
     * Create Micronaut builder instance with arguments
     * @param args Command line arguments
     * @return Micronaut builder for configuration chaining
     */
    public static Micronaut build(String... args);
    
    /**
     * Start the application context and embedded applications
     * @return Started ApplicationContext
     */
    public ApplicationContext start();
    
    /**
     * Add classes to be included in application initialization
     * @param classes Classes to include
     * @return This Micronaut instance for chaining
     */
    public Micronaut classes(Class<?>... classes);
    
    /**
     * Map exception types to exit codes for startup error handling
     * @param exception Exception class to map
     * @param mapper Function to convert exception to exit code
     * @return This Micronaut instance for chaining
     */
    public <T extends Throwable> Micronaut mapError(Class<T> exception, Function<T, Integer> mapper);
    
    // Configuration methods (inherited from ApplicationContextBuilder)
    public Micronaut properties(Map<String, Object> properties);
    public Micronaut environments(String... environments);
    public Micronaut packages(String... packages);
    public Micronaut banner(boolean isEnabled);
}

// Simple application startup
public class Application {
    public static void main(String[] args) {
        ApplicationContext context = Micronaut.run(Application.class, args);
    }
}

// Configured application startup
public class ConfiguredApplication {
    public static void main(String[] args) {
        ApplicationContext context = Micronaut.build(args)
            .environments("production")
            .packages("com.example.services")
            .properties(Map.of("app.version", "1.0.0"))
            .start();
    }
}

// Error handling configuration
public class RobustApplication {
    public static void main(String[] args) {
        ApplicationContext context = Micronaut.build(args)
            .mapError(IllegalStateException.class, ex -> 2)
            .mapError(SecurityException.class, ex -> 3)
            .start();
    }
}

/**
 * Interface for runnable applications that start and manage the ApplicationContext
 * @param <T> The application type
 */
public interface EmbeddedApplication<T> extends ApplicationContextLifeCycle<T> {
    
    /**
     * Get the application context managed by this application
     * @return The ApplicationContext instance
     */
    ApplicationContext getApplicationContext();
    
    /**
     * Get the application configuration
     * @return ApplicationConfiguration instance
     */
    ApplicationConfiguration getApplicationConfiguration();
    
    /**
     * Get the environment for this application
     * @return Environment instance
     */
    Environment getEnvironment();
    
    /**
     * Check if this is a long-running server application
     * @return true if this is a server application
     */
    boolean isServer();
    
    /**
     * Check if the application should force exit on shutdown
     * @return true if should force exit
     */
    boolean isForceExit();
    
    /**
     * Check if a shutdown hook should be registered
     * @return true if shutdown hook is needed
     */
    boolean isShutdownHookNeeded();
}

/**
 * Common application configuration settings
 * Bound to "micronaut.application" configuration prefix
 */
@ConfigurationProperties(ApplicationConfiguration.PREFIX)
public class ApplicationConfiguration {
    
    /** Configuration prefix for application settings */
    public static final String PREFIX = "micronaut.application";
    
    /** Property key for application name */
    public static final String APPLICATION_NAME = "micronaut.application.name";
    
    /**
     * Get the default character set for the application
     * @return Default Charset
     */
    public Charset getDefaultCharset();
    
    /**
     * Get the application name if configured
     * @return Optional application name
     */
    public Optional<String> getName();
    
    /**
     * Get instance-specific configuration
     * @return InstanceConfiguration for this application instance
     */
    public InstanceConfiguration getInstance();
}

# application.yml
micronaut:
  application:
    name: my-microservice
    instance:
      id: service-instance-1

// Accessing configuration
@Inject
ApplicationConfiguration appConfig;

public void logAppInfo() {
    String name = appConfig.getName().orElse("unnamed");
    Charset charset = appConfig.getDefaultCharset();
    System.out.println("App: " + name + ", Charset: " + charset);
}

/**
 * Exception thrown during application startup failures
 * Extends RuntimeException for unchecked exception handling
 */
public class ApplicationStartupException extends RuntimeException {
    public ApplicationStartupException(String message);
    public ApplicationStartupException(String message, Throwable cause);
}

try {
    ApplicationContext context = Micronaut.run(Application.class, args);
} catch (ApplicationStartupException e) {
    logger.error("Failed to start application: " + e.getMessage(), e);
    System.exit(1);
}