Micronaut Docs

Micronaut Test connects JUnit, Spock, Kotest, embedded servers, clients, dependency injection, transactions, and contexts so tests exercise real wiring while remaining isolated, repeatable, and CI-friendly across local and pipeline runs.

Micronaut Test Resources provisions external dependencies for tests and local development, starting containers or services and providing connection properties for databases, brokers, or cloud-like services so tests match production wiring.

Micronaut Control Panel provides a development UI for inspecting routes, beans, configuration, environment details, management information, and operational state without custom debug endpoints or log digging during feature work locally.

Micronaut AOT performs ahead-of-time optimizations that precompute metadata, reduce startup work, improve native-image behavior, and tune runtime artifacts for faster, smaller deployments while preserving framework features and configuration flexibility intact.

Micronaut Sourcegen provides APIs for generating source code from structured models, supporting Java, Kotlin, and tooling artifacts with shared abstractions for names and types, members, files, and generated code cleanly.

Micronaut OpenRewrite provides recipes for migrations, dependency updates, source transformations, and modernization tasks so teams apply consistent, reviewable changes across applications and libraries for current and future platform releases safely.

Micronaut ProjectGen provides an API for generating Gradle and Maven JVM projects with reusable project models, build configuration, and source layout conventions.

The Micronaut Platform BOM aligns dependency versions for each Micronaut Framework release.

Micronaut SQL provides JDBC infrastructure for datasource configuration, pools, transactions, schema tooling, and persistence support, giving applications a consistent base for relational access across environments while staying platform aligned cleanly.

Micronaut MongoDB configures clients, BSON codecs, health checks, optional transactions, and repository access so document database connectivity remains injectable, lifecycle-managed, and consistent across application environments without custom connection setup code.

Micronaut Redis integrates Redis clients for caching, pub/sub, health checks, connection settings, and data access so services use fast state and messaging through configured beans instead of custom setup code.

Micronaut Neo4j connects applications to graph databases with managed drivers, sessions, transactions, and health checks so graph access works with HTTP, repositories, validation, security, and configuration in one application model.

Micronaut Cassandra configures drivers, sessions, serialization, and health checks for Apache Cassandra clusters so services inject database resources and participate in the application lifecycle across local and deployed environments cleanly.

Micronaut Data precomputes repository queries ahead of time and executes them through a small runtime layer for SQL and NoSQL stores, pagination, transactions, projections, criteria APIs, and reflection-free repository access.

Micronaut R2DBC provides reactive relational connectivity with clients, connection configuration, transactions, health checks, and repositories so nonblocking services use SQL without JDBC or separate database setup code in tests too.

Micronaut Coherence integrates Oracle Coherence for distributed caches, sessions, repositories, configuration, health checks, and data-grid patterns through injected components instead of custom bootstrap or scattered cache access code in applications.

Micronaut EclipseStore integrates object persistence with storage configuration, health checks, injected storage components, and data access patterns so services persist graphs with familiar lifecycle, configuration, and testing workflows locally too.

Micronaut Kafka integrates producers, consumers, and event-driven workflows with serialization, batching, offsets, errors, health checks, and configuration so services exchange typed messages through injectable components with predictable lifecycle behavior reliably.

Micronaut RabbitMQ provides AMQP messaging with publishers, listeners, exchanges, queues, acknowledgements, serialization, retries, error handling, and configuration so message-driven components remain typed, injectable, and testable beside other application beans reliably.

Micronaut NATS integrates injectable publishers and subscribers with serialization, request-reply patterns, configuration binding, connection lifecycle, and event-driven components for typed service messaging without ad hoc glue code in applications reliably.

Micronaut JMS integrates producers, listeners, destinations, acknowledgements, transactions, serialization, and configuration so enterprise messaging uses typed handlers and injection with existing brokers and repeatable integration test suites in CI too.

Micronaut Pulsar integrates producers and consumers with subscriptions, schemas, serialization, error handling, configuration, and typed message handlers for lifecycle-managed event-driven services across development and production environments using dependency injection reliably.

Micronaut MQTT supports publish and subscribe workflows for MQTT brokers with topics, serialization, quality-of-service options, connection settings, and handler methods for IoT messaging through framework components and tests locally too.

Micronaut Elasticsearch configures clients, health checks, and cluster access for search-backed applications, supporting indexing and querying while keeping search infrastructure injectable, configurable, and testable across environments without custom setup code.

Micronaut Micrometer connects applications to metrics registries with binders, annotations, management endpoints, and configuration so HTTP, messaging, cache, database, and custom telemetry is published consistently without manual metrics plumbing code.

Micronaut JMX exposes application state through JVM management tooling with management beans, metrics views, operational data, and configuration beside HTTP management endpoints and monitoring systems without custom adapters or code.

Micronaut Tracing propagates trace context through HTTP, messaging, and service flows, instruments framework components, and connects applications to tracing backends for request visibility, latency analysis, and failure investigation across services.

Micronaut OpenSearch configures clients and health checks for OpenSearch clusters, supporting indexing, searching, and environment-specific settings without custom clients or scattered search configuration inside services and tests across deployments reliably.

Micronaut Spring supports selected Spring annotations, beans, events, transactions, and integration patterns so migrated code can run on the lightweight container while teams adopt compile-time injection gradually with less rewriting.

Micronaut GraphQL provides schema loading, data fetchers, instrumentation, execution configuration, and runtime wiring so GraphQL APIs share injection, validation, security, testing, and configuration with HTTP services inside production applications cleanly.

Micronaut gRPC adds server and client support for protobuf stubs, services, channels, interceptors, SSL, and health checks while keeping RPC components injectable, configurable, and lifecycle-managed beside HTTP endpoints and services.

