Skip to content
CAI
Software that uses CAICheck a score

AxonIQ/AxonFramework

64.6

Adequate · 9 November 2026

177.8k

lines of production code

Java

primary language

9

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Java and Kotlin event models for the simple workflow example

The workflow-simple example now includes event definitions for both Java and Kotlin, providing concrete models for user registration and email confirmation flows. Java users can reference the new \EmailConfirmedEvent\ and \RegistrationReceivedEvent\ records in the \org.axonframework.examples.workflow.simple.user\ package, while Kotlin users have equivalent \EmailConfirmedEvent\ and \RegistrationReceivedEvent\ data classes in the \org.axonframework.examples.workflow.simple.kotlin.user\ package, enabling developers to see how these events are structured in both languages.

workflow-simple · high confidence

Add tracing support for entity lifecycle and event handler tags

This change introduces tracing instrumentation for the Axon Framework event sourcing module. It adds a \TracingEntityLifecycleHandler\ that wraps entity lifecycle operations, opening an internal span around the \source\ method to capture entity ID and type attributes, while leaving initialization and subscription paths uninstrumented to avoid trace noise. Additionally, it provides a \TracingEventTagsHandlerEnhancerDefinition\ that automatically enriches active spans with event tags when \@EventHandler\ methods are invoked, resolving tags via the configured \TagResolver\ and \EventConverter\ to complement the publish-side tracing.

eventsourcing/src/main/java/org/axonframework/eventsourcing/handler/tracing · high confidence

Add tracing support for event sourcing storage and publishing

New tracing decorators have been introduced for the Axon Framework event sourcing layer. The \TracingEventStorageEngine\ now wraps the event storage engine to trace the complete logical append transaction (from invocation through commit, rollback, or failure), ensuring spans are properly closed even if a \ProcessingContext\ is abandoned. The \TracingEventStore\ decorator ensures that event publishing is traced via \TracingEventSink\, while other \EventStore\ operations are passed through. Additionally, an \EventTagsSpanAttributesProvider\ is available to automatically attach event tags as span attributes, with configurable prefixes and allowlists.

eventsourcing/src/main/java/org/axonframework/eventsourcing/eventstore/tracing · high confidence

Added Jackson deserializer for Spring Data Page objects

A new Jackson deserializer (JacksonPageDeserializer) has been added to the Spring Data extension, enabling the conversion of JSON representations of paginated data into Spring Data PageImpl instances. This allows users to seamlessly deserialize paginated responses from JSON sources into standard Spring Data Page objects, with sensible defaults applied for missing fields like page number, size, and total elements.

extensions/spring/spring/src/main/java/org/axonframework/extension/spring/data · high confidence

Added core API definitions for bike rental and payment workflows

This change introduces the foundational domain models and messaging contracts for the bike rental example. It adds JPA entity classes for tracking payment status (Pending, Approved, Rejected) and bike availability (Available, Requested, Rented), along with corresponding command, event, and query definitions. These files establish the core API surface for handling bike registration, rental requests, returns, and payment processing within the Axon Framework workflow example.

workflow-bike-rental · high confidence

Annotation-based event-sourced entity support

The \eventsourcing\ module now supports defining entities via the \@EventSourcedEntity\ annotation, enabling automatic loading, instantiation, and command handling without manual repository configuration. Users can customize event loading via \@EventCriteriaBuilder\ methods or the \tagKey\ attribute, define entity creation using \@EntityCreator\, and enable declarative snapshotting with \@Snapshotting\. This change introduces the \AnnotationBasedEventCriteriaResolver\, \AnnotationBasedEventSourcedEntityFactory\, and related definition interfaces to manage these behaviors.

eventsourcing/src/main/java/org/axonframework/eventsourcing/annotation · high confidence

Automated migration recipes for Axon Framework 4 to 5 upgrades

The migration module now includes a suite of OpenRewrite recipes to automatically refactor Axon Framework 4 code for Axon Framework 5. These recipes handle replacing aggregate \@DeadlineHandler\ methods with \@CommandHandler\ methods, explicitly passing aggregate scope to \DeadlineManager\ calls, migrating legacy deadline manager builders (replacing \serializer\ with \converter\ and adding \unitOfWorkFactory\), updating \EventGateway.publish\ calls to include \ProcessingContext\, converting \SnapshotTriggerDefinition\ beans to \@Snapshotting\ annotations, and moving Saga fields into handler parameters.

axon-migration · high confidence

Automated migration recipes for Axon Framework 4.x to Axoniq Framework 5.x

The migration module now provides a comprehensive suite of OpenRewrite recipes to mechanically transform Axon Framework 4.x codebases to Axoniq Framework 5.x. These recipes automate build file updates (BOM swaps, Java version bumps), package and class renames (e.g., \EventBus\ to \EventSink\), and annotation rewrites (e.g., \@Aggregate\ to \@EventSourced\, \@CreationPolicy\ removal with \@EntityCreator\ addition). The migration also handles command and event payload annotation (\@Command\, \@Event\), migrates legacy saga and deadline patterns to the new injection-based models, updates test fixtures (\AggregateTestFixture\ to \AxonTestFixture\), and migrates Spring Boot snapshotting configuration. For changes that cannot be safely automated, the recipes insert \TODO(axon4to5)\ markers to guide manual completion.

migration · high confidence

Automatic tracing integration for Axon Event Sourcing components

Axon Framework now automatically wires distributed tracing into the event-sourcing module when a tracing backend is present on the classpath. Configuration enhancers registered via ServiceLoader decorate the EventStorageEngine, SnapshotStore, and EventStore with tracing wrappers, while a new EventSourcingTracingSettings record allows users to toggle tracing for each component (event store, snapshot store) and control whether event tags are recorded as span attributes. This enables out-of-the-box observability for event sourcing operations without manual wiring.

eventsourcing/src/main/java/org/axonframework/eventsourcing/tracing · high confidence

Axon Framework 5.0 introduces the Update Checker for library upgrades and vulnerability detection

Axon Framework 5.0 adds a new Update Checker module that periodically sends anonymous usage data to Axoniq to detect available library upgrades and security vulnerabilities. The system automatically starts during the external connections phase, sending details about the JVM, operating system, and installed Axon libraries to a telemetry endpoint. Users receive formatted log reports highlighting any detected vulnerabilities (with severity and fix versions) or available upgrades. The feature respects user privacy by allowing opt-out via the \AXONIQ\_UPDATE\_CHECKER\_DISABLED\ environment variable, the \-Daxoniq.update-checker.disabled=true\ JVM property, or a local configuration file, and it automatically disables itself when a test environment is detected.

update · high confidence

Declarative multi-tenancy demo with Axon Server toggle

A new declarative multi-tenancy demo has been added to the examples, allowing users to run the university scenario using the declarative Configuration API instead of Spring Boot. The demo supports two modes: an in-memory default mode using a bundled tenant provider, and an Axon Server mode enabled via the \demo.axon-server.enabled\ property, which sources tenants from Axon Server contexts. When using Axon Server, the demo also supports persistent streams for the course-statistics projection via the \demo.axon-server.persistent-streams.enabled\ toggle. The configuration wires per-tenant component providers for statistics and audit logs, and includes a local query handler switch to ensure direct queries are routed through the per-tenant connector.

examples/university-multi-tenancy-examples/university-multi-tenancy-declarative/src/main · high confidence

Demo configuration toggles for Axon Server and persistent streams

The multi-tenancy declarative demo now includes a configuration record that allows users to toggle between an in-memory tenant provider and Axon Server contexts, as well as enable persistent streams for the course-statistics projection. These runtime settings are loaded from the classpath's application.properties file, giving users control over the demo's execution mode without code changes.

university-multi-tenancy-declarative · high confidence

Introduce Kotlin extension for Axon Framework

This change adds a new Kotlin extension module to Axon Framework, providing idiomatic support for Kotlin developers. It includes a Kotlin-specific property access strategy that leverages reflection to handle Kotlin value classes without requiring additional Java interop configuration. The extension also offers convenience functions for the test fixture API, such as \whenever\ to bypass Kotlin's reserved \when\ keyword, and accepts Kotlin \KClass\ types for exception assertions. Additionally, it provides inline extension functions for \EventSourcedEntityModule\ configuration to allow type inference, and includes a university demo example demonstrating event tagging and polymorphic event sourcing in Kotlin.

