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

Core dependency injection interfaces and components for the Micronaut Framework

—

Pending

Overview

Eval results

Files

Configuration and Environment

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

The Micronaut environment and configuration system provides a powerful way to manage application settings, property sources, and environment-specific configurations. It supports property resolution from multiple sources with type conversion and validation.

Core Interfaces

Environment

Main interface for accessing application environment and configuration properties.

public interface Environment extends PropertyResolver {
    String DEVELOPMENT = "dev";
    String TEST = "test";
    String PRODUCTION = "prod";
    
    Collection<String> getActiveNames();
    Set<String> getPackages();
    <T> Optional<T> getProperty(String name, Class<T> requiredType);
    <T> T getProperty(String name, Class<T> requiredType, T defaultValue);
    boolean containsProperty(String name);
    boolean containsProperties(String name);
    Collection<PropertySource> getPropertySources();
    Environment addPropertySource(PropertySource propertySource);
    Environment removePropertySource(PropertySource propertySource);
}

PropertyResolver

Interface for resolving properties from various sources with type conversion.

public interface PropertyResolver {
    boolean containsProperty(String name);
    boolean containsProperties(String name);
    <T> Optional<T> getProperty(String name, Class<T> requiredType);
    <T> T getProperty(String name, Class<T> requiredType, T defaultValue);
    String getProperty(String name, String defaultValue);
    <T> Optional<T> getProperty(String name, ArgumentConversionContext<T> conversionContext);
    String resolvePlaceholders(String str);
    String resolveRequiredPlaceholders(String str) throws ConfigurationException;
    <T> T getRequiredProperty(String name, Class<T> requiredType) throws ConfigurationException;
}

PropertySource

Represents a source of configuration properties.

public interface PropertySource {
    String getName();
    Object get(String key);
    Iterator<String> iterator();
    int getOrder();
    PropertyConvention getConvention();
    
    static PropertySource of(String name, Map<String, Object> values);
    static PropertySource of(Map<String, Object> values);
}

Property Resolution

Basic Property Access

import io.micronaut.context.ApplicationContext;
import io.micronaut.context.env.Environment;

public class BasicPropertyExample {
    public static void main(String[] args) {
        try (ApplicationContext context = ApplicationContext.run()) {
            Environment env = context.getEnvironment();
            
            // Get string property with default
            String appName = env.getProperty("app.name", String.class, "DefaultApp");
            
            // Get typed property
            Integer port = env.getProperty("server.port", Integer.class, 8080);
            
            // Get boolean property
            Boolean debug = env.getProperty("app.debug", Boolean.class, false);
            
            // Check if property exists
            if (env.containsProperty("database.url")) {
                String dbUrl = env.getProperty("database.url", String.class);
                System.out.println("Database URL: " + dbUrl);
            }
            
            System.out.println("App: " + appName + ", Port: " + port + ", Debug: " + debug);
        }
    }
}

Required Properties

import io.micronaut.context.ApplicationContext;
import io.micronaut.context.env.Environment;
import io.micronaut.context.exceptions.ConfigurationException;

public class RequiredPropertyExample {
    public static void main(String[] args) {
        try (ApplicationContext context = ApplicationContext.run()) {
            Environment env = context.getEnvironment();
            
            try {
                // Get required property - throws exception if missing
                String apiKey = env.getRequiredProperty("api.key", String.class);
                System.out.println("API Key configured: " + apiKey.substring(0, 4) + "...");
                
            } catch (ConfigurationException e) {
                System.err.println("Missing required configuration: " + e.getMessage());
            }
        }
    }
}

Property Placeholder Resolution

import io.micronaut.context.ApplicationContext;
import io.micronaut.context.env.Environment;

public class PlaceholderExample {
    public static void main(String[] args) {
        try (ApplicationContext context = ApplicationContext.run()) {
            Environment env = context.getEnvironment();
            
            // Resolve placeholders in strings
            String template = "Welcome to ${app.name} running on port ${server.port:8080}";
            String resolved = env.resolvePlaceholders(template);
            System.out.println(resolved);
            
            // Required placeholder resolution
            try {
                String requiredTemplate = "Database: ${database.url}";
                String requiredResolved = env.resolveRequiredPlaceholders(requiredTemplate);
                System.out.println(requiredResolved);
            } catch (ConfigurationException e) {
                System.err.println("Failed to resolve placeholder: " + e.getMessage());
            }
        }
    }
}

Environment Management

Active Environments

import io.micronaut.context.ApplicationContext;
import io.micronaut.context.env.Environment;

