tessl/maven-io-micronaut--micronaut-inject

Core dependency injection interfaces and components for the Micronaut Framework

—

Pending

Overview

Eval results

Files

Application Context Management

Name: tessl/maven-io-micronaut--micronaut-inject
Author: tessl

The ApplicationContext is the main IoC container in Micronaut Inject, responsible for managing bean lifecycle, dependency resolution, and application configuration. It extends BeanContext with additional capabilities for application bootstrapping and environment management.

Core Interfaces

ApplicationContext

The primary interface for the Micronaut IoC container.

public interface ApplicationContext extends BeanContext, LifeCycle<ApplicationContext> {
    static ApplicationContext run();
    static ApplicationContext run(Class<?> mainClass, String... args);
    static ApplicationContext run(String... args);
    static ApplicationContextBuilder builder();
    static ApplicationContextBuilder builder(Class<?> mainClass, String... args);
    
    Environment getEnvironment();
    <T> ApplicationContext registerSingleton(Class<T> type, T singleton);
    ApplicationContext start();
    ApplicationContext stop();
}

BeanContext

Core interface for bean resolution and management.

public interface BeanContext extends BeanLocator {
    <T> T getBean(Class<T> beanType);
    <T> T getBean(Class<T> beanType, Qualifier<T> qualifier);
    <T> Optional<T> findBean(Class<T> beanType);
    <T> Optional<T> findBean(Class<T> beanType, Qualifier<T> qualifier);
    <T> Collection<T> getBeansOfType(Class<T> beanType);
    <T> Collection<T> getBeansOfType(Class<T> beanType, Qualifier<T> qualifier);
    <T> BeanDefinition<T> getBeanDefinition(Class<T> beanType);
    <T> BeanDefinition<T> getBeanDefinition(Class<T> beanType, Qualifier<T> qualifier);
    <T> Collection<BeanDefinition<T>> getBeanDefinitions(Class<T> beanType);
    boolean containsBean(Class<?> beanType);
    <T> T createBean(Class<T> beanType);
    <T> T createBean(Class<T> beanType, Qualifier<T> qualifier);
    <T> void destroyBean(T bean);
}

ApplicationContextBuilder

Builder for configuring ApplicationContext instances.

public interface ApplicationContextBuilder {
    ApplicationContextBuilder environments(String... environments);
    ApplicationContextBuilder properties(Map<String, Object> properties);
    ApplicationContextBuilder singletons(Object... beans);
    ApplicationContextBuilder packages(String... packages);
    ApplicationContextBuilder args(String... args);
    ApplicationContext build();
}

Usage Examples

Basic Application Context

import io.micronaut.context.ApplicationContext;

public class BasicExample {
    public static void main(String[] args) {
        // Create and start application context
        try (ApplicationContext context = ApplicationContext.run()) {
            // Get beans from context
            MyService service = context.getBean(MyService.class);
            service.doSomething();
        } // Context automatically closed
    }
}

Configured Application Context

import io.micronaut.context.ApplicationContext;
import java.util.Map;

public class ConfiguredExample {
    public static void main(String[] args) {
        ApplicationContext context = ApplicationContext.builder()
            .environments("dev", "local")
            .properties(Map.of(
                "app.name", "MyApp",
                "database.url", "jdbc:h2:mem:test"
            ))
            .packages("com.example.services")
            .build()
            .start();
            
        try {
            MyService service = context.getBean(MyService.class);
            service.process();
        } finally {
            context.close();
        }
    }
}

Manual Bean Registration

import io.micronaut.context.ApplicationContext;

public class ManualRegistrationExample {
    public static void main(String[] args) {
        try (ApplicationContext context = ApplicationContext.run()) {
            // Register singleton instances
            MyConfig config = new MyConfig("production");
            context.registerSingleton(MyConfig.class, config);
            
            // Create bean that depends on registered singleton
            MyService service = context.getBean(MyService.class);
            service.initialize();
        }
    }
}

Bean Resolution with Qualifiers

import io.micronaut.context.ApplicationContext;
import io.micronaut.context.Qualifier;
import io.micronaut.inject.qualifiers.Qualifiers;

public class QualifierExample {
    public static void main(String[] args) {
        try (ApplicationContext context = ApplicationContext.run()) {
            // Get bean by type only
            DatabaseService dbService = context.getBean(DatabaseService.class);
            
            // Get bean with named qualifier
            DatabaseService mysqlService = context.getBean(
                DatabaseService.class, 
                Qualifiers.byName("mysql")
            );
            
            // Get all beans of a type
            Collection<DatabaseService> allServices = 
                context.getBeansOfType(DatabaseService.class);
            
            // Optional bean resolution
            Optional<CacheService> cacheService = 
                context.findBean(CacheService.class);
        }
    }
}

Bean Lifecycle Management

Creating and Destroying Beans

import io.micronaut.context.ApplicationContext;

public class LifecycleExample {
    public static void main(String[] args) {
        try (ApplicationContext context = ApplicationContext.run()) {
            // Create prototype bean instances
            PrototypeBean bean1 = context.createBean(PrototypeBean.class);
            PrototypeBean bean2 = context.createBean(PrototypeBean.class);
            
            // Use beans
            bean1.doWork();
            bean2.doWork();
            
            // Manually destroy beans when done
            context.destroyBean(bean1);
            context.destroyBean(bean2);
        }
    }
}

Checking Bean Availability

import io.micronaut.context.ApplicationContext;

public class AvailabilityExample {
    public static void main(String[] args) {
        try (ApplicationContext context = ApplicationContext.run()) {
            // Check if bean is available
            if (context.containsBean(EmailService.class)) {
                EmailService emailService = context.getBean(EmailService.class);
                emailService.sendWelcomeEmail();
            }
            
            // Get all bean definitions for a type
            Collection<BeanDefinition<MessageService>> definitions = 
                context.getBeanDefinitions(MessageService.class);
                
            for (BeanDefinition<MessageService> def : definitions) {
                System.out.println("Found bean: " + def.getBeanType());
            }
        }
    }
}

Implementation Classes

DefaultApplicationContext

The default implementation of ApplicationContext.

public class DefaultApplicationContext implements ApplicationContext {
    public DefaultApplicationContext();
    public DefaultApplicationContext(String... environments);
    public DefaultApplicationContext(ApplicationContextConfiguration configuration);
    
    // Implements all ApplicationContext methods
}

Context Configuration

ApplicationContextConfiguration

Configuration interface for customizing ApplicationContext behavior.

public interface ApplicationContextConfiguration {
    List<String> getEnvironments();
    Optional<Boolean> isEagerInitSingletons();
    Optional<Boolean> isEagerInitConfiguration();
    ClassLoader getClassLoader();
}

Error Handling

Common exceptions when working with ApplicationContext:

BeanContextException: Base exception for context-related errors
NoSuchBeanException: When a required bean cannot be found
NonUniqueBeanException: When multiple beans match but only one expected
BeanInstantiationException: When bean creation fails

try (ApplicationContext context = ApplicationContext.run()) {
    MyService service = context.getBean(MyService.class);
} catch (NoSuchBeanException e) {
    System.err.println("Service not found: " + e.getMessage());
} catch (BeanInstantiationException e) {
    System.err.println("Failed to create service: " + e.getMessage());
}

Install with Tessl CLI

npx tessl i tessl/maven-io-micronaut--micronaut-inject

docs

annotations.md

application-context.md

environment-config.md