axon-kotlin, extensions/kotlin/kotlin-test, university-demo-kotlin · high confidence

Introduce new core messaging abstractions and command handling components

This change introduces foundational messaging infrastructure for Axon 5, including the \MessageStream\ abstraction with \AbstractMessageStream\ for non-blocking, pull-based consumption, and a new \Context\ interface for immutable resource management. It also adds the \GenericCommandMessage\ implementation, the \SimpleCommandHandlingComponent\ for registering and dispatching command handlers, and the \AnnotationRoutingStrategy\ to route commands based on annotated identifiers. Additionally, core types like \MessageType\ (combining \QualifiedName\ and version) and \ClassBasedMessageTypeResolver\ are added to standardize message typing.

axon-messaging · high confidence

Introduce university-demo example with event-sourced faculty module

Adds a new university-demo application that demonstrates an event-sourced faculty module, including write-side commands (enrolling students, creating and renaming courses, changing capacity), read-side projections for course statistics, and automations such as notifying when all courses are fully booked or when a student subscribes to a course.

examples/university-demo/src/main/java · high confidence

JUnit 5 integration for the Axon Test Fixture

The test module now includes a JUnit 5 extension (AxonFrameworkExtension) and supporting annotations (@ProvidedAxonTestFixture) that automatically manage the lifecycle of the AxonTestFixture. This allows test classes to inject the fixture directly as a method parameter, with the extension handling setup and teardown, while also introducing dedicated exception types (AxonAssertionError, FixtureExecutionException) to provide clearer error reporting during test execution.

test · high confidence

New Avro conversion support in the conversion module

The AvroConverter and its supporting classes have been introduced in the conversion module to handle serialization and deserialization of Avro messages using single-object encoding. This includes configuration via AvroConverterConfiguration, strategy-based conversion for SpecificRecordBase types, and utilities for schema compatibility checking and fingerprinting, enabling users to convert between Avro binary formats and Java objects within the Axon Framework.

conversion/src/main/java/org/axonframework/conversion/avro · high confidence

New Axon Framework 4 and Spring Boot 4 example application

Added a standalone example module demonstrating Axon Framework 4.12.x with Spring Boot 4 and Java 21. The example includes a Spring Boot application that connects to Axon Server, configures Jackson serialization, and uses an in-memory event store and projection to handle course creation commands and queries. It also provides an IntelliJ run configuration and documentation for running the example independently.

examples/framework4-springboot4 · high confidence

New Axon Framework 4 and Spring Boot 4 example with in-memory projection

Added a new example application in the \axon-example-af4-sb4\ location demonstrating Axon Framework 4 with Spring Boot 4. This example includes a \Course\ aggregate, command (\CreateCourse\), event (\CourseCreated\), and an in-memory projection (\CourseProjection\) that handles queries (\FindAllCourses\, \FindCourseById\) to return course summaries.

axon-example-af4-sb4 · high confidence

New Dropwizard metrics monitors for Axon components

The Dropwizard metrics extension now provides a set of new monitor implementations that expose detailed operational metrics for Axon components. The MetricsConfigurationEnhancer automatically decorates CommandBuses, EventSinks, EventProcessors, and QueryBuses with these monitors, registering them into a MetricRegistry. New monitors include CapacityMonitor (calculating processing capacity based on average message duration and volume), EventProcessorLatencyMonitor (tracking the lag between event publication and processing), MessageCountingMonitor (counting ingested, successful, failed, and ignored messages), MessageTimerMonitor (recording processing durations via Timers), and PayloadTypeMessageMonitorWrapper (creating per-payload-type monitors). Users gain visibility into component throughput, latency, and capacity directly through Dropwizard metrics.

axon-metrics-dropwizard · high confidence

New Java example module for Axon Framework university domain

A new 'university-java' example module has been added to demonstrate Axon Framework capabilities. It includes a complete domain model with commands (CreateCourse, EnrollStudentInFaculty, SubscribeStudentToCourse), events (CourseCreated, StudentSubscribedToCourse), and an automation component that uses event-sourced entities to track course capacity and send notifications when courses are fully booked. The example also features a read-model projection for course statistics and utilizes JSpecify nullability annotations.

university-java · high confidence

New Java university example demonstrating event-driven faculty management

Added a new Java-based example application that models a university faculty domain using event sourcing and CQRS. The example includes a main application entry point, configuration for Axon Server integration, and a faculty initializer that seeds data. It demonstrates key patterns such as command handling for course creation and capacity changes, event sourcing for tracking course state, and a read-side projection that maintains course statistics in an in-memory repository. The example also features an automation component that sends notifications when a course becomes fully booked, showcasing event-driven business logic.

examples/university-java/src/main · high confidence

New Kotlin extension functions and idiomatic test helpers

The Kotlin extension now provides idiomatic APIs for Axon users, including reified gateway methods (sendWithResult, sendAndWait, query, queryMany, subscriptionQuery, streamingQuery) that eliminate the need for explicit Java class arguments, and convenience aliases like whenever() to bypass Kotlin's reserved when keyword in test fixtures. It also introduces a Kotlin-reflect-based NullabilityResolver that correctly honors Kotlin's T? nullability declarations at runtime, a Kotlin-reflect PropertyAccessStrategy that supports value classes, and helper utilities such as evolveIf() for event sourcing and metadata accessors.

extensions/kotlin/kotlin · high confidence

New Kotlin university demo example with event-sourced faculty domain

A new Kotlin-based university demo has been added to the examples directory, demonstrating event sourcing with the Axon Framework. The example models a faculty domain where students can be enrolled and subscribed to courses, using Kotlin-specific features like value classes for IDs and nullable types for create-or-update command handling. It includes both a standard state-machine implementation and a polymorphic state implementation for course subscriptions, along with a docker-compose file for running the Axon Server infrastructure.

examples/university-demo-kotlin · high confidence

New Micrometer-based message monitoring capabilities

The Micrometer metrics extension now includes four new monitor implementations: CapacityMonitor, which tracks processing capacity by measuring average message duration against throughput; EventProcessorLatencyMonitor, which measures the delay between event publication and processing; MessageCountingMonitor, which tracks ingested, successful, failed, processed, and ignored message counts; and MessageTimerMonitor, which records detailed timing distributions for message processing. These components allow users to expose granular operational metrics to Micrometer-compatible registries.

axon-metrics-micrometer · high confidence

New Spring Boot 3 and 4 example applications for the University domain

Added dedicated example implementations for the University domain model in both Spring Boot 3 and Spring Boot 4 directories. These examples demonstrate event-driven architecture patterns using Axon Framework, including command handling for course and student management, event sourcing for tracking course capacity and subscriptions, and automation logic that sends notifications when courses become fully booked. The changes introduce new Java source files defining commands, events, projections, and shared types specific to these framework versions.

university-java-springboot-3, university-java-springboot-4 · high confidence

New Spring Boot 3 university example with event sourcing and real-time updates

The university-java-springboot-3 example now demonstrates a complete event-sourced domain with Spring Boot 3, featuring REST controllers for creating courses, changing capacity, and enrolling students. It includes a course statistics read model that projects events into an in-memory repository and exposes real-time updates via Server-Sent Events (SSE) using Axon's subscription queries. The example also configures dedicated event processors for course stats and notifications, and initializes sample data on startup.

examples/university-java-springboot-3 · high confidence

New Spring Boot 4 university example with event-sourced commands and SSE query streams

The Spring Boot 4 university example now includes a complete set of new components: an application entry point, a faculty initializer that seeds data, and REST controllers for creating courses, changing capacity, and enrolling students. These write-side operations use Axon's new entity-based event sourcing (EventSourced, EventAppender) instead of traditional aggregate roots. The read side features a course statistics projection with an in-memory repository, query handlers, and a REST controller that exposes both standard JSON and Server-Sent Events (SSE) streams for real-time course stats updates. Additionally, a notification automation configuration defines a pooled streaming processor for handling notification events.

examples/university-java-springboot-4 · high confidence

New Spring Boot configuration properties and auto-configuration for converters, event processors, timeouts, and tracing

