or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

index.md
tile.json

tessl/maven-io-micronaut--micronaut-core-bom

Micronaut Bill of Materials (BOM) for managing dependencies across the Micronaut Framework ecosystem

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/io.micronaut/micronaut-core-bom@4.9.x

To install, run

npx @tessl/cli install tessl/maven-io-micronaut--micronaut-core-bom@4.9.0

index.mddocs/

Micronaut Core BOM

Micronaut Core BOM (Bill of Materials) provides centralized dependency management for the entire Micronaut Framework ecosystem. It ensures version compatibility across all Micronaut Core modules and manages external dependency versions, eliminating version conflicts and simplifying dependency declarations in Micronaut applications.

Package Information

  • Package Name: micronaut-core-bom
  • Package Type: maven
  • Language: Java (Build Tool Configuration)
  • Installation: Import as BOM in Maven/Gradle
  • Group ID: io.micronaut
  • Artifact ID: micronaut-core-bom
  • Version: 4.9.4

Core Imports

Maven

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>io.micronaut</groupId>
            <artifactId>micronaut-core-bom</artifactId>
            <version>4.9.4</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

Gradle (Kotlin DSL)

dependencies {
    implementation platform("io.micronaut:micronaut-core-bom:4.9.4")
}

Gradle (Groovy DSL)

dependencies {
    implementation platform('io.micronaut:micronaut-core-bom:4.9.4')
}

Gradle with Version Catalogs

# gradle/libs.versions.toml
[versions]
micronaut = "4.9.4"

[libraries]
micronaut-bom = { module = "io.micronaut:micronaut-core-bom", version.ref = "micronaut" }

# build.gradle.kts
dependencies {
    implementation platform(libs.micronaut.bom)
}

Basic Usage

// build.gradle.kts
dependencies {
    // Import the BOM
    implementation platform("io.micronaut:micronaut-core-bom:4.9.4")
    
    // Now use Micronaut dependencies without version numbers
    implementation("io.micronaut:micronaut-context")
    implementation("io.micronaut:micronaut-http-server-netty")
    implementation("io.micronaut:micronaut-jackson-databind")
    
    // External dependencies are also managed
    implementation("com.fasterxml.jackson.core:jackson-core")
    implementation("io.netty:netty-handler")
    implementation("org.jetbrains.kotlin:kotlin-stdlib")
}

Capabilities

Dependency Management

The BOM manages versions for all dependencies in the Micronaut ecosystem, ensuring compatibility and eliminating version conflicts. Once imported, all managed dependencies can be declared without explicit version numbers.

<!-- Maven: Import BOM in dependencyManagement -->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>io.micronaut</groupId>
            <artifactId>micronaut-core-bom</artifactId>
            <version>4.9.4</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<!-- Then use managed dependencies without versions -->
<dependencies>
    <dependency>
        <groupId>io.micronaut</groupId>
        <artifactId>micronaut-context</artifactId>
    </dependency>
    <dependency>
        <groupId>io.micronaut</groupId>
        <artifactId>micronaut-http-server-netty</artifactId>
    </dependency>
</dependencies>
// Gradle Kotlin DSL: Import platform
dependencies {
    implementation(platform("io.micronaut:micronaut-core-bom:4.9.4"))
    
    // Use managed dependencies without versions
    implementation("io.micronaut:micronaut-context")
    implementation("io.micronaut:micronaut-http-server-netty")
}

Micronaut Core Modules

The BOM manages versions for all Micronaut Core framework modules:

Core Framework Dependencies

// Core components
implementation("io.micronaut:micronaut-core")           // Foundation classes and utilities
implementation("io.micronaut:micronaut-context")        // Dependency injection container
implementation("io.micronaut:micronaut-inject")         // DI framework
implementation("io.micronaut:micronaut-aop")            // Aspect-oriented programming
implementation("io.micronaut:micronaut-runtime")        // Runtime utilities
implementation("io.micronaut:micronaut-core-reactive")  // Reactive programming support

HTTP Components