public class EnvironmentExample {
    public static void main(String[] args) {
        try (ApplicationContext context = ApplicationContext.run("dev", "local")) {
            Environment env = context.getEnvironment();
            
            // Get active environment names
            Collection<String> activeEnvironments = env.getActiveNames();
            System.out.println("Active environments: " + activeEnvironments);
            
            // Check for specific environment
            if (activeEnvironments.contains(Environment.DEVELOPMENT)) {
                System.out.println("Running in development mode");
            }
            
            // Environment-specific configuration
            if (activeEnvironments.contains("local")) {
                String localDbUrl = env.getProperty("database.url", String.class, "jdbc:h2:mem:test");
                System.out.println("Local database: " + localDbUrl);
            }
        }
    }
}

Package Scanning

import io.micronaut.context.ApplicationContext;
import io.micronaut.context.env.Environment;

public class PackageExample {
    public static void main(String[] args) {
        try (ApplicationContext context = ApplicationContext.run()) {
            Environment env = context.getEnvironment();
            
            // Get scanned packages
            Set<String> packages = env.getPackages();
            System.out.println("Scanned packages: " + packages);
        }
    }
}

Property Sources

Working with Property Sources

import io.micronaut.context.ApplicationContext;
import io.micronaut.context.env.Environment;
import io.micronaut.context.env.PropertySource;
import java.util.Map;

public class PropertySourceExample {
    public static void main(String[] args) {
        try (ApplicationContext context = ApplicationContext.run()) {
            Environment env = context.getEnvironment();
            
            // Get all property sources
            Collection<PropertySource> sources = env.getPropertySources();
            for (PropertySource source : sources) {
                System.out.println("Property source: " + source.getName() + 
                                 " (order: " + source.getOrder() + ")");
            }
            
            // Add custom property source
            PropertySource customSource = PropertySource.of("custom", Map.of(
                "custom.setting", "value",
                "app.feature.enabled", true
            ));
            
            env.addPropertySource(customSource);
            
            // Access custom property
            String customSetting = env.getProperty("custom.setting", String.class);
            System.out.println("Custom setting: " + customSetting);
        }
    }
}

Creating Property Sources

import io.micronaut.context.env.PropertySource;
import java.util.Map;
import java.util.HashMap;

public class CustomPropertySourceExample {
    
    public static PropertySource createDatabasePropertySource() {
        Map<String, Object> props = new HashMap<>();
        props.put("datasources.default.url", "jdbc:postgresql://localhost/myapp");
        props.put("datasources.default.username", "appuser");
        props.put("datasources.default.driverClassName", "org.postgresql.Driver");
        
        return PropertySource.of("database-config", props);
    }
    
    public static PropertySource createFeatureFlags() {
        return PropertySource.of("feature-flags", Map.of(
            "features.new-ui", true,
            "features.beta-api", false,
            "features.analytics", true
        ));
    }
}

Configuration Properties

@ConfigurationProperties Usage

import io.micronaut.context.annotation.ConfigurationProperties;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.Max;

@ConfigurationProperties("database")
public class DatabaseConfig {
    
    @NotBlank
    private String url;
    
    @NotBlank  
    private String username;
    
    private String password;
    
    @Min(1)
    @Max(100)
    private int maxConnections = 10;
    
    private boolean ssl = false;
    
    // Getters and setters
    public String getUrl() { return url; }
    public void setUrl(String url) { this.url = url; }
    
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
    
    public String getPassword() { return password; }
    public void setPassword(String password) { this.password = password; }
    
    public int getMaxConnections() { return maxConnections; }
    public void setMaxConnections(int maxConnections) { this.maxConnections = maxConnections; }
    
    public boolean isSsl() { return ssl; }
    public void setSsl(boolean ssl) { this.ssl = ssl; }
}

Nested Configuration Properties

import io.micronaut.context.annotation.ConfigurationProperties;
import java.time.Duration;

@ConfigurationProperties("app")
public class ApplicationConfig {
    
    private String name;
    private String version;
    private Server server = new Server();
    private Security security = new Security();
    
    @ConfigurationProperties("server")
    public static class Server {
        private int port = 8080;
        private String host = "localhost";
        private Duration timeout = Duration.ofSeconds(30);
        
        // Getters and setters
        public int getPort() { return port; }
        public void setPort(int port) { this.port = port; }
        
        public String getHost() { return host; }
        public void setHost(String host) { this.host = host; }
        