This change introduces a comprehensive set of Spring Boot configuration properties and corresponding auto-configuration classes to manage Axon Framework settings via standard application properties. Users can now configure message and event converters (including Avro support) through \axon.converter.\\, define event processor settings (mode, segments, token store) via \axon.eventhandling.\\, and adjust timeout behaviors for unit of work and message handlers using \axon.timeout.\\. Additionally, distributed tracing is now configurable through \axon.tracing.\\ with granular control over components like the CommandBus and EventSink, while update checks can be disabled or customized via \axon.update-check.\*\. The auto-configuration classes ensure these settings are applied correctly, such as wiring Avro converters only when Avro is on the classpath and handling dependencies between converter types.

extensions/spring/spring-boot-autoconfigure · high confidence

New Spring TransactionManager for Unit of Work

A new SpringTransactionManager implementation has been added to the Spring extension's unit of work package. This component integrates Spring's PlatformTransactionManager with Axon's processing lifecycle, allowing transactions to be started, committed, or rolled back in sync with message processing. It also provides JPA EntityManagerExecutor and JDBC ConnectionExecutor resources when the respective providers are available, ensuring database operations participate in the same transactional context as the messaging unit of work.

extensions/spring/spring/src/main/java/org/axonframework/extension/spring/messaging/unitofwork · high confidence

New Spring authorization interceptors for message metadata and access control

The Spring extension now includes a new authorization package containing two interceptors and a dedicated exception. MessageAuthorizationDispatchInterceptor automatically injects the current Spring Security username and authorities into message metadata when messages are dispatched, while MessageAuthorizationHandlerInterceptor enforces access control by checking the @Secured annotation on message payloads against the injected authorities, throwing UnauthorizedMessageException if access is denied.

extensions/spring/spring/src/main/java/org/axonframework/extension/spring/authorization · high confidence

New Spring extension components for Avro schema loading and Spring Security authorization

The Axon Spring extension now includes support for loading Avro schemas from classes extending SpecificRecordBase and enforcing authorization via the Spring Security @Secured annotation. Users can now scan specific packages for Avro schemas using the new AvroSchemaPackages bean and Registrar, and message handlers can be protected by the SecuredMessageHandlerDefinition which checks for required roles in message metadata.

axon-spring · high confidence

New Spring stereotype annotations for event-sourced entities

The Spring extension now provides dedicated stereotype annotations (such as @EventSourced) that allow developers to mark Spring components as event-sourced entities directly. These annotations act as meta-annotations for Axon's core @EventSourcedEntity, enabling Spring's auto-configuration to automatically detect and manage entity instances with configurable properties for ID resolution, event criteria, and entity factories. The package is also marked with JSpecify nullability annotations to improve static analysis support.

extensions/spring/spring/src/main/java/org/axonframework/extension/spring/stereotype · high confidence

New Spring utility classes and nullability annotations

The Spring extension now includes new utility classes, BeanDefinitionUtils and SpringUtils, to assist with Spring bean definition resolution and qualifier matching, alongside the introduction of AxonStartedEvent to signal when Axon is fully initialized. Additionally, the package-level nullability annotations have been adopted using JSpecify's @NullMarked.

extensions/spring/spring/src/main/java/org/axonframework/extension/spring · high confidence

New annotation-based entity creation model with @EntityCreator and @InjectEntityId

The eventsourcing module introduces a new reflection-based mechanism for defining how event-sourced entities are instantiated. Users can now use the @EntityCreator annotation on constructors or static factory methods to explicitly mark entity creation points, supporting both event-driven initialization (for existing entities) and identifier-only initialization (for new entities). To resolve ambiguity when both the entity identifier and the first event payload are of the same type (e.g., String), the new @InjectEntityId annotation allows explicit injection of the entity identifier. Additionally, a @ForcedEntityCreator annotation is provided to ensure entity creation even in 'create-if-missing' scenarios, avoiding the need for static command handlers or ManagedEntity injections. This new model is wired through the new AnnotationBasedEventSourcedEntityFactoryDefinition, which constructs the factory using standard Axon components like ParameterResolverFactory and EventConverter.

eventsourcing/src/main/java/org/axonframework/eventsourcing/annotation/reflection · high confidence

New caching utilities for conversion and Avro schema checks

The axon-conversion module now includes a new CachingSupplier utility that provides thread-safe, lazy initialization with serialization support for expensive supplier operations. Additionally, the Avro schema compatibility checking has been enhanced with a new DefaultSchemaIncompatibilityChecker that caches incompatibility results by schema fingerprints, improving performance for repeated schema compatibility checks.

axon-conversion · high confidence

New common infrastructure components for caching, JDBC/JPA execution, and lifecycle management

The axon-common module introduces several new foundational classes to support framework internals. It adds a caching abstraction layer with an abstract base adapter and concrete implementations for EhCache, JCache, and WeakReference-based caching, enabling flexible cache integration. It also provides TransactionalExecutor implementations for ambient JDBC Connections and JPA EntityManagers, which defer and cache resource acquisition to ensure safe reuse within externally managed transactions. Additionally, a ShutdownLatch utility is added to coordinate graceful application shutdown by tracking and waiting for registered activities.

axon-common · high confidence

New common utility classes and exception hierarchy

The common module now includes a new Assert utility class for parameter and state validation, a dedicated exception hierarchy (AxonException, AxonConfigurationException, etc.), and various utility classes for builders, collections, dates, identifiers, executors, and futures. These additions provide a self-contained set of infrastructure tools without requiring external dependencies like Spring for basic assertion logic.

common/src/main · high confidence

New configuration properties for JPA Event Storage Engine

Users can now configure the Aggregate-based JPA Event Storage engine via Spring Boot properties under the prefix 'axon.eventstorage.jpa'. This new configuration class exposes settings for batch size, gap cleaning threshold, gap timeout, lowest global sequence, maximum gap offset, and polling interval, allowing fine-tuned control over event retrieval and gap management behavior.

axon-spring-boot-autoconfigure · high confidence

New content-type converters and JSpecify nullability adoption

The conversion module now includes five new {@code ContentTypeConverter} implementations: {@code BlobToInputStreamConverter}, {@code ByteArrayToInputStreamConverter}, {@code ByteArrayToStringConverter}, {@code InputStreamToByteArrayConverter}, and {@code StringToByteArrayConverter}, enabling direct conversion between SQL Blobs, byte arrays, strings, and input streams. Additionally, the {@code converter} package has been annotated with JSpecify nullability markers (e.g., {@code @NullMarked}, {@code @Nullable}) to improve static analysis and null-safety guarantees.

conversion/src/main/java/org/axonframework/conversion/converter · high confidence

New conversion module with GeneralConverter and chaining support

A new \org.axonframework.conversion\ package has been introduced to centralize object conversion logic. This includes a new \GeneralConverter\ interface for unrestricted type conversion, a \ChainingContentTypeConverter\ that automatically discovers and chains \ContentTypeConverter\ implementations via Java ServiceLoader, and utility classes like \CachingSupplier\ and \PassThroughConverter\. This modularizes conversion capabilities previously scattered in messaging components, providing a dedicated contract for general-purpose conversion tasks.

conversion/src/main/java/org/axonframework/conversion · high confidence

New course-catalog demo with event transformation and interactive shell

The university-message-transformation example now includes a complete course-catalog demo application that demonstrates event transformation capabilities. The demo features an interactive REPL shell (accessible via --keep-alive) for running sample commands like publishing courses, updating capacity, and enrolling students. It includes a transformation chain that lifts legacy events (CourseOffered, CourseListedWithSeats, StudentRegistered) to their current shapes (CoursePublished v3, CourseCapacityChanged, StudentEnrolledInCourse with region backfilling). The application supports AxonIQ Platform integration through configuration properties loaded from application.properties, .env files, and environment variables, with Axon Server connection toggled via axon.server.enabled. An overbooking notifier automation alerts when course capacity ranges exceed 20 seats, and the demo seeds historic events idempotently to demonstrate the transformation chain in action.

examples/university-message-transformation/src/main · high confidence

New declarative and annotation-based configuration for event-sourced entities

The eventsourcing module now provides a new configuration API centered on the \EventSourcingConfigurer\ and \EventSourcedEntityModule\. Users can register event-sourced entities using a fluent, declarative builder or automatically via the \@EventSourcedEntity\ annotation, which simplifies setup by handling metamodels, factories, and criteria resolvers. The \EventSourcingConfigurationDefaults\ enhancer automatically registers default components like \TagResolver\, \EventStorageEngine\, and \EventStore\, while disabling the standard \EventBus\ defaults to prevent conflicts. Additionally, snapshot sourcing is now handled via a dedicated \SnapshotSourcingConfigurationEnhancer\ that decorates the storage engine, and entity ID resolution includes automatic payload conversion to support polymorphic types.