// HTTP server and client
implementation("io.micronaut:micronaut-http")                    // HTTP abstractions
implementation("io.micronaut:micronaut-http-server")             // HTTP server
implementation("io.micronaut:micronaut-http-server-netty")       // Netty HTTP server
implementation("io.micronaut:micronaut-http-client")             // HTTP client
implementation("io.micronaut:micronaut-http-client-core")        // Core HTTP client
implementation("io.micronaut:micronaut-http-client-jdk")         // JDK HTTP client
implementation("io.micronaut:micronaut-http-validation")         // HTTP validation
implementation("io.micronaut:micronaut-websocket")               // WebSocket support

Language Support

// Java support
annotationProcessor("io.micronaut:micronaut-inject-java")        // Java annotation processor
testImplementation("io.micronaut:micronaut-inject-java-test")    // Java testing utilities

// Groovy support  
implementation("io.micronaut:micronaut-inject-groovy")           // Groovy DI support
testImplementation("io.micronaut:micronaut-inject-groovy-test")  // Groovy testing

// Kotlin support
implementation("io.micronaut:micronaut-inject-kotlin")           // Kotlin DI support
testImplementation("io.micronaut:micronaut-inject-kotlin-test")  // Kotlin testing

Additional Features

// JSON processing
implementation("io.micronaut:micronaut-jackson-core")            // Jackson integration
implementation("io.micronaut:micronaut-jackson-databind")        // Jackson databinding
implementation("io.micronaut:micronaut-json-core")               // JSON core

// Other features
implementation("io.micronaut:micronaut-messaging")               // Messaging abstractions
implementation("io.micronaut:micronaut-router")                  // Request routing
implementation("io.micronaut:micronaut-management")              // Management endpoints
implementation("io.micronaut:micronaut-retry")                   // Retry mechanisms
implementation("io.micronaut:micronaut-function")                // Function support
implementation("io.micronaut:micronaut-function-client")         // Function client
implementation("io.micronaut:micronaut-graal")                   // GraalVM support
implementation("io.micronaut:micronaut-discovery-core")          // Service discovery
implementation("io.micronaut:micronaut-context-propagation")     // Context propagation
implementation("io.micronaut:micronaut-buffer-netty")            // Netty buffer integration

External Dependencies

The BOM also manages versions for key external libraries used by Micronaut:

Jackson JSON Processing

// Jackson dependencies with managed versions
implementation("com.fasterxml.jackson.core:jackson-core")                    // 2.18.3
implementation("com.fasterxml.jackson.core:jackson-databind")                // 2.18.2
implementation("com.fasterxml.jackson.core:jackson-annotations")             // 2.18.3
implementation("com.fasterxml.jackson.datatype:jackson-datatype-jdk8")       // 2.18.3
implementation("com.fasterxml.jackson.datatype:jackson-datatype-jsr310")     // 2.18.3
implementation("com.fasterxml.jackson.dataformat:jackson-dataformat-yaml")   // 2.18.3
implementation("com.fasterxml.jackson.dataformat:jackson-dataformat-xml")    // 2.18.3
implementation("com.fasterxml.jackson.module:jackson-module-afterburner")    // 2.18.3
implementation("com.fasterxml.jackson.module:jackson-module-kotlin")         // 2.18.3
implementation("com.fasterxml.jackson.module:jackson-module-parameter-names") // 2.18.3

Netty Network Programming

// Netty dependencies with managed versions
implementation("io.netty:netty-buffer")                          // 4.2.2.Final
implementation("io.netty:netty-common")                          // 4.2.2.Final
implementation("io.netty:netty-codec-http")                      // 4.2.2.Final
implementation("io.netty:netty-codec-http2")                     // 4.2.2.Final
implementation("io.netty:netty-codec-http3")                     // 4.2.2.Final
implementation("io.netty:netty-handler")                         // 4.2.2.Final
implementation("io.netty:netty-handler-proxy")                   // 4.2.2.Final
implementation("io.netty:netty-transport-native-epoll")          // 4.2.2.Final
implementation("io.netty:netty-transport-native-kqueue")         // 4.2.2.Final
implementation("io.netty:netty-transport-native-io_uring")       // 4.2.2.Final
implementation("io.netty:netty-transport-native-unix-common")    // 4.2.2.Final
implementation("io.netty:netty-codec-classes-quic")             // 4.2.2.Final
implementation("io.netty:netty-codec-native-quic")              // 4.2.2.Final
implementation("io.netty:netty-tcnative-boringssl-static")       // 2.0.72.Final

