All Classes and Interfaces

Class
Description
Base FailoverExpiryExtractor that resolves expiry configuration from a @Failover annotation, preferring SpEL expression attributes over the literal numeric ones.
FailoverHandler decorator that publishes metrics on every store/recover operation and delegates payload post-processing to a RecoveredPayloadHandler.
Basic FailoverExecution that invokes the supplier, stores the result on success, and attempts recovery via the FailoverHandler on any exception.
AbstractFailoverExpiryExtractor that interprets expression strings as plain literals: durations are parsed with Long.parseLong(java.lang.String, int) and units with ChronoUnit.valueOf(java.lang.String).
Spring BeanFactory-backed implementation of ExpiryPolicyLookup.
AbstractFailoverExpiryExtractor that resolves expiry expressions via Spring's ConfigurableBeanFactory.resolveEmbeddedValue(java.lang.String), supporting property placeholders (e.g.
Spring BeanFactory-backed implementation of KeyGeneratorLookup.
Spring BeanFactory-backed implementation of PayloadSplitterLookup.
ManifestInfoExtractor decorator that caches extraction results by artifact title to avoid repeated classpath scans.
Utility for unchecked generic casts needed to bridge raw types at framework boundaries.
ResourceLoader that resolves resources via the current thread's class loader.
ContextPropagator that chains multiple propagators, applying each in order.
ObservablePublisher that stamps the publish timestamp once and fans metrics out to a list of delegate publishers.
Strategy for propagating thread-bound context (tenant ID, security principal, MDC trace) across executor boundaries in scatter/gather operations.
Strategy for detecting the underlying database product name from a live JDBC connection.
Default DatabaseResolver that reads the database product name from JDBC connection metadata.
Default ExpiryPolicy that computes expiry by adding the annotation-configured duration to the current clock time, and checks expiry against the current clock.
Default FailoverClock that returns the current UTC instant from the system clock.
Default FailoverHandler that persists payloads to the failover store on success and retrieves them on failure, applying expiry checks and payload enrichment.
Default FailoverObserver that scans for all @Failover-annotated methods and publishes a startup summary metric for each one.
Default FailoverStore decorator that ensures every payload written to or read from the delegate store has its upToDate flag forced to false.
Default FailoverStoreQueryResolver that resolves all JDBC queries against a given table prefix, selects the appropriate native merge/upsert dialect for the detected database, and owns all parameter binding and result-set mapping logic.
Default KeyGenerator that derives a cache key from method arguments.
ManifestInfoExtractor that searches all META-INF/MANIFEST.MF resources on the classpath for an entry whose Implementation-Title matches the requested title.
Default PayloadEnricher that propagates failover metadata (upToDate, asOf, exception info) into payloads that implement Referential or ReferentialAware.
Strategy that governs how the failover framework handles exceptions thrown by the primary method when recovery is unavailable or the stored entry has expired.
Wraps a Throwable thrown during the actual method execution inside the failover aspect.
Spring scheduler that periodically removes expired entries from the failover store via FailoverHandler.clean().
Strategy for computing and checking expiry of stored failover payloads.
Strategy for resolving an ExpiryPolicy by qualifier or bean name.
Thrown when no ExpiryPolicy bean is found for the qualifier specified in a @Failover annotation.
Annotation for handling the failover of the invoking a method.
AspectJ around-advice that intercepts methods annotated with Failover and delegates execution to the configured FailoverExecution strategy.
Root Spring Boot autoconfiguration for the failover framework.
Abstraction over the system clock used by the failover framework for computing and comparing expiry timestamps.
Strategy for executing a method call with failover semantics.
Extracts expiry configuration (duration and unit) from a @Failover annotation.
Composite ExpiryPolicy that delegates to a named policy from the lookup when @Failover#expiryPolicy() is set, falling back to the default policy otherwise.
Spring Boot FailureAnalyzer that produces actionable startup diagnostics when a required failover bean is missing.
Core handler for failover lifecycle operations: storing payloads, recovering them on failure, and cleaning up expired entries.
Spring Boot Actuator HealthIndicator for the failover framework.
Primary KeyGenerator that orchestrates key generation for a failover operation.
MeterBinder that exposes static failover configuration as Micrometer gauges.
Autoconfiguration for Micrometer-based failover metrics.
Resolves the effective store namespace for a Failover annotation.
Publishes a startup summary of all detected @Failover configurations.
Root configuration properties for the failover framework, bound to the failover prefix.
Scans the application classpath for methods annotated with Failover and provides lookup by name.
Thrown when the FailoverScanner encounters an error during Spring context scanning or detects duplicate @Failover names.
Persistence contract for failover referential data.
Central assembler that creates the single FailoverStore<Object> bean by combining a TenantStoreFactory (raw store) with the standard decorator chain (DefaultFailoverStore + optionally FailoverStoreAsync and/or MultiTenantFailoverStore).
FailoverStore implementation backed by a single Caffeine in-memory cache.
Thrown when a FailoverStore operation (store, find, delete, or clean) fails.
FailoverStore implementation backed by a plain ConcurrentHashMap.
JDBC-backed FailoverStore implementation.
Autoconfiguration that activates when failover.store.multitenant.enabled=true.
Contract for resolving JDBC queries, binding parameters, and mapping result-set rows for the failover store.
This describes the type of failover
TenantResolver that always returns the same literal tenant ID.
JDBC store configuration properties.
Jackson-backed Serializer that converts payloads to/from JSON using a provided ObjectMapper.
Strategy interface for generating a cache key from a failover operation's method arguments.
Strategy for resolving a KeyGenerator by qualifier or bean name.
Thrown when no KeyGenerator bean is found for the qualifier specified in a @Failover annotation.
Extracts build metadata from META-INF/MANIFEST.MF for a given artifact title.
ContextPropagator that propagates the SLF4J Mapped Diagnostic Context (MDC) across executor boundaries in scatter/gather operations.
AbstractObservablePublisher that publishes failover metrics by writing each metric entry into the MDC before emitting a single INFO log line, then restoring the prior MDC state.
Key-value bag for additional metadata attached to recovered failover payloads.
Carries all contextual information available at the point where a method exception is handled.
Default MethodExceptionPolicy — graceful handling with no exception propagator.
Strategy for deciding the final outcome after a primary method call fails and failover recovery has been attempted.
Mutable key-value bag for failover metrics, keyed with a "failover-" prefix.
ContextPropagator that propagates the active Micrometer Span across executor boundaries in scatter/gather operations.
ObservablePublisher that emits real Micrometer meters on every store/recover event.
Autoconfiguration that registers MicrometerContextPropagator when io.micrometer.tracing.Tracer is on the classpath and a Tracer bean exists.
Multitenant failover store configuration — a Store-level concern independent of the backing store technology (JDBC, Caffeine, InMemory).
Tenant isolation strategy for the JDBC store.
Outermost FailoverStore decorator that routes every operation to the correct per-tenant store.
MethodExceptionPolicy that serves recovered data when available, and cascades the original exception only when there is nothing to recover.
SPI for publishing failover metrics to an external sink (log, metrics system, event bus, etc.).
Spring scheduler that periodically calls FailoverObserver.observe() to collect metrics from all registered @Failover configurations and publish them to all registered ObservablePublisher beans.
No-op RecoveredPayloadHandler that returns the recovered payload unchanged.
Strategy for resolving the SQL type and extracting the value of the PAYLOAD column.
Strategy for enriching payloads before they are stored or after they are recovered.
Strategy that splits a composite payload into individual slices for scatter/gather operations.
Thrown when a user-provided PayloadSplitter raises an exception during splitOnStore, splitOnRecover, or merge.
Strategy for resolving a PayloadSplitter by qualifier or bean name.
Thrown when PayloadSplitterLookup cannot resolve the PayloadSplitter named in Failover.payloadSplitter().
Post-processor for payloads recovered from the failover store.
Base class for referential entities which need to be aware of the failover metadata information.
Interface to be implemented by referential entities that wish to be aware of the failover metadata information.
Envelope that wraps a referential payload with metadata used by the failover mechanism.
Spring JDBC RowMapper that converts a row from the FAILOVER_STORE table into a ReferentialPayload.
BasicFailoverExecution extension that wraps each supplier with a Resilience4j CircuitBreaker named after the failover point.
Autoconfiguration for the Resilience4j-based FailoverExecution.
Abstraction for locating classpath resources by name.
MethodExceptionPolicy that serves recovered data when available, and cascades the original exception only when there is nothing to recover.
Scatter/gather configuration for the failover framework.
FailoverHandler decorator that adds scatter/gather routing to Failover-annotated methods.
Scheduler configuration for the failover framework.
Strategy for serializing and deserializing business payloads to and from a storable string representation (e.g.
FailoverScanner backed by the Spring ApplicationContext.
Configuration properties for failover.store.*.
 
Per-tenant configuration overrides (JDBC only).
Thread-local holder for the current tenant ID.
ContextPropagator that propagates the current tenant ID from TenantContext across executor boundaries in scatter/gather operations.
TenantResolver that reads the current tenant ID from TenantContext.
Strategy for resolving the current tenant identifier from the execution context.
SPI for creating a raw FailoverStore for a given tenant.
Default PayloadColumnResolver that maps the PAYLOAD column as VARCHAR.