eventsourcing/src/main/java/org/axonframework/eventsourcing/configuration · high confidence

New entity modelling components and repository implementation

The axon-modelling package introduces a new entity modelling architecture, including the SimpleRepository for loading and persisting entities with automatic state change tracking, and the SimpleEntityEvolvingComponent for evolving entities based on event types. Entity identification is now handled by new resolvers like AnnotationBasedEntityIdResolver and PropertyBasedEntityIdResolver, while the InjectEntityParameterResolverFactory now supports injecting entities as ManagedEntity or Optional types. Child entity management is supported via new field definitions (GetterEvolverChildEntityFieldDefinition, GetterSetterChildEntityFieldDefinition) and routing key matching (AnnotatedEntityModelRoutingKeyMatcher, RoutingKeyEventTargetMatcher).

axon-modelling · high confidence

New entity modelling core interfaces and implementations

The modelling module introduces the foundational interfaces and components for the new entity modelling system in version 5.0.0. This includes the \StateManager\ interface and its \SimpleStateManager\ and \HierarchicalStateManager\ implementations, which handle entity loading and persistence via registered \Repository\ instances. The \EntityEvolver\ and \EntityEvolvingComponent\ interfaces (with \SimpleEntityEvolvingComponent\ and \AnnotationBasedEntityEvolvingComponent\ implementations) define how entities evolve their state based on incoming events. Additionally, \EntityIdResolver\ and \PropertyBasedEntityIdResolver\ provide mechanisms for resolving entity identifiers from message payloads, supported by a set of new exceptions such as \EntityIdResolutionException\, \MissingRepositoryException\, and \ConcurrencyException\ to handle specific error scenarios.

modelling · high confidence

New event-sourcing handler API for entity lifecycle management

The eventsourcing module introduces a new handler API in the \org.axonframework.eventsourcing.handler\ package to manage the lifecycle of event-sourced entities. This includes the \EntityLifecycleHandler\ interface and its implementations (\SimpleEntityLifecycleHandler\ and \SnapshottingEntityLifecycleHandler\), which handle entity initialization, sourcing from the event store (with optional snapshot support), and live event subscription. The \InitializingEntityEvolver\ class coordinates entity creation and state evolution, while \SourcingHandler\ defines the contract for reconstructing entities from historical events. This refactoring decouples the sourcing and lifecycle logic, allowing for more flexible entity management strategies.

eventsourcing/src/main/java/org/axonframework/eventsourcing/handler · high confidence

New fluent API for defining and assigning event processors in Spring

The Spring extension now provides a new fluent configuration API (EventProcessorDefinition) for explicitly defining event processors and assigning event handlers to them. Users can create pooled streaming or subscribing processors, specify handler selection criteria using the new EventHandlerSelector (which supports matching by @Namespace annotation), and apply custom configuration. The underlying DefaultProcessorModuleFactory uses these definitions to group handlers and build the corresponding EventProcessorModules, replacing the previous implicit assignment logic.

extensions/spring/spring/src/main/java/org/axonframework/extension/spring/config · high confidence

New in-memory snapshot store with payload isolation

Axon Framework introduces an in-memory implementation of the SnapshotStore interface, designed for testing, prototyping, and single-node scenarios. The store supports two modes: a default constructor that retains snapshot payloads by reference, and a constructor accepting a Converter that serializes and deserializes payloads on both store and load operations. This conversion-based copying ensures that later mutations to mutable entity instances do not alter previously stored snapshots, providing isolation behavior that mirrors production-grade durable stores. The implementation is thread-safe, uses ConcurrentHashMap for storage, and returns immediate CompletableFutures to align with the asynchronous API.

eventsourcing/src/main/java/org/axonframework/eventsourcing/snapshot/inmemory · high confidence

New multi-tenancy demo core components and outcome models

The university multi-tenancy demo now includes a comprehensive set of core classes to demonstrate tenant isolation. This adds tenant-aware event processing and subscription queries, with outcomes for event storage, snapshotting, and streaming captured in new record types (EventStorageOutcome, SnapshottingOutcome, StreamingOutcome, SubscriptionQueryOutcome). A new DemoTenantProvider simulates Axon Server's tenant lifecycle in-memory, while domain models (CourseOpened, StudentEnrolledInCourse, TenantStatistics) and the EnrollStudentCommandHandler enforce tenant-scoped event sourcing and read-model updates. Query-side guardrails are demonstrated via QueryRejectionOutcome, ensuring queries for unknown, missing, or removed tenants are rejected.

university-multi-tenancy-core · high confidence

New multi-tenancy demo lifecycle and outcome reporting

The multi-tenancy demo now includes a structured lifecycle runner and outcome reporting system. The new \DemoApplication\ record and \DemoLifecycle\ class orchestrate the end-to-end demo scenario, handling tenant provisioning, enrollment, and statistics tracking. The \DemoOutcome\ record and its sub-records (\EventStorageOutcome\, \SnapshottingOutcome\, \StreamingOutcome\, \SubscriptionQueryOutcome\, \QueryRejectionOutcome\) capture and report the results of the demo run, including tenant isolation, snapshotting, event processing, and subscription query behavior. A \ProviderAmbiguityGuardrail\ class demonstrates framework guardrails against ambiguous tenant component providers. This change provides a more structured and observable way to run and verify the multi-tenancy demo.

examples/university-multi-tenancy-examples/university-multi-tenancy-core/src/main/java/org/axonframework/examples/demo/multitenancy/shared/run · high confidence

New public API for event-sourced entity snapshotting

Axon Framework 5.1.0 introduces a new public API in the \org.axonframework.eventsourcing.snapshot.api\ package to define the contract for snapshot management. This includes the \Snapshot\ record to represent an entity's state at a specific event stream position, the \EvolutionResult\ record to expose sourcing metrics (such as events applied and sourcing time) for decision-making, and the \SnapshotPolicy\ interface which allows users to configure when snapshots are created based on event counts, sourcing duration, or specific event predicates. These components provide the foundational types for the snapshotting framework, enabling custom implementations or usage of default storage strategies.

eventsourcing/src/main/java/org/axonframework/eventsourcing/snapshot/api · high confidence

New shared demo harness for multi-tenancy examples

The multi-tenancy demo now uses a shared core module to support multiple demonstration styles (declarative and Spring Boot) with consistent behavior. This location introduces configuration enums to select the infrastructure backing (in-memory vs. Axon Server) and the event processing style (pooled streaming vs. persistent streams), alongside a new tenant-scoped audit log component that records entries per tenant. These shared components allow the demo to toggle between different multi-tenancy architectures and observe how tenant isolation and event processing behave in each setup.

examples/university-multi-tenancy-examples/university-multi-tenancy-core/src/main/java/org/axonframework/examples/demo/multitenancy/shared · high confidence

New shared tenant infrastructure for the multi-tenancy demo

The multi-tenancy demo now includes a shared tenant package that standardizes how tenants are provisioned and managed across both in-memory and Axon Server backends. This adds an in-memory tenant provider for local runs, an Axon Server context manager to provision and delete server contexts at runtime, and a tenant provisioning abstraction that handles the lifecycle of adding and removing tenants. It also introduces per-tenant component providers for course statistics and audit logs, a utility for building multi-tenant persistent stream event sources, and a snapshot lookup helper to inspect per-tenant snapshot stores.

examples/university-multi-tenancy-examples/university-multi-tenancy-core/src/main/java/org/axonframework/examples/demo/multitenancy/shared/tenant · high confidence

New workflow examples for Axon Framework 5.4.0

Added two new example applications, \workflow-bike-rental\ and \workflow-simple\, to demonstrate workflow capabilities. The bike rental example implements a payment workflow that coordinates bike rentals and payments using event sourcing, command/query handling, and Spring Boot, while the simple example provides a basic workflow pattern with notification and utility services.

examples/workflow-bike-rental, examples/workflow-simple · high confidence

Reactor gateways now support dispatch interceptors with access to Reactor context