Kotlin Support

// Kotlin dependencies with managed versions
implementation("org.jetbrains.kotlin:kotlin-stdlib")                         // 1.9.25
implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")                    // 1.9.25
implementation("org.jetbrains.kotlin:kotlin-reflect")                        // 1.9.25
implementation("org.jetbrains.kotlin:kotlin-test")                           // 1.9.25
implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core")              // 1.8.1
implementation("org.jetbrains.kotlinx:kotlinx-coroutines-jdk8")              // 1.8.1
implementation("org.jetbrains.kotlinx:kotlinx-coroutines-reactive")          // 1.8.1
implementation("org.jetbrains.kotlinx:kotlinx-coroutines-reactor")           // 1.8.1
implementation("org.jetbrains.kotlinx:kotlinx-coroutines-rx2")               // 1.8.1
implementation("org.jetbrains.kotlinx:kotlinx-coroutines-slf4j")             // 1.8.1

// Kotlin compiler dependencies (for tooling and annotation processing)
implementation("org.jetbrains.kotlin:kotlin-annotation-processing-embeddable") // 1.9.25
implementation("org.jetbrains.kotlin:kotlin-compiler-embeddable")              // 1.9.25

Groovy Support

// Groovy dependencies with managed versions
implementation("org.apache.groovy:groovy")                       // 4.0.27
implementation("org.apache.groovy:groovy-json")                  // 4.0.27
implementation("org.apache.groovy:groovy-sql")                   // 4.0.27
implementation("org.apache.groovy:groovy-templates")             // 4.0.27

Jakarta/Javax APIs

// Jakarta/Javax API dependencies with managed versions
implementation("jakarta.annotation:jakarta.annotation-api")      // 2.1.1

Reactive Programming

// Reactive dependencies with managed versions
implementation("org.reactivestreams:reactive-streams")           // 1.0.4
implementation("io.projectreactor:reactor-core")                 // 3.7.7
testImplementation("io.projectreactor:reactor-test")             // 3.7.7

Other Managed Dependencies

// Additional dependencies with managed versions
implementation("org.yaml:snakeyaml")                             // 2.4
implementation("io.methvin:directory-watcher")                   // 0.19.0
implementation("com.github.javaparser:javaparser-symbol-solver-core") // 3.26.4
implementation("com.google.devtools.ksp:symbol-processing-api")  // 1.9.25-1.0.20
implementation("com.google.devtools.ksp:symbol-processing")      // 1.9.25-1.0.20

Version Override

While the BOM manages versions, you can override them when needed:

dependencies {
    implementation(platform("io.micronaut:micronaut-core-bom:4.9.4"))
    
    // Use BOM-managed version
    implementation("com.fasterxml.jackson.core:jackson-core")
    
    // Override with specific version
    implementation("org.yaml:snakeyaml:2.3") {
        version {
            strictly("2.3")  // Force specific version
        }
    }
}
<!-- Maven: Override BOM version -->
<dependencies>
    <dependency>
        <groupId>org.yaml</groupId>
        <artifactId>snakeyaml</artifactId>
        <version>2.3</version> <!-- Overrides BOM version -->
    </dependency>
</dependencies>

Types

Maven Dependency Management Types

<!-- BOM import configuration -->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>io.micronaut</groupId>
            <artifactId>micronaut-core-bom</artifactId>
            <version>4.9.4</version>
            <type>pom</type>        <!-- Always 'pom' for BOM imports -->
            <scope>import</scope>   <!-- Always 'import' for BOM imports -->
        </dependency>
    </dependencies>
</dependencyManagement>

Gradle Platform Types

// Gradle platform configuration types
dependencies {
    // Platform import - manages versions of dependencies
    implementation(platform("io.micronaut:micronaut-core-bom:4.9.4"))
    
    // Enforced platform - forces versions even when conflicts exist
    implementation(enforcedPlatform("io.micronaut:micronaut-core-bom:4.9.4"))
}