Micronaut OpenAPI generates API descriptions, schemas, Swagger UI assets, and documentation from code, helping HTTP APIs publish accurate contracts without maintaining separate specifications manually during development and release workflows reliably.

Micronaut Jackson XML adds XML media support for HTTP clients, controllers, and codecs using Jackson, content negotiation, serialization configuration, and object mapping for integrations still depending on XML contracts today.

Micronaut JAX-RS supports selected Jakarta REST annotations and HTTP patterns so teams reuse JAX-RS-style controllers, parameters, and metadata on compile-time routing and injection during incremental migration from older stacks safely.

Micronaut Servlet runs applications on Jetty, Tomcat, Undertow, and other servlet containers while adapting controllers, filters, configuration, injection, and security to servlet deployments that require existing container infrastructure in production.

Micronaut Serialization generates reflection-free serializers and deserializers from compile-time metadata for JSON, JSON-B, Jackson annotations, BSON, custom serializers, and fast native-image payload handling without runtime introspection or reflection costs overhead.

Micronaut JSON Schema generates schemas from application and serialization models, including configuration and validation metadata, so teams publish machine-readable contracts without separate schema sources or duplicated model metadata in tooling.

Micronaut Guice lets applications reuse selected Guice modules and bindings inside framework applications, supporting interoperability while new components adopt the compile-time bean model during gradual migrations with less rewriting safely.

Micronaut Jakarta EL provides a Jakarta Expression Language implementation compiled at build time for efficient expression evaluation without a separate runtime engine.

Micronaut AWS integrates serverless functions, SDK clients, parameters, secrets, messaging, storage, tracing, and deployment support so services consume Amazon infrastructure through injection and configuration instead of custom bootstrap per module.

Micronaut GCP integrates functions, cloud clients, configuration, tracing, logging, and runtime behavior so applications target Google Cloud while keeping development and testing familiar through injected services and settings locally too.

Micronaut Kubernetes supports service discovery, configuration, health, leader election, service account access, and cluster metadata so applications adapt to Kubernetes without scattering infrastructure code through business components or profiles repeatedly.

Micronaut Azure connects applications to Azure services and hosting models with functions, cloud clients, configuration, identity, tracing, and deployment workflows through injection and settings from local development to production cloud.

Micronaut Discovery Client provides service registration and lookup with Consul, Eureka, health integration, metadata, and configuration-driven resolution so clients avoid hardcoded locations and duplicated discovery logic across modules in services.

Micronaut Oracle Cloud integrates OCI functions, SDK clients, configuration, authentication, object storage, and deployment workflows so services consume cloud resources through injected clients and environment-aware configuration in deployments and tests.

Micronaut Pulsar integrates producers and consumers with subscriptions, schemas, serialization, error handling, configuration, and typed message handlers for lifecycle-managed event-driven services across development and production environments using dependency injection reliably.

Micronaut Tracing propagates trace context through HTTP, messaging, and service flows, instruments framework components, and connects applications to tracing backends for request visibility, latency analysis, and failure investigation across services.

Micronaut Object Storage provides uniform APIs for reading, writing, deleting, and listing objects across cloud providers while configuration selects the concrete backend per environment, deployment, or repeatable test suite locally.

Micronaut Kotlin adds Kotlin-friendly extensions, annotation processing guidance, coroutine support, nullability-aware APIs, and testing conveniences so idiomatic Kotlin keeps compile-time injection, configuration binding, and native-image readiness across service modules cleanly.

Micronaut Groovy supports Groovy applications with compile-time processing, AST integration, testing conveniences, and language-specific behavior so Groovy code uses injection, configuration, AOP, and HTTP APIs efficiently with native-image readiness preserved.

Micronaut Graal Languages integrates GraalVM dynamic language runtimes and polyglot capabilities so language-specific components can participate in configuration and dependency injection beside JVM code where useful and practical for services.

Micronaut ACME automates certificate issuance and renewal with ACME challenge handling, configuration, and HTTPS integration points for services that need certificates without manual operational scripts during deployment and renewal workflows.

Micronaut Picocli combines command-line applications with dependency injection, configuration, testing utilities, native-image packaging, and distribution patterns so CLI tools share services without HTTP bootstrap or separate startup code at runtime.

Micronaut Cache adds annotation-driven caching with pluggable backends, key generation, invalidation, conditions, async behavior, and backend configuration while keeping cache decisions near services and portable across infrastructure choices in tests.

Micronaut Email abstracts message composition and sending with provider integrations, templates, attachments, configuration, transactional workflows, and test-friendly APIs for application mail delivery without binding business code to transports or providers.

Micronaut Chatbots helps build bot workflows with request handling, commands, responses, security, configuration, and deployment patterns so bot logic uses injected application services instead of platform-specific webhook code per target.

Micronaut Session adds HTTP session management with stores, cookies, filters, configuration, and security integration so server-side user state remains explicit, testable, and framework-managed across environments and deployment models cleanly too.

Micronaut CRaC integrates Coordinated Restore at Checkpoint support so applications can prepare resources before checkpointing and restore quickly with framework-aware lifecycle handling.

Micronaut RSS publishes standards-compatible feeds with feed models, entries, metadata, links, and response rendering so services expose updates or articles without assembling XML manually or duplicating response logic in endpoints.

Micronaut Views integrates server-side templates with HTTP applications, handling view resolution, model binding, static resources, rendering configuration, and HTML responses through normal controllers, validation, security, and injection like APIs too.

Micronaut Multitenancy provides tenant resolution and propagation with filters, resolvers, configuration, and helper APIs so routing, data access, and services react to tenant context without duplicating tenant plumbing everywhere repeatedly.