The Reactor extension now provides Reactor-specific command, event, and query gateways that run dispatch interceptors inside the Reactor subscription. This allows interceptors to access Reactor context (such as ReactiveSecurityContextHolder) during message dispatch, which was previously unavailable. The extension introduces ReactorMessageDispatchInterceptor and ReactorDispatchInterceptorRegistry components, along with configuration defaults that wire these interceptors into the new gateway implementations.

extensions/reactor/axon-reactor · high confidence

Registered default content-type converters in Axon Framework

A new META-INF/services file has been added to register the default content-type converters for the Axon Framework conversion module. This enables automatic discovery and usage of converters for common data types, including conversions between byte arrays and input streams, as well as byte arrays and strings.

conversion/src/main/resources · high confidence

Repository initialization with project configuration and documentation

The repository has been initialized with the Axon Framework codebase, including the Apache 2.0 license, a comprehensive README with project overview and migration notes, and contribution guidelines. The project is configured for Java 21 and uses the Maven Wrapper (version 3.3.4) for builds. Standard development tooling is established via .editorconfig, .gitattributes, and .gitignore files, alongside IDE-specific style definitions (axon\_code\_style.xml) and copyright templates to ensure consistent code formatting and legal compliance across the project.

(repo-wide) · high confidence

Saga recipes example introduces a generic payment context with idempotent preparation

The saga-recipes example now includes a generic payment context that models payments using two distinct identifiers: a system-generated PaymentId and a caller-supplied PaymentReference. This design makes the PreparePayment command idempotent by construction, as the decision model is keyed by the reference rather than the identifier. The context supports preparing, confirming, rejecting, and cancelling payments, with cancellation serving as a deadline replacement for Axon Framework 5's missing DeadlineManager via a scheduled sweep.

examples/saga-recipes/src/main · high confidence

Spring Boot auto-configuration for Micrometer metrics

The Micrometer metrics extension now includes Spring Boot auto-configuration, allowing metrics to be automatically set up when the required classes are present. Users can enable or disable metrics globally via the \axon.metrics.enabled\ property (enabled by default) and configure Micrometer-specific options, such as enabling dimensional tags, via \axon.metrics.micrometer.dimensional\. If a \MeterRegistry\ bean is not already defined, the auto-configuration provides a default \SimpleMeterRegistry\. When metrics are disabled, the configuration enhancers are explicitly disabled to prevent unnecessary overhead.

extensions/metrics/metrics-micrometer/src/main/java/org/axonframework/extension/metrics/micrometer/springboot · high confidence

Spring Boot multi-tenancy demo with configurable projection streaming

The university multi-tenancy example now includes a Spring Boot implementation that demonstrates tenant-aware event processing and query handling via autoconfiguration. The demo features a configurable projection processor that can run as either a pooled streaming processor (default) or a subscribing processor fed by persistent streams, selectable via the \axon.axonserver.auto-persistent-streams-enabled\ property. It also configures the distributed query bus to route direct queries through the per-tenant connector rather than preferring local handlers, ensuring the multi-tenant routing behavior is visible during the demo run.

examples/university-multi-tenancy-examples/university-multi-tenancy-springboot/src/main · high confidence

Spring integration now resolves handler parameters from the application context

The Spring extension now automatically resolves method and constructor parameters in Axon handlers as Spring beans. By marking a parameter with Spring's @Autowired or @Qualifier, the framework will inject the corresponding bean from the ApplicationContext, supporting both single-bean resolution and explicit qualification. This capability is provided by new configuration classes in the Spring extension that wire Spring's dependency injection into Axon's parameter resolution pipeline.

extensions/spring/spring/src/main/java/org/axonframework/extension/spring/config/annotation · high confidence

Tenant-aware messaging helpers for the multi-tenancy demo

The multi-tenancy demo now includes a shared messaging package that provides tenant-aware command and query helpers. Enrollments and StatisticsQueries drive the command and query gateways by attaching tenant metadata, ensuring messages are routed to the correct tenant's isolated components. TenantMetadataFactory builds this metadata, while RemoteExceptions and TenantRejections handle exception matching and tenant resolution failures, including transient states. StatisticsSubscription manages live statistics subscriptions, completing when a tenant's courses are full.

examples/university-multi-tenancy-examples/university-multi-tenancy-core/src/main/java/org/axonframework/examples/demo/multitenancy/shared/messaging · high confidence

Tenant-aware statistics read model and query handling

The university multi-tenancy demo now includes a dedicated statistics read slice that tracks course enrollment counts and audit log sizes per tenant. This change introduces a \CourseStatisticsProjection\ that updates a tenant-scoped \CourseStatisticsStore\ via a single pooled streaming event processor (or persistent streams), ensuring that statistics are isolated to each tenant's context. A new \TenantStatisticsQueryHandler\ allows tenants to query their own enrollment statistics using \@TenantScoped\ injection, demonstrating that tenant-aware component resolution works for both command and query handlers. The implementation includes in-memory backing for the demo, configuration for the event processor, and logic to emit query updates and complete subscriptions when a tenant's courses are full.

examples/university-multi-tenancy-examples/university-multi-tenancy-core/src/main/java/org/axonframework/examples/demo/multitenancy/university/read · high confidence

University course catalog demo with legacy event transformation chain

The university-message-transformation example now includes a complete course catalog domain model and a transformation chain that lifts historic event shapes to their current versions on read. The demo seeds legacy events (such as unversioned announcements, beta-versioned welcome messages, and bundled course listings) and applies transformations to split bundled events, rename legacy event types, and lift versioned payloads (e.g., CoursePublished v1→v2→v3, StudentRegistered v1→v3) while dropping operational noise like SystemHeartbeat pings. Read models (CatalogView, Enrolment, WelcomeMessage) reflect the transformed, current shapes, enabling users to see how event evolution is handled transparently during projection.

university-message-transformation · high confidence

University demo: new faculty domain model and automation logic

The university-demo example now includes a complete faculty domain model with commands for creating, renaming, and changing course capacity, as well as enrolling and unsubscribing students. It introduces event-sourced entities to track course state and a new automation feature that monitors course bookings and sends a notification when all courses in a faculty are fully booked. Additionally, a read model is provided to retrieve course statistics, and shared ID types (CourseId, FacultyId, StudentId) are defined with type-prefixed formatting.

university-demo · high confidence

Behavioural changes

1 commit (0 fixes) modifying examples/spring-cloud/domain, university-springcloud-domain

A change to existing behaviour in examples/spring-cloud/domain, university-springcloud-domain — 1 commit, 12 files: “Move Spring Boot agnostic code to domain module”.

examples/spring-cloud/domain, university-springcloud-domain · medium confidence · unverified

2 commits (0 fixes) modifying examples/spring-cloud/springboot4

A change to existing behaviour in examples/spring-cloud/springboot4 — 2 commits, 8 files: “Include Spring Boot 4 based Connector sample”; “Ensure reading can time out, making it so the test cannot block”.

examples/spring-cloud/springboot4 · medium confidence · unverified

5 commits (0 fixes) modifying examples/spring-cloud/springboot3

A change to existing behaviour in examples/spring-cloud/springboot3 — 5 commits, 8 files: “feat(spring-cloud): example for spring boot 3 - command & query”; “Move Spring Boot agnostic code to domain module”; “example(spring-cloud): runs a docker-compose setup to verify distribution via cloud”; and 2 more.

examples/spring-cloud/springboot3 · medium confidence · unverified

6 commits (0 fixes) modifying examples/spring-cloud

A change to existing behaviour in examples/spring-cloud — 6 commits, 11 files: “feat(spring-cloud): example for spring boot 3 - command & query”; “Include Spring Boot 4 based Connector sample”; “Update the Spring Cloud Connector readme accordingly”; and 3 more.

examples/spring-cloud · medium confidence · unverified

Added MariaDB duplicate key error codes to JPA event store

The JPA event store now recognizes MariaDB-specific duplicate key errors (codes 1022, 1061, and 1062) via the new SQLErrorCode.properties file. This ensures that constraint violations during event persistence are correctly identified and handled as duplicate key exceptions rather than generic database errors.

eventsourcing/src/main/resources/org · high confidence

Command handling interfaces and types restructured