// Configuration for test dependencies
testImplementation(platform("io.micronaut:micronaut-core-bom:4.9.4"))

Gradle Version Catalog Types

# gradle/libs.versions.toml structure for BOM
[versions]
micronaut = "4.9.4"

[libraries]
# BOM library definition
micronaut-bom = { module = "io.micronaut:micronaut-core-bom", version.ref = "micronaut" }

# Managed dependencies (versions omitted - managed by BOM)
micronaut-context = { module = "io.micronaut:micronaut-context" }
micronaut-http-server = { module = "io.micronaut:micronaut-http-server-netty" }
jackson-core = { module = "com.fasterxml.jackson.core:jackson-core" }

Usage Examples

Complete Micronaut Application Setup

// build.gradle.kts
plugins {
    application
    kotlin("jvm")
    kotlin("plugin.allopen")
}

dependencies {
    // Import Micronaut BOM
    implementation(platform("io.micronaut:micronaut-core-bom:4.9.4"))
    
    // Core Micronaut dependencies
    implementation("io.micronaut:micronaut-context")
    implementation("io.micronaut:micronaut-runtime")
    implementation("io.micronaut:micronaut-http-server-netty")
    implementation("io.micronaut:micronaut-jackson-databind")
    
    // Annotation processors
    annotationProcessor("io.micronaut:micronaut-inject-java")
    
    // All versions are managed by the BOM
}

Maven Project Setup

<project>
    <dependencyManagement>
        <dependencies>
            <!-- Import Micronaut BOM -->
            <dependency>
                <groupId>io.micronaut</groupId>
                <artifactId>micronaut-core-bom</artifactId>
                <version>4.9.4</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    
    <dependencies>
        <!-- Micronaut dependencies without versions -->
        <dependency>
            <groupId>io.micronaut</groupId>
            <artifactId>micronaut-context</artifactId>
        </dependency>
        <dependency>
            <groupId>io.micronaut</groupId>
            <artifactId>micronaut-http-server-netty</artifactId>
        </dependency>
        <dependency>
            <groupId>io.micronaut</groupId>
            <artifactId>micronaut-jackson-databind</artifactId>
        </dependency>
        
        <!-- External dependencies are also managed -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
        </dependency>
    </dependencies>
</project>

Multi-Module Project

// Parent build.gradle.kts
subprojects {
    dependencies {
        // Apply BOM to all subprojects
        implementation(platform("io.micronaut:micronaut-core-bom:4.9.4"))
    }
}

// Module-specific build.gradle.kts
dependencies {
    // Versions managed by parent BOM
    implementation("io.micronaut:micronaut-context")
    implementation("io.micronaut:micronaut-http-client")
    testImplementation("io.micronaut:micronaut-test-junit5")
}

## Common Issues and Error Handling

### Version Conflicts

When using the BOM, version conflicts may still occur if dependencies are overridden or forced:

```kotlin
dependencies {
    implementation(platform("io.micronaut:micronaut-core-bom:4.9.4"))
    
    // This may cause conflicts with BOM-managed versions
    implementation("com.fasterxml.jackson.core:jackson-core:2.15.0") {
        version {
            strictly("2.15.0")
        }
    }
}

Solution: Remove version overrides or use BOM-managed versions when possible.

Missing Platform Declaration

// ❌ Wrong - no platform declaration
dependencies {
    implementation("io.micronaut:micronaut-context")  // Version not managed
}

// ✅ Correct - with platform
dependencies {
    implementation(platform("io.micronaut:micronaut-core-bom:4.9.4"))
    implementation("io.micronaut:micronaut-context")  // Version managed by BOM
}

Maven Import Scope Issues

<!-- ❌ Wrong scope -->
<dependency>
    <groupId>io.micronaut</groupId>
    <artifactId>micronaut-core-bom</artifactId>
    <version>4.9.4</version>
    <type>pom</type>
    <scope>compile</scope>  <!-- Wrong scope -->
</dependency>

<!-- ✅ Correct - import scope in dependencyManagement -->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>io.micronaut</groupId>
            <artifactId>micronaut-core-bom</artifactId>
            <version>4.9.4</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>