        public Duration getTimeout() { return timeout; }
        public void setTimeout(Duration timeout) { this.timeout = timeout; }
    }
    
    @ConfigurationProperties("security")
    public static class Security {
        private boolean enabled = true;
        private String algorithm = "SHA-256";
        
        // Getters and setters  
        public boolean isEnabled() { return enabled; }
        public void setEnabled(boolean enabled) { this.enabled = enabled; }
        
        public String getAlgorithm() { return algorithm; }
        public void setAlgorithm(String algorithm) { this.algorithm = algorithm; }
    }
    
    // Main class getters and setters
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    
    public String getVersion() { return version; }
    public void setVersion(String version) { this.version = version; }
    
    public Server getServer() { return server; }
    public void setServer(Server server) { this.server = server; }
    
    public Security getSecurity() { return security; }
    public void setSecurity(Security security) { this.security = security; }
}

Using Configuration Properties

import io.micronaut.context.ApplicationContext;
import jakarta.inject.Singleton;
import jakarta.inject.Inject;

@Singleton
public class DatabaseService {
    private final DatabaseConfig config;
    
    @Inject
    public DatabaseService(DatabaseConfig config) {
        this.config = config;
    }
    
    public void connect() {
        System.out.println("Connecting to: " + config.getUrl());
        System.out.println("Username: " + config.getUsername());
        System.out.println("Max connections: " + config.getMaxConnections());
        System.out.println("SSL enabled: " + config.isSsl());
    }
}

public class ConfigurationExample {
    public static void main(String[] args) {
        try (ApplicationContext context = ApplicationContext.run()) {
            DatabaseService service = context.getBean(DatabaseService.class);
            service.connect();
        }
    }
}

Value Injection

@Value Annotation

import io.micronaut.context.annotation.Value;
import jakarta.inject.Singleton;

@Singleton
public class ServiceWithValues {
    
    @Value("${app.name:DefaultApp}")
    private String appName;
    
    @Value("${server.port:8080}")
    private int serverPort;
    
    @Value("${app.debug:false}")
    private boolean debugMode;
    
    @Value("${app.version}")
    private String version; // Required property - no default
    
    public void displayConfig() {
        System.out.println("App: " + appName);
        System.out.println("Port: " + serverPort);
        System.out.println("Debug: " + debugMode);
        System.out.println("Version: " + version);
    }
}

@Property Annotation

import io.micronaut.context.annotation.Property;
import jakarta.inject.Singleton;

@Singleton
public class PropertyInjectionExample {
    
    private final String databaseUrl;
    private final Integer connectionTimeout;
    
    public PropertyInjectionExample(
        @Property(name = "database.url") String databaseUrl,
        @Property(name = "database.timeout", defaultValue = "30") Integer connectionTimeout) {
        
        this.databaseUrl = databaseUrl;
        this.connectionTimeout = connectionTimeout;
    }
    
    public void printConfiguration() {
        System.out.println("Database URL: " + databaseUrl);
        System.out.println("Connection timeout: " + connectionTimeout + "s");
    }
}

Type Conversion

Built-in Type Conversion

import io.micronaut.context.ApplicationContext;
import io.micronaut.context.env.Environment;
import java.time.Duration;
import java.time.LocalDateTime;
import java.util.List;

public class TypeConversionExample {
    public static void main(String[] args) {
        try (ApplicationContext context = ApplicationContext.run()) {
            Environment env = context.getEnvironment();
            
            // Duration conversion (e.g., "30s", "5m", "1h")  
            Duration timeout = env.getProperty("app.timeout", Duration.class, Duration.ofSeconds(30));
            
            // List conversion (comma-separated values)
            List<String> tags = env.getProperty("app.tags", List.class);
            
            // LocalDateTime conversion
            LocalDateTime startTime = env.getProperty("app.start-time", LocalDateTime.class);
            
            System.out.println("Timeout: " + timeout);
            System.out.println("Tags: " + tags);
            System.out.println("Start time: " + startTime);
        }
    }
}

Implementation Classes

DefaultEnvironment

Default implementation of the Environment interface.

public class DefaultEnvironment implements Environment {
    public DefaultEnvironment(ApplicationContextConfiguration configuration);
    
    // Implements Environment interface methods
    public Collection<String> getActiveNames();
    public <T> Optional<T> getProperty(String name, Class<T> requiredType);
    public boolean containsProperty(String name);
    public Collection<PropertySource> getPropertySources();
}

Install with Tessl CLI

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

docs

annotations.md

application-context.md

environment-config.md