The command handling API in the messaging module has been restructured to align with the new core messaging abstractions. The CommandBus now dispatches commands using a ProcessingContext and returns a CompletableFuture\<CommandResultMessage\>. Command handlers are defined via the CommandHandler functional interface, which returns a MessageStream.Single\<CommandResultMessage\>. New interfaces and classes include CommandHandlerRegistry for subscribing handlers by QualifiedName, CommandHandlingComponent to group handlers, and CommandHandlingExceptionHandler for custom error handling. CommandMessage now supports routingKey and priority, and GenericCommandMessage implements these with metadata and conversion support. Exceptions like CommandExecutionException and CommandDispatchException are updated to fit the new HandlerExecutionException hierarchy and detail conversion model.

messaging · high confidence

Conditional registration of Event Sourcing tracing configuration enhancers

The Event Sourcing module now registers its tracing-related configuration enhancers via Java SPI service files, allowing them to be loaded conditionally. Specifically, the new \META-INF/services/org.axonframework.common.configuration.ConfigurationEnhancer\ file declares \EventSourcingConfigurationDefaults\, \EventSourcingSpanAttributesProviderConfigurationEnhancer\, and \EventSourcingTracingConfigurationEnhancer\, while \META-INF/services/org.axonframework.messaging.core.annotation.HandlerEnhancerDefinition\ registers \TracingEventTagsHandlerEnhancerDefinition\. This enables the framework to apply tracing enhancements to event handlers and configuration only when tracing is explicitly enabled or configured, rather than unconditionally.

eventsourcing/src/main/resources/META-INF · high confidence

Dropwizard metrics auto-configuration now triggers by default

The Dropwizard metrics auto-configuration in the Spring Boot extension now activates automatically when the required classes are present, removing the previous requirement to explicitly set the 'axon.metrics.enabled' property to true. Users no longer need to configure this property to enable infrastructure metrics, as the auto-configuration will trigger by default in the absence of the property.

extensions/metrics/metrics-dropwizard/src/main/java · high confidence

Enable Axon Server connectivity in the University Demo

The University Demo application now includes an application.properties file that explicitly enables Axon Server connectivity by setting axon.server.enabled to true, allowing the demo to interact with an Axon Server instance.

examples/university-demo/src/main/resources · high confidence

Event sourcing repository and entity lifecycle management restructured

The EventSourcingRepository now delegates entity loading, initialization, and live updates to a dedicated EntityLifecycleHandler, simplifying repository configuration and allowing custom lifecycle handling. Entity creation is managed by AnnotationBasedEventSourcedEntityFactory, which scans for @EntityCreator-annotated constructors and static methods to instantiate entities, supporting polymorphic types and forced creation. Consistency tracking is enhanced with AggregateBasedConsistencyMarker for per-aggregate position tracking and GlobalIndexConsistencyMarker for global stream positions, both implementing the new Position interface. Tag resolution is expanded with PayloadBasedTagResolver, MetadataBasedTagResolver, and MultiTagResolver for flexible event tagging. The InMemoryEventStorageEngine now supports streaming from an empty store and uses atomic batch visibility for appended events.

axon-eventsourcing · high confidence

JPA event storage engine gains configurable polling coordinator and explicit termination

The JPA-based event storage engine now supports a pluggable EventCoordinator, with a new JpaPollingEventCoordinator that detects appended events by periodically counting rows in the AggregateEventEntry table. This coordinator runs a daemon polling thread that can be interrupted immediately when events are appended, and its termination is now explicitly bound with a 30-second timeout to prevent indefinite blocking. Configuration of this behavior is centralized in the new AggregateBasedJpaEventStorageEngineConfiguration record, which exposes settings for batch size, gap cleaning thresholds, gap timeouts, and the event type resolver, allowing users to tune how events are sourced and how gaps in tracking tokens are managed.

eventsourcing/src/main/java/org/axonframework/eventsourcing/eventstore/jpa · high confidence

Jackson 3 conversion support with Jackson 2 compatibility

The Jackson message conversion classes in the \org.axonframework.conversion.jackson\ package have been updated to use Jackson 3 (package \tools.jackson\), introducing a new \JacksonConverter\ that detects and rejects incompatible Jackson 2 tree nodes to prevent silent data corruption. A parallel set of converters in the \org.axonframework.conversion.jackson2\ package (using \com.fasterxml.jackson\) provides the existing \Jackson2Converter\ for users who need to maintain Jackson 2 compatibility.

conversion/src/main/java/org/axonframework/conversion/jackson · high confidence

Micrometer metrics extension refactored to use ConfigurationEnhancer and JSpecify nullability

The Micrometer metrics extension has been restructured to adopt a new configuration model and stricter null-safety. The previous direct constructor-based configuration is deprecated in favor of a \ConfigurationEnhancer\ approach: \MicrometerMetricsConfigurationEnhancer\ now registers a default \MicrometerMetricsConfiguration\ (containing the \MeterRegistry\ and dimension toggle) into the component registry, while \MetricsConfigurationEnhancer\ decorates the \MessageMonitorRegistry\ to attach monitors to \CommandBus\, \EventSink\, \EventProcessor\, and \QueryBus\ components. This change ensures a single, consistent configuration instance is built. Additionally, the codebase has been migrated to JSpecify annotations (\@NullMarked\), replacing legacy Jakarta annotations, and utility classes like \TagsUtil\ and \SlidingTimeWindowReservoir\ have been updated to support this new architecture.

extensions/metrics/metrics-micrometer/src/main/java/org/axonframework/extension/metrics/micrometer · high confidence

Micrometer metrics extension registers service and Spring Boot auto-configuration

The Micrometer metrics extension now explicitly registers its configuration enhancers (MetricsConfigurationEnhancer and MicrometerMetricsConfigurationEnhancer) via the Java ServiceLoader mechanism and defines its Spring Boot auto-configuration class (MicrometerMetricsAutoConfiguration) in the standard Spring Boot imports file. This ensures that the framework correctly discovers and applies these components during initialization without requiring manual wiring.

extensions/metrics/metrics-dropwizard/src/main/resources, extensions/metrics/metrics-micrometer/src/main/resources · high confidence

Multi-tenancy demo restructured into vertical write slices

The university multi-tenancy demo has been reorganized into distinct use-case vertical slices, introducing dedicated packages for the 'open-course' and 'enroll-student' workflows. This change adds specific command handlers, event-sourced state classes, and configuration modules for each slice, along with tenant-aware exceptions (such as CourseFullException and CourseNotOpenException) to enforce business rules within each tenant's isolated event store.

examples/university-multi-tenancy-examples/university-multi-tenancy-core/src/main/java/org/axonframework/examples/demo/multitenancy/university/write · high confidence

New SnapshotStore API with tracing support

The snapshotting subsystem introduces a new \SnapshotStore\ interface in the \org.axonframework.eventsourcing.snapshot.store\ package, replacing previous mechanisms with an asynchronous API that accepts a \ProcessingContext\ for correlation. This change enables automatic tracing of snapshot operations via the new \TracingSnapshotStore\ decorator, which wraps store and load calls with spans labeled by the snapshot's qualified name and entity identifier, improving observability for event-sourced entities.

eventsourcing/src/main/java/org/axonframework/eventsourcing/snapshot/store · high confidence

New consistency marker and append condition model for event sourcing

The event sourcing event store now uses a new \ConsistencyMarker\ interface and \AppendCondition\ sealed interface to manage concurrency and conflict detection. \ConsistencyMarker\ defines boundaries (ORIGIN, INFINITY, lower/upper bounds) to track event stream positions, with specific implementations like \AggregateBasedConsistencyMarker\ for per-aggregate tracking. \AppendCondition\ specifies the criteria and marker against which new events are validated during append operations, replacing previous mechanisms. This change introduces \AppendEventsTransactionRejectedException\ to report conflicts with details on tags and conflicting events, and \ConflictDiagnosingEventStorageEngine\ to help identify the specific event causing a rejection. Additionally, \AnnotationBasedTagResolver\ allows tagging events via \@EventTag\ annotations on payload fields/methods.

eventsourcing/src/main/java/org/axonframework/eventsourcing/eventstore · high confidence

Reactor extension adopts DispatchInterceptorFactory pattern

The Axon Reactor messaging extension now uses a factory-based approach for registering message dispatch interceptors. This change introduces the \DefaultReactorDispatchInterceptorRegistry\, which manages separate lists of interceptor factories for command, event, and query messages. This allows interceptors to be resolved lazily and ensures that interceptor builder methods are invoked only once, while factory methods can be invoked multiple times, providing more flexible and efficient interceptor lifecycle management for users.

axon-reactor · high confidence

Refactored event sourcing entity creation and criteria resolution

The event sourcing module introduces a new CriteriaResolver interface to resolve EventCriteria from identifiers, replacing the previous IndexResolver mechanism. The EventSourcedEntityFactory interface has been refined to explicitly define how entities are constructed based on their mutability and constructor signatures, supporting no-argument, identifier-based, and event-message-based creation strategies. Additionally, specific exceptions like EntityMissingAfterFirstEventException have been added to enforce factory contracts, while the deprecated EntityMissingAfterLoadOrCreateException is retained for backward compatibility but marked for removal.

eventsourcing/src/main/java/org/axonframework/eventsourcing · high confidence

Saga recipes example adds rental and payment domain models with idempotent request handling

The saga-recipes example now includes the core domain models for a bike rental scenario, introducing value objects like Amount, PaymentId, and RentalId, along with commands (RequestBike, PreparePayment) and events (BikeRequested, PaymentPrepared). The RequestBike command is designed to be idempotent by accepting a caller-supplied RentalId, and the payment context uses a PaymentReference as an idempotency key to prevent duplicate payment preparations. Additionally, the example implements a projection-based sweep for pending payments to replace the deprecated Axon Framework 4 deadline manager, ensuring overdue payments are cancelled without relying on framework-level deadline scheduling.

saga-recipes · high confidence

Test coverage

Added ArchUnit test configuration for tracing snapshot store; Added ArchUnit tests to enforce nullability conventions; Added JUnit 5 tests for JPA event store configuration and SQL error resolution; Added architecture tests for the snapshot package; Added compatibility tests for Spring Boot 3 and 4; Added comprehensive test coverage for the course catalog message transformation chain; Added contract tests for saga recipe implementations; Added integration tests for handler timeouts and immutable entity modeling; Added integration tests for the multi-tenancy Spring Boot demo; Added shared test infrastructure for Spring Boot compatibility matrix; Added smoke tests for the multi-tenancy demo; Added test coverage for Axon Framework Event Sourcing components; Added test fixtures for Spring annotation configuration; Added test for course creation in the university example; Added test resources for event sourcing benchmarks; Added test service provider files for ConfigurationEnhancer and NullabilityResolver; Added test suite for ComponentDescriptor implementations; Added test suite for the new extensible configuration system; Added test utilities for MySQL integration and domain events; Added test utilities for event handling scheduling; Added tests for Avro schema loading from SpecificRecordBase classes; Added tests for Axon Spring Boot test starter infrastructure; Added tests for Dropwizard metrics auto-configuration behavior; Added tests for InMemoryEventStorageEngine and StorageEngineBackedEventStore; Added tests for JPA token store row locking behavior; Added tests for MaterializingResource caching and concurrency behavior; Added tests for Micrometer metrics auto-configuration; Added tests for Spring Data Page Jackson deserialization; Added tests for Spring configuration and component registry behavior; Added tests for TracingSnapshotStore span creation and context threading; Added tests for annotation-based entity creation and forced entity creators; Added tests for annotation-based event criteria resolution; Added tests for course enrollment composition and remote exception handling; Added tests for course snapshot serialization in the multi-tenancy demo; Added tests for event sourcing tracing configuration and handler behavior; Added tests for event store consistency markers, tagging, and transactional behavior; Added tests for event-sourced saga recipe variants; Added tests for nullability resolution chain and entry points; Added tests for payment context isolation and command handlers; Added tests for tenant course statistics projection and store; Added tests for the conversion module; Added tests for the deadline replacement and vertical slices saga recipes; Added tests for the legacy Axon Framework 4 PaymentSaga port; Added tests for the new event sourcing configuration modules and defaults; Added tests for the rental payment sequencing policy; Added tests for the repository-based saga recipe; Added tests for tracing event storage engine and span attributes; Added unit and integration tests for the University Demo faculty module; Added unit tests for AnnotationUtils and PriorityAnnotationComparator; Added unit tests for Avro conversion components; Added unit tests for Dropwizard metrics monitors; Added unit tests for JDBC connection wrapping and locking mechanisms; Added unit tests for Jackson 3 JSON conversion components; Added unit tests for Micrometer metrics monitors and configuration enhancer; Added unit tests for Spring messaging integration components; Added unit tests for SpringTransactionManager; Added unit tests for common utility classes and architecture conventions; Added unit tests for conversion converters; Added unit tests for event filtering and snapshotting in entity lifecycle handlers; Added unit tests for event sourcing tracing components; Added unit tests for property access strategies; Added unit tests for rental command handlers; Frozen ArchUnit violation store for common module; New integration test suites for query handling and entity administration; Standardized test logging configuration across Axon Framework modules; Test infrastructure setup for saga recipes example.

Dependencies

Routine dependency and build plugin updates

This release updates various build plugins and library dependencies across the project, including bumps to Spring Boot, Spring Framework, Hibernate, Project Reactor, and the PostgreSQL JDBC driver. These changes ensure compatibility with newer Java versions and incorporate upstream fixes and improvements from the underlying libraries.

(dependencies) · high confidence

Updated Maven Wrapper to version 3.3.4

The Maven Wrapper configuration has been updated to use version 3.3.4, which downloads and uses Apache Maven 3.9.16. This ensures consistent build behavior across environments by pinning the specific Maven distribution version.

.mvn · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

This is the PUBLIC form of this artifact. Findings are listed in full, but the details of SECURITY findings — which rule fired, in which file, on which line, and how to fix it — are deliberately withheld, and any secret-scanner results are excluded entirely. Where detail is absent here it was REMOVED FOR PUBLICATION; it is not missing from the analysis. The complete artifact is available from the repository owner.

Score

  • CAI 60 → 65 (+4.9)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 84 → 84 (+0.0)
  • Architecture 78 → 78 (+0.2)
  • Maturity 54 → 81 (+27.2)
  • Readiness 53 → 52 (-0.2)
  • Security 72 → 66 (-5.6)
  • Event Sourcing 100 → 100 (+0.0)
  • Performance 77 → 100 (+22.9)

Resolved (126)

  • ADR not followed: 1. JacksonConverter rejects Jackson 2 tree nodes (fail loud) (specs/137-message-transformation/0001-jackson-converter-jackson2-handling.md)
  • Change coupling: ConcatenatingMessageStream.java ↔ DelayedMessageStream.java (messaging/src/main/java/org/axonframework/messaging/core/ConcatenatingMessageStream.java)
  • Change coupling: DelayedMessageStream.java ↔ OnErrorContinueMessageStream.java (messaging/src/main/java/org/axonframework/messaging/core/DelayedMessageStream.java)
  • Change coupling: InterceptingCommandBus.java ↔ TracingCommandBus.java (messaging/src/main/java/org/axonframework/messaging/commandhandling/interception/InterceptingCommandBus.java)
  • Change coupling: RetryingCommandBus.java ↔ TracingCommandBus.java (messaging/src/main/java/org/axonframework/messaging/commandhandling/retry/RetryingCommandBus.java)
  • Change coupling: SimpleContext.java ↔ SimpleEntry.java (messaging/src/main/java/org/axonframework/messaging/core/SimpleContext.java)
  • Change-coupling hub: MappedMessageStream.java → ConcatenatingMessageStream.java, EmptyMessageStream.java, FailedMessageStream.java, FluxMessageStream.java, OnErrorContinueMessageStream.java (messaging/src/main/java/org/axonframework/messaging/core/MappedMessageStream.java)
  • Change-coupling hub: OnNextMessageStream.java → ConcatenatingMessageStream.java, EmptyMessageStream.java, FailedMessageStream.java, FluxMessageStream.java, OnErrorContinueMessageStream.java (messaging/src/main/java/org/axonframework/messaging/core/OnNextMessageStream.java)
  • Documentation: no project overview (docs/CLAUDE.md)
  • High: security finding (details withheld)
  • High: security finding (details withheld)
  • Hotspot: messaging/src/main/java/org/axonframework/messaging/eventhandling/processing/streaming/pooled/Coordinator.java (messaging/src/main/java/org/axonframework/messaging/eventhandling/processing/streaming/pooled/Coordinator.java)
  • Hotspot: messaging/src/main/java/org/axonframework/messaging/tracing/configuration/MessagingTracingConfigurationEnhancer.java (messaging/src/main/java/org/axonframework/messaging/tracing/configuration/MessagingTracingConfigurationEnhancer.java)
  • Low cohesion: Builder (LCOM4 19) (messaging/src/main/java/org/axonframework/messaging/eventhandling/processing/streaming/pooled/Coordinator.java)
  • No assertions: nestedOrCriteriaSurvivesTheRoundTrip (messaging/src/test/java/org/axonframework/messaging/eventstreaming/EventCriteriaFlattenRoundTripTest.java)
  • No assertions: orCombinedCriteriaSurvivesTheRoundTrip (messaging/src/test/java/org/axonframework/messaging/eventstreaming/EventCriteriaFlattenRoundTripTest.java)
  • No assertions: sequenceNumberParameterResolverHandlesPrimitive (messaging/src/test/java/org/axonframework/messaging/eventhandling/annotation/AnnotatedParameterResolverFactoryTest.java)
  • No assertions: sequenceNumberParameterResolverIsReturnedOnlyWhenAppropriate (messaging/src/test/java/org/axonframework/messaging/eventhandling/annotation/AnnotatedParameterResolverFactoryTest.java)
  • No assertions: tagAndTypeCriteriaSurvivesTheRoundTrip (messaging/src/test/java/org/axonframework/messaging/eventstreaming/EventCriteriaFlattenRoundTripTest.java)
  • No assertions: tagOnlyCriteriaSurvivesTheRoundTrip (messaging/src/test/java/org/axonframework/messaging/eventstreaming/EventCriteriaFlattenRoundTripTest.java)
  • …and 106 more

New (73)

  • Change-coupling hub: MappedMessageStream.java → EmptyMessageStream.java, FailedMessageStream.java, FluxMessageStream.java, OnErrorContinueMessageStream.java (messaging/src/main/java/org/axonframework/messaging/core/MappedMessageStream.java)
  • Change-coupling hub: OnNextMessageStream.java → ConcatenatingMessageStream.java, FailedMessageStream.java, FluxMessageStream.java, OnErrorContinueMessageStream.java (messaging/src/main/java/org/axonframework/messaging/core/OnNextMessageStream.java)
  • ClassTooLong: WorkPackage (messaging/src/main/java/org/axonframework/messaging/eventhandling/processing/streaming/pooled/WorkPackage.java)
  • Duplicated block (19 lines × 2) (examples/spring-cloud/springboot3/src/main/java/org/axonframework/examples/springcloud/UniversityApplication.java)
  • High interface indirection
  • High: security finding (details withheld)
  • High: security finding (details withheld)
  • Low cohesion: Builder (LCOM4 20) (messaging/src/main/java/org/axonframework/messaging/eventhandling/processing/streaming/pooled/Coordinator.java)
  • No assertions: aForeignEventWithAMatchingVersionIsExcludedByThePredicatesNameGuard (examples/university-message-transformation/src/test/java/org/axonframework/examples/demo/coursecatalog/catalog/transformations/WelcomeMessageBetaCleanupWithoutPreFilterTest.java)
  • No assertions: aForeignEventWithAMatchingVersionPassesThroughUntouched (examples/university-message-transformation/src/test/java/org/axonframework/examples/demo/coursecatalog/catalog/transformations/WelcomeMessageBetaCleanupTest.java)
  • No assertions: aHandledEventStillTransformsThroughAChainThatRegistersADrop (examples/university-message-transformation/src/test/java/org/axonframework/examples/demo/coursecatalog/catalog/chain/DropTest.java)
  • No assertions: bumpingTheVersionViaPredicateIsAllowed (examples/university-message-transformation/src/test/java/org/axonframework/examples/demo/coursecatalog/catalog/chain/RenameViaTransformRejectedTest.java)
  • No assertions: bumpingTheVersionWhileKeepingTheNameIsAllowed (examples/university-message-transformation/src/test/java/org/axonframework/examples/demo/coursecatalog/catalog/chain/RenameViaTransformRejectedTest.java)
  • No assertions: combinesFirstAndLastNameIntoFullName (examples/university-message-transformation/src/test/java/org/axonframework/examples/demo/coursecatalog/catalog/transformations/StudentRegisteredV1ToV2Test.java)
  • No assertions: commandWithoutARegionFallsBackToTheUnknownRegion (examples/university-message-transformation/src/test/java/org/axonframework/examples/demo/coursecatalog/catalog/seed/RequestRegionBackfillIntegrationTest.java)
  • No assertions: dropsSystemHeartbeatSoNoEventIsProduced (examples/university-message-transformation/src/test/java/org/axonframework/examples/demo/coursecatalog/catalog/transformations/SystemHeartbeatDropTest.java)
  • No assertions: enrollingAnAlreadyEnrolledStudentIsANoOp (examples/university-message-transformation/src/test/java/org/axonframework/examples/demo/coursecatalog/catalog/write/enrollstudent/EnrollStudentAxonFixtureTest.java)
  • No assertions: enrolsStudentWhenCourseIsOpenAndStudentRegistered (examples/university-message-transformation/src/test/java/org/axonframework/examples/demo/coursecatalog/catalog/write/enrollstudent/EnrollStudentAxonFixtureTest.java)
  • No assertions: exactMatchWinsOverAnOverlappingPredicateWhenTheExactIsRegisteredFirst (examples/university-message-transformation/src/test/java/org/axonframework/examples/demo/coursecatalog/catalog/chain/SemanticMatchingTest.java)
  • No assertions: exactMatchWinsOverAnOverlappingPredicateWhenThePredicateIsRegisteredFirst (examples/university-message-transformation/src/test/java/org/axonframework/examples/demo/coursecatalog/catalog/chain/SemanticMatchingTest.java)
  • …and 53 more

Changes since last survey

  • 63 commits — 60 feature/other, 3 fixes

By area

  • (repo) — 22 commits
  • messaging/src — 16 commits
  • examples/spring-cloud — 4 commits
  • docs/reference-guide — 3 commits
  • examples/university-java-springboot-4 — 3 commits
  • (root) — 2 commits
  • .github/workflows — 2 commits
  • build/parent — 2 commits
  • docs/_playbook — 2 commits
  • .github/dependabot.yml — 1 commit
  • conversion/src — 1 commit
  • docs/saga-guide — 1 commit
  • eventsourcing/src — 1 commit
  • extensions/metrics — 1 commit
  • extensions/spring — 1 commit
  • integrationtests/src — 1 commit

Notable commits

  • fix: Merge pull request #5226 from AxonIQ/bug/null-and-empty-namespace-support
  • fix: Merge pull request #5231 from AxonIQ/bug/723-signal-blocking
  • fix: Merge pull request #5237 from AxonIQ/bug/connection-limit
  • change: Align SB connector sample module names
  • change: Allow defaulting namespace to null/empty
  • change: Bump chokidar in /docs/_playbook in the antora-dependencies group
  • change: Bump org.springframework.boot:spring-boot-dependencies
  • change: Bump qs from 6.16.0 to 6.17.1 in /docs/_playbook
  • change: Bump the github-dependencies group with 3 updates
  • change: Bump the maven-dependencies group
  • change: Bump the maven-dependencies group across 1 directory with 11 updates
  • change: Bump the maven-dependencies group across 1 directory with 14 updates
  • change: Bump the maven-dependencies group across 1 directory with 16 updates
  • change: Bump the maven-dependencies group across 1 directory with 4 updates
  • change: Bump tools.jackson:jackson-bom
  • change: Cap the coordinator's wait for a full work package at one second, and correct its Javadoc
  • change: Check how streams treat their sources, and make IgnoredEntriesMessageStream read its delegate only when read
  • change: Clarify deliberate duplication in README.md
  • change: Clarify nullability of the namespace
  • change: Clarify the segment progress tokens and test a skipped event in one batch
  • …and 43 more

Architecture

  • Containers 0 added · 0 removed · contexts 1 added · 1 removed · edges 1 added · 1 removed

Added bounded contexts (1)

  • university-springcloud-domain

Removed bounded contexts (1)

  • university-springboot3

Added dependency edges (1)

  • university-springcloud-domain → axon-messaging

Removed dependency edges (was a dependency, now gone) (1)

  • university-springboot3 → axon-messaging

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

AxonIQ/AxonFramework was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 9 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 68b46cdb8998814720d09ac07dd4d50d1c932d80 — the exact code this score is about.
  • Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-b921b700395b.