All Classes and Interfaces

Class
Description
Utility design to run an ApplicationContext and provide AssertJ style assertions.
A Bean registration to be applied when the context loaded.
 
Abstract ApplicationListener to expose Spring Security authentication events as AuditEvents.
Abstract ApplicationListener to expose Spring Security authorization denied and authorization granted events as AuditEvents.
Base class for DatabaseInitializerDetectors that detect database initializer beans by type.
Base class for DependsOnDatabaseInitializationDetectors that detect by type beans that depend upon database initialization.
Abstract base class for BindHandler implementations.
Base class for health contributor configurations that can combine source beans into a composite.
Abstract base class for ConfigurableWebServerFactory implementations.
AbstractConnectionFactoryConfigurer<T extends org.springframework.amqp.rabbit.connection.AbstractConnectionFactory>
Configures Rabbit ConnectionFactory with sensible defaults.
A base DataSourcePoolMetadata implementation.
Abstract base class for a BeanFactoryPostProcessor that can be used to dynamically declare that all beans of a specific type should depend on specific other beans identified by name or type.
Abstract base class for endpoints discovered by a EndpointDiscoverer.
Abstract base class for endpoints operations discovered by a EndpointDiscoverer.
Abstract base class for error @Controller implementations.
Abstract base class for ErrorWebExceptionHandler implementations.
Abstract base class for ExposableEndpoint implementations.
Abstract base class for most FailureAnalyzer implementations.
Abstract base ServletContextInitializer to register Filters in a Servlet 3.0+ container.
Base HealthIndicator implementations that encapsulates creation of Health instance and error handling.
Abstract base class for a FailureAnalyzer that handles some kind of injection failure.
Base class for binding Jetty metrics in response to an ApplicationStartedEvent.
Base class for AssertJ based JSON marshal testers.
Utility class used to support field initialization.
Base class for parsers wrapped or implemented in this package.
Abstract base class for LoggingSystem implementations.
Maintains a mapping between native levels and LogLevel.
Abstract base class for nested conditions.
 
AbstractRabbitListenerContainerFactoryConfigurer<T extends org.springframework.amqp.rabbit.config.AbstractRabbitListenerContainerFactory<?>>
Configure RabbitListenerContainerFactory with sensible defaults.
Base ReactiveHealthIndicator implementations that encapsulates creation of Health instance and error handling.
Abstract base class for ReactiveWebServerFactory implementations.
Base ImportBeanDefinitionRegistrar used to auto-configure Spring Data Repositories.
Base class for an InitializingBean that performs SQL database initialization using schema (DDL) and data (DML) scripts.
Scripts to be used to initialize the database.
Abstract base class for ConfigurableServletWebServerFactory implementations.
A custom HandlerMapping that makes web endpoints available over HTTP using Spring WebFlux.
An OperationInvoker that performs the invocation of a blocking operation on a separate thread using Reactor's bounded elastic scheduler.
Reactive handler providing actuator links at the root endpoint.
A reactive web operation that can be handled by WebFlux.
A custom HandlerMapping that makes web endpoints available over HTTP using Spring MVC.
Handler providing actuator links at the root endpoint.
A servlet web operation that can be handled by Spring MVC.
The specific access level granted to the cloud foundry user that's calling the endpoints.
Provides access control for a Dispatcher.
Auto-configuration to integrate with an ActiveMQ broker.
Callback interface that can be implemented by beans wishing to customize the ActiveMQConnectionFactory whilst retaining default auto-configuration.
Configuration properties for ActiveMQ.
 
Value object that represents an additional path for a HealthEndpointGroup.
A custom HandlerMapping that allows health groups to be mapped to an additional path.
A custom HandlerMapping that allows health groups to be mapped to an additional path.
Utility to determine if a Java agent based reloader (e.g.
Condition that will match when all nested class conditions match.
Utility class to find a class annotated with a particular annotation in a hierarchy.
ConfigurableReactiveWebApplicationContext that accepts annotated classes as input - in particular @Configuration-annotated classes, but also plain @Component classes and JSR-330 compliant classes using javax.inject annotations.
ReactiveWebServerApplicationContext that accepts annotated classes as input - in particular @Configuration-annotated classes, but also plain @Component classes and JSR-330 compliant classes using javax.inject annotations.
GenericWebApplicationContextthat accepts annotated classes as input - in particular @Configuration-annotated classes, but also plain @Component classes and JSR-330 compliant classes using javax.inject annotations.
ServletWebServerApplicationContext that accepts annotated classes as input - in particular @Configuration -annotated classes, but also plain @Component classes and JSR-330 compliant classes using javax.inject annotations.
Abstract base class for a TypeExcludeFilter that can be customized using an annotation.
 
EnumerablePropertySource to adapt annotations marked with @PropertyMapping.
AnsiElement implementation for ANSI 8-bit foreground or background color codes.
Ansi background colors.
Ansi colors.
An ANSI encodable element.
Generates ANSI encoded output, automatically attempting to detect if the terminal supports ANSI.
An ApplicationListener that configures AnsiOutput depending on the value of the property spring.output.ansi.enabled.
Ansi styles.
Condition that will match when any nested class condition matches.
Auto-configuration for Spring's AOP support.
API versions supported for the actuator API.
Provides access to the arguments that were used to run a SpringApplication.
Provides availability state information for the application.
Bean that provides an ApplicationAvailability implementation by listening for change events.
AssertJ assertions that can be applied to an ApplicationContext.
The scope of an assertion.
An ApplicationContext that additionally supports AssertJ style assertions.
Strategy interface for creating the ConfigurableApplicationContext used by a SpringApplication.
OncePerRequestFilter to add an X-Application-Context header that contains the ApplicationContext ID.
Event published when a SpringApplication is starting up and the ApplicationContext is prepared and ApplicationContextInitializers have been called but before any bean definitions are loaded.
An ApplicationContext runner for a standard, non-web environment ConfigurableApplicationContext.
Application context related test utilities.
A specialization of FormattingConversionService configured by default with converters and formatters appropriate for most Spring Boot applications.
Event published when a SpringApplication is starting up and the Environment is first available for inspection and modification.
Event published by a SpringApplication when it fails to start.
Provides access to the application home directory.
An application process ID.
An ApplicationListener that saves application PID into file.
Event published as when a SpringApplication is starting up and the ApplicationContext is fully prepared but not refreshed.
Event published as late as conceivably possible to indicate that the application is ready to service requests.
Interface used to indicate that a bean should run when it is contained within a SpringApplication.
Event published once the application context has been refreshed but before any application and command line runners have been called.
Event published as early as conceivably possible as soon as a SpringApplication has been started - before the Environment or ApplicationContext is available, but after the ApplicationListeners have been registered.
Provides access to an application specific temporary directory.
Auto-configuration for exporting metrics to AppOptics.
@ConfigurationProperties for configuring AppOptics metrics export.
Auto-configuration to integrate with an Artemis broker.
Callback interface that can be implemented by beans wishing to customize the Artemis JMS server Configuration before it is used by an auto-configured EmbeddedActiveMQ instance.
Define the mode in which Artemis can operate.
A no-op implementation of the BindingRegistry.
Configuration properties for Artemis.
Configuration for an embedded Artemis server.
An ApplicationContext that additionally supports AssertJ style assertions.
A ReactiveWebApplicationContext that additionally supports AssertJ style assertions.
A WebApplicationContext that additionally supports AssertJ style assertions.
Auto-configuration for exporting metrics to Atlas.
@ConfigurationProperties for configuring Atlas metrics export.
Spring ApplicationEvent to encapsulate AuditEvents.
A value object representing an audit event: at a particular time, a particular user or agent carried out an action of a particular type.
Repository for AuditEvents.
@Endpoint to expose audit events.
Description of an application's audit events.
The default AbstractAuditListener implementation.
Default implementation of AbstractAuthenticationAuditListener.
Default implementation of AbstractAuthorizationAuditListener.
Indicates that a class provides configuration that can be automatically applied by Spring Boot.
A TypeFilter implementation that matches registered auto-configuration classes.
Event fired when auto-configuration classes are imported.
Filter that can be registered in spring.factories to limit the auto-configuration classes considered.
Listener that can be registered with spring.factories to receive details of imported auto-configurations.
 
Provides access to meta-data written by the auto-configure annotation processor.
Registers packages with AutoConfigurationPackages.
Class for storing auto-configuration packages for reference later (e.g.
Configurations representing auto-configuration @Configuration classes.
Hint for that an auto-configuration should be applied after other specified auto-configuration classes.
Hint that an auto-configuration should be applied before other specified auto-configuration classes.
Annotation that can be applied to a test class to configure a test CacheManager if none has been defined yet.
Auto-configuration imports for typical Data Cassandra tests.
Auto-configuration imports for typical Data Couchbase tests.
Auto-configuration imports for typical Data Elasticsearch tests.
Auto-configuration imports for typical Data JDBC tests.
Auto-configuration imports for typical Data JPA tests.
Auto-configuration imports for typical Data LDAP tests.
Auto-configuration imports for typical Data MongoDB tests.
Auto-configuration imports for typical Data Neo4j tests.
Auto-configuration imports for typical Data R2DBC tests.
Auto-configuration imports for typical Data redis tests.
Auto-configuration imports for typical Spring GraphQL tests.
Annotation that can be applied to a test class to enable a GraphQlTester.
Annotation that can be applied to a test class to enable a HttpGraphQlTester.
Auto-configuration imports for typical jdbc tests.
Auto-configuration imports for typical jOOQ tests.
Auto-configuration imports for typical JSON tests.
Annotation that can be applied to a test class to enable and configure auto-configuration of JSON testers.
Deprecated, for removal: This API element is subject to removal in a future version.
since 3.0.0 for removal in 3.2.0 in favor of @AutoConfigureObservability
Annotation that can be applied to a test class to enable and configure auto-configuration of MockMvc.
Annotation that can be applied to a test class to enable and configure auto-configuration of a single MockRestServiceServer.
Annotation that can be applied to a test class to enable auto-configuration of MockWebServiceClient.
Annotation that can be applied to a test class to enable and configure auto-configuration of a single MockWebServiceServer.
Annotation that can be applied to a test class to enable auto-configuration for observability.
Auto-configuration specific variant of Spring Framework's @Order annotation.
Annotation that can be applied to a test class to enable and configure auto-configuration of Spring REST Docs.
Annotation that can be applied to a test class to configure a test database to use instead of the application-defined or auto-configured DataSource.
What the test database can replace.
Annotation that can be applied to a test class to enable auto-configuration of a TestEntityManager.
Annotation that can be applied to a test class to enable and configure auto-configuration of web clients.
Auto-configuration imports for typical Spring WebFlux tests.
Auto-configuration imports for typical Spring MVC tests.
Annotation that can be applied to a test class to enable and configure auto-configuration of web service clients.
Annotation that can be applied to a test class to enable and configure auto-configuration of web service servers endpoints.
Annotation that can be applied to a test class to enable a WebTestClient.
Nested configuration properties for items that are automatically timed.
Strategy that can be used to apply Timers automatically instead of using @Timed.
ApplicationEvent sent when the AvailabilityState of the application changes.
Auto-configuration for availability probes.
Tagging interface used on ApplicationAvailability states.
A HealthIndicator that checks a specific AvailabilityState of the application.
Callback used to add status mappings.
ApplicationListener to trigger early initialization in a background thread of time-consuming tasks.
Interface class for writing a banner programmatically.
An enumeration of possible values for configuring the Banner.
Basic global error @Controller, rendering ErrorAttributes.
Really basic JSON parser for when you have nothing else available.
AssertJ based JSON tester that works with basic JSON strings.
Auto-configuration for Spring Batch.
Callback interface that can be implemented by beans wishing to customize the ConfigurableConversionService that is provided by DefaultBatchConfiguration while retaining its default auto-configuration.
Qualifier annotation for a DataSource to be injected into Batch auto-configuration.
DataSourceScriptDatabaseInitializer for the Spring Batch database.
Auto-configuration for instrumentation of Spring Batch Jobs.
Configuration properties for Spring Batch.
 
 
An AbstractFailureAnalyzer that performs analysis of failures caused by a BeanNotOfRequiredTypeException.
@Endpoint to expose details of an application's beans, grouped by application context.
Description of a bean.
Description of an application's beans.
Description of an application context beans.
Source that can be bound by a Binder.
Restrictions that can be applied when binding values.
RuntimeHintsRegistrar that can be used to register ReflectionHints for Bindable types, discovering any nested type it may expose through a property.
Strategy interface used to determine a specific constructor to use when binding.
Context information for use by BindHandlers.
A container object which Binds objects from one or more ConfigurationPropertySources.
Exception thrown when binding fails.
Callback interface that can be used to handle additional logic during element binding.
Configuration property binding methods.
A container object to return the result of a Binder bind operation.
Error thrown when validation fails during a bind operation.
A simple bootstrap context that is available during startup and Environment post-processing up to the point that the ApplicationContext is prepared.
ApplicationEvent published by a BootstrapContext when it's closed.
A simple object registry that is available during startup and Environment post-processing up to the point that the ApplicationContext is prepared.
Supplier used to provide the actual instance when needed.
The scope of an instance.
Callback interface that can be used to initialize a BootstrapRegistry before it is used.
Bean to record and provide bound @ConfigurationProperties.
BindHandler that can be used to track bound configuration properties.
ApplicationStartup implementation that buffers steps and records their timestamp as well as their processing time.
Provide build-related information such as group and artifact.
Callback interface that can be implemented by beans wishing to customize the default setup for caches added to the manager through addCaches and for dynamically created caches.
CacheMeterBinderProvider implementation for cache2k.
Auto-configuration for the cache abstraction.
Callback interface that can be implemented by beans wishing to customize the cache manager before it is fully initialized, in particular to tune its configuration.
Invokes the available CacheManagerCustomizer instances in the context for a given CacheManager.
Provide a MeterBinder based on a Cache.
Auto-configuration for metrics on all available caches.
Register supported Cache to a MeterRegistry.
Configuration properties for the cache abstraction.
Caffeine specific cache properties.
Couchbase specific cache properties.
Infinispan specific cache properties.
JCache (JSR-107) specific cache properties.
Redis-specific cache properties.
@Endpoint to expose available caches.
Description of a Cache.
Description of a Cache entry.
Description of a CacheManager.
Description of the caches.
Supported cache types (defined in order of precedence).
Configures Rabbit CachingConnectionFactory with sensible defaults.
An OperationInvoker that caches the response of an operation with a configurable time to live.
OperationInvokerAdvisor to optionally provide result caching support.
CacheMeterBinderProvider implementation for Caffeine.
Provides access to System.out and System.err output that has been captured by the OutputCaptureExtension or OutputCaptureRule.
Auto-configuration for Cassandra.
Details required to establish a connection to a Cassandra service.
A Cassandra node.
Auto-configuration for Spring Data's Cassandra support.
Simple implementation of a HealthIndicator returning status information for Cassandra data stores.
Simple implementation of a ReactiveHealthIndicator returning status information for Cassandra data stores.
Configuration properties for Cassandra.
Name of the algorithm used to compress protocol frames.
 
 
Pool properties.
 
 
 
 
Auto-configuration for Spring Data's reactive Cassandra support.
Auto-configuration for Spring Data's Cassandra Reactive Repositories.
Auto-configuration for Spring Data's Cassandra Repositories.
Deprecated, for removal: This API element is subject to removal in a future version.
since 3.1.0 for removal in 3.3.0 in favor of registering a SslBundle backed by a PemSslStoreBundle.
A single file that has changed.
Change types.
A collections of files from a specific source directory that have changed.
A single file that may be served from a ClassLoader.
The kinds of class load files.
A container for files that may be served from a ClassLoader.
ClassLoaderFileRepository that maintains a collection of ClassLoaderFile items grouped by source directories.
An individual source directory that is being managed by the collection.
URLStreamHandler for the contents of a ClassLoaderFile.
ApplicationEvent containing details of a classpath change.
Listens and pushes any classpath updates to a remote endpoint.
Provides access to entries on the classpath that refer to directories.
Encapsulates a FileSystemWatcher to watch the local classpath directories for changes.
Strategy interface used to determine when a changed classpath file should trigger a full application restart.
Utility class that can be used to create ClientHttpRequestFactory instances configured using given ClientHttpRequestFactorySettings.
Settings that can be applied when creating a ClientHttpRequestFactory.
Deprecated, for removal: This API element is subject to removal in a future version.
since 3.0.0 for removal in 3.2.0 in favor of ClientHttpRequestFactories
Callback interface that can be implemented by beans wishing to customize the ClientResources through a ClientResources.Builder whilst retaining default auto-configuration.
Condition that matches if any spring.security.oauth2.client.registration properties are defined.
Auto-configuration to expose actuator endpoints for Cloud Foundry to use.
WebSecurityConfigurer to tell Spring Security to ignore cloudfoundry specific paths.
Authorization exceptions thrown to limit access to the endpoints.
Reasons why the exception can be thrown.
@EndpointExtension for the HealthEndpoint that always exposes full health details.
@EndpointExtension for the InfoEndpoint that always exposes full git details.
Reactive @EndpointExtension for the HealthEndpoint that always exposes full health details.
An EnvironmentPostProcessor that knows where to find VCAP (a.k.a.
WebEndpointDiscoverer for Cloud Foundry that uses Cloud Foundry specific extensions for the HealthEndpoint.
Simple detection for well known cloud platforms.
Callback interface that can be implemented by beans wishing to customize the ClusterEnvironment through a ClusterEnvironment.Builder whilst retaining default auto-configuration.
Callback interface that can be used to customize codecs configuration for an HTTP client and/or server with a CodecConfigurer.
properties for reactive codecs.
Log4j2 LogEventPatternConverter colors output using the AnsiOutput class.
Logback CompositeConverter colors output using the AnsiOutput class.
Interface used to indicate that a bean should run when it is contained within a SpringApplication.
DataSourcePoolMetadata for an Apache Commons DBCP2 DataSource.
A DataSourcePoolMetadataProvider implementation that returns the first DataSourcePoolMetadata that is found by one of its delegate.
A HealthComponent that is composed of other HealthComponent instances.
A HealthContributor that is composed of other HealthContributor instances.
Base class for health contributor configurations that can combine source beans into a composite.
Auto-configuration for a CompositeMeterRegistry.
A ReactiveHealthContributor that is composed of other ReactiveHealthContributor instances.
Base class for health contributor configurations that can combine source beans into a composite.
Simple server-independent abstraction for compression configuration.
Configure ConcurrentKafkaListenerContainerFactory with sensible defaults.
Caching implementation of the MetadataReaderFactory interface backed by a ConcurrentReferenceHashMap, caching MetadataReader per Spring Resource handle (i.e.
@Conditional that checks whether an endpoint is available.
@Conditional that only matches when beans meeting all the specified requirements are already contained in the BeanFactory.
@Conditional that only matches when the specified classes are on the classpath.
@Conditional that matches when the specified cloud platform is active.
@Conditional that only matches when web security is available and the user has not defined their own configuration.
@Conditional that checks whether a default health indicator is enabled.
@Conditional that checks whether an info contributor is enabled.
@Conditional that checks whether a metrics exporter is enabled.
@Conditional that checks whether the Spring resource handling chain is enabled.
@Conditional that checks whether tracing is enabled.
Configuration annotation for a conditional element that depends on the value of a SpEL expression.
@Conditional that only matches when a GraphQL schema is defined for the application, through schema files or infrastructure beans.
@Conditional that only matches when the RestartInitializer has been applied with non null URLs.
@Conditional that matches based on the JVM version the application is running on.
Range options.
@Conditional that matches based on the availability of a JNDI InitialContext and the ability to lookup specific locations.
@Conditional that matches based on the configuration of the management port.
@Conditional that only matches when no beans meeting the specified requirements are already contained in the BeanFactory.
@Conditional that only matches when the specified classes are not on the classpath.
@Conditional that only matches when no Filter beans of the specified type are contained in the BeanFactory.
@Conditional that only matches when the application is not a traditional WAR deployment.
@Conditional that only matches when the application context is a not a web application context.
@Conditional that checks if the specified properties have a specific value.
@Conditional that only matches when a particular type of Spring Data repository has been enabled.
@Conditional that only matches when the specified resources are on the classpath.
@Conditional that only matches when a bean of the specified class is already contained in the BeanFactory and a single candidate can be determined.
@Conditional that matches when the application is a traditional WAR deployment.
@Conditional that matches when the application is a web application.
Available application types.
Records condition evaluation details for reporting and logging.
Provides access to a single Condition and ConditionOutcome.
Provides access to a number of ConditionEvaluationReport.ConditionAndOutcome items.
A condition evaluation report message that can logged or printed.
A message associated with a ConditionOutcome.
Render styles.
Outcome for a condition match, including log message.
An ApplicationContextFailureProcessor that prints the ConditionEvaluationReport when the context cannot be prepared.
A description of an application's condition evaluation.
A description of an application context's condition evaluation, primarily intended for serialization to JSON.
Adapts ConditionEvaluationReport.ConditionAndOutcome to a JSON friendly structure.
Adapts ConditionEvaluationReport.ConditionAndOutcomes to a JSON friendly structure.
Callback interface that can be implemented by beans wishing to customize the Config through a Config.ConfigBuilder whilst retaining default auto-configuration.
Configuration data that has been loaded from a ConfigDataResource and may ultimately contribute property sources to Spring's Environment.
Option flags that can be applied.
A set of ConfigData.Option flags.
Strategy interface used to supply ConfigData.Options for a given PropertySource.
ApplicationContextInitializer that can be used with the ContextConfiguration.initializers() to trigger loading of ConfigData such as application.properties.
EnvironmentPostProcessor that loads and applies ConfigData to Spring's Environment.
EventListener to listen to Environment updates triggered by the ConfigDataEnvironmentPostProcessor.
Abstract base class for configuration data exceptions.
Strategy class that can be used to load ConfigData for a given ConfigDataResource.
Context provided to ConfigDataLoader methods.
A user specified location that can be resolved to one or more config data resources.
ConfigDataNotFoundException thrown when a ConfigDataLocation cannot be found.
Strategy interface used to resolve locations into one or more resources.
Context provided to ConfigDataLocationResolver methods.
Action to take when an uncaught ConfigDataNotFoundException is thrown.
ConfigDataNotFoundException thrown when a ConfigData cannot be found.
A single resource from which ConfigData can be loaded.
ConfigDataNotFoundException thrown when a ConfigDataResource cannot be found.
ConfigDataLoader for config tree locations.
ConfigDataLocationResolver for config tree locations.
ConfigDataResource backed by a config tree directory.
PropertySource backed by a directory tree that contains files for each value.
Property source options.
A value returned from the property source which exposes the contents of the property file.
A BootstrapContext that also provides configuration methods through the BootstrapRegistry interface.
ConfigurableWebServerFactory for Jetty-specific features.
Interface to provide configuration for a reactive web application.
Specialization of ConfigurableEnvironment for reactive application contexts.
A configurable RSocketServerFactory.
A configurable ServletWebServerFactory.
ConfigurableWebServerFactory for Tomcat-specific features.
ConfigurableWebServerFactory for Undertow-specific features.
SPI interface to be implemented by most if not all web server application contexts.
A configurable WebServerFactory.
Annotation for externalized configuration.
Provides access to @ConfigurationProperties bean details, regardless of if the annotation was used directly or on a @Bean factory method.
Deprecated, for removal: This API element is subject to removal in a future version.
since 3.0.8 for removal in 3.3.0 in favor of BindMethod
Exception thrown when @ConfigurationProperties binding fails.
Allows additional functionality to be applied to the BindHandler used by the ConfigurationPropertiesBindingPostProcessor.
Qualifier for beans that are needed to configure the binding of @ConfigurationProperties (e.g.
@Endpoint to expose application properties from @ConfigurationProperties annotated beans.
Description of a @ConfigurationProperties bean.
Description of an application's @ConfigurationProperties beans.
Description of an application context's @ConfigurationProperties beans.
BeanSerializerModifier to return only relevant configuration properties.
Configuration properties for ConfigurationPropertiesReportEndpoint.
Configures the base packages used when scanning for @ConfigurationProperties classes.
A single configuration property obtained from a ConfigurationPropertySource consisting of a name, value and optional origin.
Interface that can be used to control configuration property source caches.
A configuration property name composed of elements separated by dots.
The various forms that a non-indexed element value can take.
Maintains a mapping of ConfigurationPropertyName aliases.
Provides access to ConfigurationPropertySources.
The state of content from a ConfigurationPropertySource.
A set of @Configuration classes that can be registered in ApplicationContext.
ApplicationContextInitializer to report warnings for common misconfiguration mistakes.
A single check that can be applied.
ConfigurationWarningsApplicationContextInitializer.Check for @ComponentScan on problematic package.
Base interface for types that provide the details required to establish a connection to a remote service.
A registry of ConnectionDetailsFactory instances.
A factory to create ConnectionDetails from a given source.
RuntimeException thrown when a ConnectionDetailsFactory could not be found.
RuntimeException thrown when required ConnectionDetails could not be found.
Builder for ConnectionFactory.
Callback interface that can be implemented by beans wishing to customize the auto-configured RabbitMQ ConnectionFactory.
A HealthIndicator to validate a R2DBC ConnectionFactory.
Utility used to build an R2DBC ConnectionFactoryOptions for a RunningService.
Callback interface that can be implemented by beans wishing to customize the ConnectionFactoryOptions through a ConnectionFactoryOptions.Builder whilst retaining default auto-configuration.
A MeterBinder for a ConnectionPool.
Auto-configuration for metrics on all available R2DBC connection factories.
Provides access to the ports that can be used to connect to a RunningService.
A ConnectorStartFailedException is thrown when a Tomcat Connector fails to start, for example due to a port clash or incorrect SSL configuration.
Annotation that can be used to indicate which constructor to use when binding configuration properties using constructor arguments rather than by calling setters.
Deprecated, for removal: This API element is subject to removal in a future version.
since 3.0.0 for removal in 3.2.0 in favor of ConstructorBinding
Helper class to programmatically bind configuration properties that use constructor injection.
ContainerConnectionDetailsFactory<C extends org.testcontainers.containers.Container<?>,D extends ConnectionDetails>
Base class for ConnectionDetailsFactory implementations that provide ConnectionDetails from a ContainerConnectionSource.
ContainerConnectionDetailsFactory.ContainerConnectionDetails<C extends org.testcontainers.containers.Container<?>>
Base class for ConnectionDetails results that are backed by a ContainerConnectionSource.
ContainerConnectionSource<C extends org.testcontainers.containers.Container<?>>
Passed to ContainerConnectionDetailsFactory to provide details of the @ServiceConnection annotated Container that provides the service.
Callback interface used to process an ApplicationContext with the ability to throw a (checked) exception.
A mutable registry of health endpoint contributors (either HealthContributor or ReactiveHealthContributor).
Identifies a type as being an endpoint that is only exposed over Spring MVC or Spring WebFlux.
HandlerMapping that exposes @ControllerEndpoint and @RestControllerEndpoint annotated endpoints over Spring WebFlux.
HandlerMapping that exposes @ControllerEndpoint and @RestControllerEndpoint annotated endpoints over Spring MVC.
Cookie properties.
SameSite values.
Strategy interface that can be used with ConfigurableServletWebServerFactory implementations in order to supply custom Cookie.SameSite values for specific cookies.
Configuration properties for web endpoints' CORS support.
Auto-configuration for Couchbase.
Callback interface that can be implemented by beans wishing to customize the CouchbaseCacheManager.CouchbaseCacheManagerBuilder before it is used to build the auto-configured CouchbaseCacheManager.
Details required to establish a connection to a Couchbase service.
Auto-configuration for Spring Data's Couchbase support.
 
Configuration properties for Spring Data Couchbase.
HealthIndicator for Couchbase.
Configuration properties for Couchbase.
 
 
 
 
Auto-configuration for Spring Data's Reactive Couchbase support.
A ReactiveHealthIndicator for Couchbase.
Auto-configuration for Spring Data's Couchbase Reactive Repositories.
Auto-configuration for Spring Data's Couchbase Repositories.
Callback interface that can be implemented by beans wishing to customize the CqlSession through a CqlSessionBuilder whilst retaining default auto-configuration.
Enumeration of common database drivers.
Configures beans that depend upon SQL database initialization with dependencies upon beans that perform database initialization.
Supported database initialization modes.
Settings for initializing an SQL database.
Detects beans that initialize an SQL database.
Annotation that can be used for a Cassandra test that focuses only on Cassandra components.
Annotation that can be used for a Data Couchbase test that focuses only on Data Couchbase components.
Auto-configuration for exporting metrics to Datadog.
@ConfigurationProperties for configuring Datadog metrics export.
Annotation that can be used for a Data Elasticsearch test that focuses only on Data Elasticsearch components.
Annotation that can be used for a Data JDBC test that focuses only on Data JDBC components.
Annotation for a JPA test that focuses only on JPA components.
Annotation that can be used for an LDAP test that focuses only on LDAP components.
Annotation that can be used for a MongoDB test that focuses only on MongoDB components.
Annotation that can be used for a Neo4j test that focuses only on Neo4j components.
Internal utility to help when dealing with data object property names.
Annotation that can be used for a R2DBC test that focuses only on Data R2DBC components.
Annotation for a Data Redis test that focuses only on Redis components.
Annotation that can be used to change the default unit used when converting a DataSize.
 
 
Convenience class for building a DataSource.
A custom SpringLiquibase extension that closes the underlying DataSource once the database has been migrated.
HealthIndicator that tests the status of a DataSource and optionally runs a test query.
External configuration properties for DataSourceHealthIndicator.
Provides access meta-data that is commonly available from most pooled DataSource implementations.
Provide a DataSourcePoolMetadata based on a DataSource.
Register the DataSourcePoolMetadataProvider instances for the supported data sources.
A MeterBinder for a DataSource.
Auto-configuration for metrics on all available datasources.
Base class for configuration of a data source.
XA Specific datasource settings.
InitializingBean that performs DataSource initialization using schema (DDL) and data (DML) scripts.
Unwraps a DataSource that may have been proxied or wrapped in a custom Wrapper such as DelegatingDataSource.
Formatters for dates, times, and date-times.
EnvironmentPostProcessor to enable the Reactor Debug Agent if available.
Default implementation of ApplicationArguments.
Default ConfigurableBootstrapContext implementation.
Callback interface that can be implemented by beans wishing to customize the DefaultConfiguration whilst retaining default auto-configuration.
Callback interface that can be implemented by beans wishing to customize the DefaultCookieSerializer configuration.
Default implementation of ErrorAttributes.
Default implementation of ErrorAttributes.
Default ErrorViewResolver implementation that attempts to resolve error views using well known conventions.
Basic global WebExceptionHandler, rendering ErrorAttributes.
Default HealthContributorRegistry implementation.
Default implementation of JerseyApplicationPath that derives the path from JerseyProperties or the @ApplicationPath annotation.
Configure DefaultJmsListenerContainerFactory with sensible defaults.
Callback interface for customizing DefaultKafkaConsumerFactory beans.
Callback interface for customizing DefaultKafkaProducerFactory beans.
MapPropertySource containing default properties contributed directly to a SpringApplication.
Default ReactiveHealthContributorRegistry implementation.
Default RepositoryTagsProvider implementation.
Default RestartInitializer that only enable initial restart when running a standard "main" method.
Deprecated, for removal: This API element is subject to removal in a future version.
since 3.0.0 for removal in 3.2.0 in favor of DefaultClientRequestObservationConvention
Default implementation of SourceDirectoryUrlFilter that attempts to match URLs using common naming conventions.
Default SslBundleRegistry implementation.
Deprecated, for removal: This API element is subject to removal in a future version.
since 3.0.0 removal in 3.2.0 in favor of ApplicationContextFailureProcessor
Annotation that can be used to specify the default value when binding to an immutable property.
Deprecated, for removal: This API element is subject to removal in a future version.
since 3.0.0 for removal in 3.2.0 in favor of ClientRequestObservationConvention
Deprecated, for removal: This API element is subject to removal in a future version.
since 3.0.0 for removal in 3.2.0 in favor of ServerRequestObservationConvention
Deprecated, for removal: This API element is subject to removal in a future version.
since 3.0.0 for removal in 3.2.0 in favor of ServerRequestObservationConvention
Deferred Log that can be used to store messages that shouldn't be written until the logging system is fully initialized.
Factory that can be used to create multiple DeferredLog instances that will switch over when appropriate.
A DeferredLogFactory implementation that manages a collection DeferredLog instances.
ApplicationContextInitializer that delegates to other initializers that are specified under a context.initializer.classes environment property.
ApplicationListener that delegates to other listeners that are specified under a context.listener.classes environment property.
A ServletContextInitializer to register DelegatingFilterProxys in a Servlet 3.0+ container.
Identifies a method on an @Endpoint as being a delete operation.
Declares a field or method parameter should be converted to collection using the specified delimiter.
Indicate that a bean's creation and initialization depends upon database initialization having completed.
Detects beans that depend on database initialization.
Indicates that a getter in a @ConfigurationProperties object is deprecated.
Interface that can be implemented by ImportSelector and ImportBeanDefinitionRegistrar implementations when they can determine imports early.
Auto-configuration for DevTools-specific DataSource configuration.
Utility to deduce if DevTools should be enabled in the current context.
EnvironmentPostProcessor to add devtools properties from the user's home directory.
Devtools deferred logging support.
Configuration properties for developer tools.
LiveReload properties.
Restart properties.
EnvironmentPostProcessor to add properties that make sense when working at development time.
Auto-configuration for DevTools-specific R2DBC configuration.
DevTools settings loaded from /META-INF/spring-devtools.properties files.
Configure DirectRabbitListenerContainerFactoryConfigurer with sensible defaults.
An endpoint discovered by an EndpointDiscoverer.
An OperationMethod discovered by an EndpointDiscoverer.
EndpointFilter the matches based on the EndpointDiscoverer the created the endpoint.
A HealthIndicator that checks available disk space and reports a status of Status.DOWN when it drops below a configurable threshold.
External configuration properties for DiskSpaceHealthIndicator.
A MeterBinder that binds one or more DiskSpaceMetrics.
Dispatcher used to route incoming remote server requests to a Handler.
Servlet filter providing integration with the remote server Dispatcher.
A description of a mapping known to a DispatcherServlet.
Details of a DispatcherHandler mapping.
A MappingDescriptionProvider that introspects the HandlerMappings that are known to a DispatcherHandler.
 
 
A description of a mapping known to a DispatcherServlet.
Details of a DispatcherServlet mapping.
Interface that can be used by auto-configurations that need path details for the default DispatcherServlet.
A MappingDescriptionProvider that introspects the HandlerMappings that are known to one or more DispatcherServlets.
Enumeration of filter dispatcher types, identical to DispatcherType and used in configuration as the servlet API may not be present.
Provides a high-level API to work with Docker compose.
Base class for ConnectionDetailsFactory implementations that provide ConnectionDetails from a DockerComposeConnectionSource.
Convenient base class for ConnectionDetails results that are backed by a RunningService.
A reference to a docker compose file (usually named compose.yaml).
An origin which points to a service defined in docker compose.
Configuration properties for Docker Compose.
Profiles properties.
Readiness properties.
TCP properties.
Readiness wait strategies.
Skip options.
Start properties.
Stop properties.
ApplicationEvent published when Docker Compose RunningService instances are available.
Base class for docker exceptions.
DockerException thrown if the docker daemon is not running.
DockerException thrown if the docker JSON cannot be parsed.
DockerException thrown if the docker process cannot be started.
Callback interface that can be implemented by beans wishing to customize the DriverConfigLoader through a DriverConfigLoaderBuilderCustomizer whilst retaining default auto-configuration.
Annotation that can be used to indicate the format to use when converting a Duration.
Duration format styles.
Annotation that can be used to change the default unit used when converting a Duration.
Base class for Servlet 3.0+ dynamic based registration beans.
Auto-configuration for exporting metrics to Dynatrace.
@ConfigurationProperties for configuring Dynatrace metrics export.
 
 
Auto-configuration for exporting metrics to Elastic.
@ConfigurationProperties for configuring Elastic metrics export.
Auto-configuration for Elasticsearch's Java client.
Details required to establish a connection to an Elasticsearch service.
An Elasticsearch node.
Connection protocol.
Auto-configuration for Spring Data's Elasticsearch support.
Configuration properties for Elasticsearch.
 
 
 
Auto-configuration for ElasticsearchReactiveHealthIndicator using the ReactiveElasticsearchClient.
HealthIndicator for an Elasticsearch cluster using a ReactiveElasticsearchClient.
Auto-configuration for Spring Data's Elasticsearch Repositories.
Auto-configuration for Elasticsearch REST clients.
HealthIndicator for an Elasticsearch cluster using a RestClient.
Connection details for embedded databases.
Connection details for embedded databases compatible with R2DBC.
Configuration for embedded data sources.
Auto-configuration for Embedded LDAP.
Configuration properties for Embedded LDAP.
 
 
Auto-configuration for embedded servlet and reactive web servers customizations.
Nested configuration if Jetty is being used.
Nested configuration if Netty is being used.
Nested configuration if Tomcat is being used.
Nested configuration if Undertow is being used.
Enable auto-configuration of the Spring Application Context, attempting to guess and configure beans that you are likely to need.
Enable support for @ConfigurationProperties annotated beans.
Configuration properties for server HTTP encoding.
Type of HTTP message to consider for encoding configuration.
Identifies a type as being an actuator endpoint that provides information about the running application.
Identifies a type as being a Cloud Foundry specific extension for an @Endpoint.
Qualifier for beans that are needed to convert @Endpoint input parameters.
A Base for EndpointsSupplier implementations that discover @Endpoint beans and @EndpointExtension beans in an application context.
A key generated for an Operation based on specific criteria from the actual operation implementation.
Technologies that can be used to expose an endpoint.
Annotation primarily used as a meta-annotation to indicate that an annotation provides extension support for an endpoint.
Strategy class that can be used to filter endpoints.
An identifier for an actuator endpoint.
Identifies a type as being a JMX-specific extension of an @Endpoint.
A resolver for links to web endpoints.
A value object for the base mapping for endpoints.
Adapter to expose a JMX endpoint as a DynamicMBean.
Media types that are, by default, produced and consumed by an endpoint.
Interface used to supply the ObjectMapper that should be used when serializing OperationResponseBody endpoint results.
A factory to create an ObjectName for an EndpointMBean.
Factory that can be used to create a ServerWebExchangeMatcher for actuator endpoint locations.
Factory that can be used to create a RequestMatcher for actuator endpoint locations.
The request matcher used to match against actuator endpoints.
The ServerWebExchangeMatcher used to match against actuator endpoints.
The request matcher used to match against the links endpoint.
The ServerWebExchangeMatcher used to match against the links endpoint.
Contains details of a servlet that is exposed as an actuator endpoint.
Provides access to a collection of endpoints.
Identifies a type as being a Web-specific extension of an @Endpoint.
Convenient builder for JPA EntityManagerFactory instances.
Callback interface that can be used to customize the auto-configured EntityManagerFactoryBuilder.
BeanFactoryPostProcessor that can be used to dynamically declare that all EntityManagerFactory beans should "depend on" one or more specific beans.
Configures the base packages used by auto-configuration when scanning for entity classes.
An entity scanner that searches the classpath from an @EntityScan specified packages.
Class for storing @EntityScan specified packages for reference later (e.g.
Callback interface that can be implemented by beans wishing to customize the auto-configured Environment that is created by an EnvironmentBuilder.
@Endpoint to expose environment information.
Description of an Environment.
Description of an entry of the Environment.
Description of a PropertySource.
Description of a particular entry of PropertySource.
Description of a particular entry of the Environment.
Description of a property's value, including its origin if available.
Configuration properties for EnvironmentEndpoint.
An InfoContributor that provides all environment entries prefixed with info.
Allows for customization of the application's Environment prior to the application context being refreshed.
SmartApplicationListener used to trigger EnvironmentPostProcessors registered in the spring.factories file.
Factory interface used by the EnvironmentPostProcessorApplicationListener to create the EnvironmentPostProcessor instances.
Options controlling the contents of ErrorAttributes.
Error attributes that can be included in an error response.
Provides access to error attributes which can be logged or presented to the user.
Provides access to error attributes which can be logged or presented to the user.
Marker interface used to identify a @Controller that should be used to render errors.
Auto-configuration to render errors through an MVC error controller.
 
Simple server-independent abstraction for error pages.
A Servlet Filter that provides an ErrorPageRegistry for non-embedded applications (i.e.
Interface to be implemented by types that register ErrorPages.
BeanPostProcessor that applies all ErrorPageRegistrars from the bean factory to ErrorPageRegistry beans.
Interface for a registry that holds ErrorPages.
Configuration properties for web error handling.
Include error attributes options.
Include Stacktrace attribute options.
 
Interface that can be implemented by beans that resolve error views.
Marker interface that indicates that a WebExceptionHandler is used to render errors.
Auto-configuration to render errors through a WebFlux WebExceptionHandler.
Event fired when an application exit code has been determined from an ExitCodeGenerator.
Strategy interface that can be used to provide a mapping between exceptions and exit codes.
Interface used to generate an 'exit code' from a running command line SpringApplication.
Information describing an endpoint that can be exposed over Spring MVC or Spring WebFlux.
Information describing an endpoint that can be exposed in some technology specific way.
Information describing an endpoint that can be exposed over JMX.
Information describing an endpoint that can be exposed by registering a servlet.
Information describing an endpoint that can be exposed over the web.
ThrowablePatternConverter that adds some additional whitespace around the stack trace.
ExtendedThrowableProxyConverter that adds some additional whitespace around the stack trace.
The result of analyzing a failure.
Reports a FailureAnalysis to the user.
A FailureAnalyzer is used to analyze a failure and provide diagnostic information that can be displayed to the user.
Strategy used to handle launch failures.
Various outcomes for the handler.
Callback interface when file changes are detected.
An ApplicationListener that halts application startup if the system file encoding does not match an expected value set in the environment.
Watches specific directories for file changes.
Factory used to create new FileSystemWatcher instances.
Utility to load TypeFilters from @Filter annotations.
Test URLClassLoader that can filter the classes and resources it can load.
Filter to restrict the classes that can be loaded.
Filter to restrict the resources that can be loaded.
Filter to restrict the packages that can be loaded.
Annotation that can be used on an @Endpoint to implement implicit filtering.
A ServletContextInitializer to register Filters in a Servlet 3.0+ container.
A MappingDescriptionProvider that describes that mappings of any Filters registered with a ServletContext.
Auto-configuration for Flyway database migrations.
 
Callback interface that can be implemented by beans wishing to customize the flyway configuration.
Details required for Flyway to establish a connection to an SQL service using JDBC.
Qualifier annotation for a DataSource to be injected in to Flyway.
@Endpoint to expose flyway info.
Description of an application context's Flyway beans.
Description of an application's Flyway beans.
Description of a Flyway bean.
Description of a migration performed by Flyway.
InitializingBean used to trigger Flyway migration through the FlywayMigrationStrategy.
Strategy used to initialize Flyway migration.
Configuration properties for Flyway database migrations.
Auto-configuration for FreeMarker.
@ConfigurationProperties for configuring FreeMarker.
TemplateAvailabilityProvider that provides availability information for FreeMarker view templates.
 
Auto-configuration for exporting metrics to Ganglia.
@ConfigurationProperties for configuring Ganglia metrics export.
Subclass of GenericApplicationContext, suitable for reactive web environments.
Provide git-related information such as commit id and time.
A callback for the result of a graceful shutdown request.
The result of a graceful shutdown request.
Auto-configuration for exporting metrics to Graphite.
@ConfigurationProperties for configuring Graphite metrics export.
Auto-configuration for creating a Spring GraphQL base infrastructure.
Configuration properties for GraphQL endpoint's CORS support.
Auto-configuration for instrumentation of Spring GraphQL endpoints.
properties for Spring GraphQL.
 
 
 
 
 
 
Auto-configuration that creates a GraphQlSourceBuilderCustomizers to detect Spring Data repositories with Query By Example support and register them as DataFetchers for any queries with a matching return type.
Auto-configuration that creates a GraphQlSourceBuilderCustomizers to detect Spring Data repositories with Querydsl support and register them as DataFetchers for any queries with a matching return type.
Auto-configuration that creates a GraphQlSourceBuilderCustomizers to detect Spring Data repositories with Query By Example support and register them as DataFetchers for any queries with a matching return type.
Auto-configuration that creates a GraphQlSourceBuilderCustomizers to detect Spring Data repositories with Querydsl support and register them as DataFetchers for any queries with a matching return type.
Auto-configuration for enabling Spring GraphQL over RSocket.
Callback interface that can be implemented by beans wishing to customize properties of Builder whilst retaining default auto-configuration.
Annotation to perform GraphQL tests focusing on GraphQL request execution without a Web layer, and loading only a subset of the application configuration.
Auto-configuration for GraphQlTester.
Auto-configuration for enabling Spring GraphQL over WebFlux.
 
 
Auto-configuration for enabling Security support for Spring GraphQL with WebFlux.
Auto-configuration for enabling Spring GraphQL over Spring MVC.
 
 
Auto-configuration for enabling Security support for Spring GraphQL with MVC.
Auto-configuration support for Groovy templates in MVC.
 
 
TemplateAvailabilityProvider that provides availability information for Groovy view templates.
 
@ConfigurationProperties for configuring Groovy templates.
Callback interface that can be implemented by beans wishing to further customize the Gson through GsonBuilder retaining its default auto-configuration.
Thin wrapper to adapt Gson to a JsonParser.
Configuration properties to configure Gson.
AssertJ based JSON tester backed by Gson.
Auto-configuration for H2's web console.
Configuration properties for H2's console.
 
A single handler that is able to process an incoming remote server request.
Description of a HandlerFunction.
Interface to provide a mapping between a ServerHttpRequest and a Handler.
A description of a HandlerMethod.
properties for Spring HATEOAS.
Auto-configuration for Hazelcast IMDG.
CacheMeterBinderProvider implementation for Hazelcast.
Callback interface that can be implemented by beans wishing to customize the Hazelcast server configuration.
SpringBootCondition used to check if the Hazelcast configuration is available.
HealthIndicator for Hazelcast.
Additional configuration to ensure that EntityManagerFactory beans depend on the hazelcastInstance bean.
Configuration properties for the hazelcast integration.
Configuration properties for Hazelcast backed Spring Session.
Carries information about the health of a component or subsystem.
Builder for creating immutable Health instances.
A component that contributes data to results returned from the HealthEndpoint.
Tagging interface for classes that contribute to health components to the results returned from the HealthEndpoint.
Generate a sensible health indicator name based on its bean name.
@Endpoint to expose application health information.
A logical grouping of health contributors that can be exposed by the HealthEndpoint.
A collection of groups for use with a health endpoint.
Hook that allows for custom modification of HealthEndpointGroups — for example, automatically adding additional auto-configured groups.
Configuration properties for HealthEndpoint.
A health endpoint group.
Health logging properties.
Strategy interface used to contribute Health to the results returned from the HealthEndpoint.
Properties used to configure the health endpoint and endpoint groups.
Status properties for the group.
Web @Endpoint to expose heap dumps.
Strategy interface used to dump the heap to a file.
Exception to be thrown if the HeapDumpWebEndpoint.HeapDumper cannot be created.
HeapDumpWebEndpoint.HeapDumper that uses com.sun.management.HotSpotDiagnosticMXBean, available on Oracle and OpenJDK, to dump the heap to a file.
Auto-configuration for Hibernate JPA.
Auto-configuration for metrics on all available Hibernate EntityManagerFactory instances that have statistics enabled.
Configuration properties for Hibernate.
 
Callback interface that can be implemented by beans wishing to customize the Hibernate properties before it is used by an auto-configured EntityManagerFactory.
Settings to apply when configuring Hibernate.
Simple server-independent abstraction for HTTP/2 configuration.
Auto-configuration for HTTP client-related observations.
Strategy used to map a health status to an HTTP status code.
Auto-configuration for configuring the encoding to use in web applications.
An HTTP request and response exchange.
Principal associated with an HTTP request-response exchange.
The request that started the exchange.
The response that finished the exchange.
The session associated with the exchange.
A started request that when finished will return a new HttpExchange instance.
A repository for HttpExchange instances.
@Endpoint to expose HttpExchange information.
Description of an application's HttpExchange entries.
Servlet Filter for recording HTTP exchanges.
Configuration properties for recording HTTP exchanges.
Recording properties.
A WebFilter for recording HTTP exchanges.
Auto-configuration for HttpGraphQlTester.
 
Factory used by UndertowServletWebServer to add HttpHandlers.
AccessManager that checks for the presence of an HTTP header secret.
ClientHttpRequestInterceptor to populate arbitrary HTTP headers with a value.
Bean used to manage the HttpMessageConverters used in a Spring Boot application.
 
An HTTP server that can be used to upload updated ClassLoaderFiles and trigger restarts.
Handler that responds with a specific HttpStatus.
TunnelConnection implementation that uses HTTP to transfer data.
Encapsulates a payload data sent over a HTTP tunnel.
Utility class that forwards HttpTunnelPayload instances to a destination channel, respecting sequence order.
A server that can be used to tunnel TCP traffic over HTTP.
Encapsulates an HTTP request/response pair.
Adapts a HttpTunnelServer to a Handler.
WebServiceMessageSender builder that can detect a suitable HTTP library based on the classpath.
Auto-configuration for exporting metrics to Humio.
@ConfigurationProperties for configuring Humio metrics export.
Auto-configuration for Spring HATEOAS's @EnableHypermediaSupport.
 
BindHandler that can be used to ignore binding errors.
BindHandler that can be used to ignore top-level ConverterNotFoundExceptions.
A reference to a Docker image of the form "imagename[:tag|@digest]".
Import and apply the specified auto-configuration classes.
Contains @Configuration import candidates, usually auto-configurations.
Imports idiomatic Testcontainer declaration classes into the Spring ApplicationContext.
Exception thrown when an attempt is made to resolve a property against an inactive ConfigData property source.
Include options for HTTP exchanges.
EndpointFilter that will filter endpoints based on include and exclude patterns.
Exception thrown when the application has configured an incompatible set of ConfigurationProperties keys.
Infinispan cache configuration.
Auto-configuration for InfluxDB.
Callback interface that can be implemented by beans wishing to further customize InfluxDB whilst retaining default auto-configuration.
HealthIndicator for InfluxDB.
Provide the OkHttpClient.Builder to use to customize the auto-configured InfluxDB instance.
Configuration properties for InfluxDB.
Auto-configuration for exporting metrics to Influx.
@ConfigurationProperties for configuring Influx metrics export.
Carries information of the application.
Builder for creating immutable Info instances.
Contributes additional info details.
Controls the fallback behavior when the primary property that controls whether an info contributor is enabled is not set.
Configuration properties for core info contributors.
 
@Endpoint to expose arbitrary application information.
Base class for components exposing unstructured data with dedicated methods for well known keys.
Property entry.
A base InfoContributor to expose an InfoProperties.
Defines how properties should be exposed.
In-memory AuditEventRepository implementation.
In-memory implementation of HttpExchangeRepository.
Simple factory used to instantiate objects by injecting available parameters.
Callback used to register available parameters.
Strategy for handling a failure that occurs when instantiating a type.
Auto-configuration for Spring Integration.
Integration component scan configuration.
Basic Spring Integration configuration.
Integration JDBC configuration.
Spring Integration JMX configuration.
Integration management configuration.
 
Integration RSocket configuration.
 
 
Expose a standard ThreadPoolTaskScheduler if the user has not enabled task scheduling explicitly.
DataSourceScriptDatabaseInitializer for the Spring Integration database.
@Endpoint to expose the Spring Integration graph.
Description of a Graph.
Configuration properties for Spring Integration.
 
 
 
 
 
 
 
 
 
Exception thrown if an invalid property is found when processing config data.
Exception thrown when ConfigurationPropertyName has invalid characters.
Exception thrown when a configuration property value is invalid.
Indicate that an endpoint request is invalid.
The context for the invocation of an operation.
A String to OffsetDateTime Converter that uses ISO offset parsing.
Condition for creating JwtDecoder by oidc issuer location.
A ConfigurationPropertySource with a fully Iterable set of entries.
Callback interface that can be implemented by beans wishing to further customize the ObjectMapper through Jackson2ObjectMapperBuilder retaining its default auto-configuration.
Auto configuration for Jackson.
Auto-configuration for Endpoint Jackson support.
JmxOperationResponseMapper that delegates to a Jackson ObjectMapper to return a JSON response.
Thin wrapper to adapt Jackson 2 ObjectMapper to JsonParser.
Configuration properties to configure Jackson.
 
AssertJ based JSON tester backed by Jackson.
Information about the Java environment the application is running in.
Information about the Java Runtime Environment the application is running in.
Information about the Java Vendor of the Java Runtime the application is running in.
Information about the Java Virtual Machine the application is running in.
An InfoContributor that exposes JavaInfo.
LoggingSystemFactory that returns JavaLoggingSystem if possible.
Known Java versions.
CacheMeterBinderProvider implementation for JCache.
Callback interface that can be implemented by beans wishing to customize the cache manager before it is used, in particular to create additional caches.
Details required to establish a connection to an SQL service using JDBC.
Configuration properties for JDBC.
JdbcTemplate settings.
Auto-configuration for Spring Data's JDBC Repositories.
DataSourceScriptDatabaseInitializer for the Spring Session JDBC database.
Configuration properties for JDBC backed Spring Session.
Annotation for a JDBC test that focuses only on JDBC-based components.
Utility used to build a JDBC URL for a RunningService.
Callback interface that can be implemented by beans wishing to customize the JedisClientConfiguration through a JedisClientConfiguration.JedisClientConfigurationBuilder whilst retaining default auto-configuration.
Interface that can be used by auto-configurations that need path details Jersey's application path that serves as the base URI for the application.
Auto-configuration for Jersey.
 
@ManagementContextConfiguration for Jersey infrastructure when a separate management context with a web server running on a different port is required.
A factory for creating Jersey Resources for web endpoint operations.
A factory for creating Jersey Resources for health groups with additional path.
 
 
 
@ManagementContextConfiguration for Jersey infrastructure when the management context is the same as the main application context.
Auto-configuration for Jersey server instrumentation.
AbstractJettyMetricsBinder for JettyConnectionMetrics.
Auto-configuration for Jetty metrics.
ReactiveWebServerFactory that can be used to create JettyWebServers.
Callback interface that can be used to customize a Jetty Server.
AbstractJettyMetricsBinder for JettyServerThreadPoolMetrics.
ServletWebServerFactory that can be used to create a JettyWebServer.
AbstractJettyMetricsBinder for JettySslHandshakeMetrics.
WebServer that can be used to control a Jetty web server.
Customization for Jetty-specific features common for both Servlet and Reactive servers.
WebSocket customizer for JettyReactiveWebServerFactory.
WebSocket customizer for JettyServletWebServerFactory.
SslBundleProperties for Java keystores.
Store properties.
SslStoreBundle backed by a Java keystore.
Details for an individual trust or key store in a JksSslStoreBundle.
Auto-configuration for Spring JMS.
 
 
Factory to create a JmsPoolConnectionFactory from properties defined in JmsPoolConnectionFactoryProperties.
Configuration properties for connection factory pooling.
Configuration properties for JMS.
Translate the acknowledge modes defined on the Session.
 
 
 
 
Auto-configuration to enable/disable Spring's @EnableMBeanExport mechanism based on configuration properties.
Identifies a type as being an endpoint that is only exposed over JMX.
Auto-configuration for JMX @Endpoint support.
Configuration properties for JMX export of endpoints.
 
Auto-configuration for exporting metrics to JMX.
An operation on a JMX endpoint.
Describes the parameters of an operation on a JMX endpoint.
Maps an operation's response to a JMX-friendly form.
@ConfigurationProperties for configuring JMX metrics export.
Configuration properties for JMX.
Auto-configuration for JMS provided from JNDI.
Auto-configuration for a JNDI located DataSource.
Spring ApplicationEvent encapsulating a JobExecution.
ApplicationRunner to launch Spring Batch jobs.
Define the supported Quartz JobStore.
 
Transforms SQLException into a Spring-specific DataAccessException.
Configuration properties for the JOOQ database library.
Annotation for a jOOQ test that focuses only on jOOQ-based components.
Base Auto-configuration for JPA.
 
External configuration properties for a JPA EntityManagerFactory created by Spring.
Auto-configuration for Spring Data's JPA Repositories.
Auto-configuration for JSON-B.
AssertJ based JSON tester backed by Jsonb.
@Component that provides JsonSerializer, JsonDeserializer or KeyDeserializer implementations to be registered with Jackson when JsonComponentModule is in use.
The various scopes under which a serializer/deserializer can be registered.
Spring Bean and Jackson Module to register @JsonComponent annotated beans.
JSON content usually created from a JSON tester.
AssertJ Assert for JsonContent.
Provides a mixin class implementation that registers with Jackson when using JsonMixinModule.
Spring Bean and Jackson Module to find and register @JsonMixin-annotated classes.
Provide the mapping of json mixin class to consider.
Helper base class for JsonDeserializer implementations that deserialize objects.
Helper base class for JsonSerializer implementations that serialize objects.
IllegalArgumentException thrown when source JSON is invalid.
Parser that can read JSON formatted strings into Maps or Lists.
Factory to create a JsonParser.
Annotation for a JSON test that focuses only on JSON serialization.
Auto-configuration for Json testers.
Configuration for the server's JSP servlet.
TemplateAvailabilityProvider that provides availability information for JSP view templates.
Auto-configuration for JVM metrics.
Callback interface for the customization of the NimbusJwtDecoder.JwkSetUriJwtDecoderBuilder used to create the auto-configured JwtDecoder for a JWK set URI that has been configured directly or obtained through an issuer URI.
Callback interface for the customization of the NimbusReactiveJwtDecoder.JwkSetUriReactiveJwtDecoderBuilder used to create the auto-configured ReactiveJwtDecoder for a JWK set URI that has been configured directly or obtained through an issuer URI.
Auto-configuration for Apache Kafka.
Details required to establish a connection to a Kafka service.
Auto-configuration for Kafka metrics.
Configuration properties for Spring for Apache Kafka.
 
 
 
 
 
 
 
 
 
Properties for non-blocking, topic-based retries.
 
 
High (and some medium) priority Streams properties and a general properties bucket.
 
Auto-configuration for exporting metrics to KairosDB.
@ConfigurationProperties for configuring KairosDB metrics export.
Condition for creating a jwt decoder using a public key value.
Utility that can be used to invoke lambdas in a safe way.
Represents a single callback that can be invoked in a lambda safe way.
Represents a collection of callbacks that can be invoked in a lambda safe way.
The result of a callback which may be a value, null or absent entirely if the callback wasn't suitable.
Abstract base class for lambda safe callbacks.
BeanFactoryPostProcessor to set lazy-init on bean definitions that are not excluded and have not already had a value explicitly set.
Filter that can be used to exclude beans definitions from having their lazy-init set by the LazyInitializationBeanFactoryPostProcessor.
HealthIndicator for configured LDAP server(s).
Configuration properties for LDAP.
settings.
Auto-configuration for Spring Data's LDAP Repositories.
Callback interface that can be implemented by beans wishing to customize the LettuceClientConfiguration through a LettuceClientConfiguration.LettuceClientConfigurationBuilder whilst retaining default auto-configuration.
Auto-configuration for Lettuce metrics.
Auto-configuration relating to the application context's lifecycle.
Docker Compose lifecycle management.
Configuration properties for lifecycle processing.
Details for a link in a HAL-formatted response.
Auto-configuration for Liquibase.
 
Details required for Liquibase to establish a connection to an SQL service using JDBC.
Qualifier annotation for a DataSource to be injected in to Liquibase.
@Endpoint to expose liquibase info.
Description of a Liquibase change set.
Description of a context expression in a LiquibaseEndpoint.ChangeSetDescriptor.
Description of an application context's SpringLiquibase beans.
Description of a SpringLiquibase bean.
Description of an application's SpringLiquibase beans.
Configuration properties to configure SpringLiquibase.
"Liveness" state of the application.
A HealthIndicator that checks the LivenessState of the application.
A livereload server.
Auto-configuration for local development support.
UriTemplateHandler will automatically prefix relative URIs with localhost:${local.server.port}.
WebClient will automatically prefix relative URLs with localhost:${local.server.port}.
LocalHostWebConnectionHtmlUnitDriver will automatically prefix relative URLs with localhost:${local.server.port}.
Annotation at the field or method/constructor parameter level that injects the HTTP management port that was allocated at runtime.
Annotation at the field or method/constructor parameter level that injects the RSocket port that was allocated at runtime.
Annotation at the field or method/constructor parameter level that injects the HTTP server port that was allocated at runtime.
LoggingSystemFactory that returns Log4J2LoggingSystem if possible.
Auto-configuration for Log4J2 metrics.
LoggingSystemFactory that returns LogbackLoggingSystem if possible.
Auto-configuration for Logback metrics.
A reference to a log output file.
Web @Endpoint that provides access to an application's log file.
Configuration properties for LogFileWebEndpoint.
Immutable class that represents the configuration of a LoggingSystem's logger.
Supported logger configurations scopes.
Logger level configuration.
A single logger group.
Logger groups configured through the Spring Environment.
@Endpoint to expose a collection of LoggerConfigurations.
Description of levels configured for a given group logger.
Description of levels configured for a given logger.
Description of loggers.
Description of levels configured for a given single logger.
An ApplicationListener that configures the LoggingSystem.
FailureAnalysisReporter that logs the failure analysis.
Context passed to the LoggingSystem during initialization.
Common abstraction over logging systems.
Factory class used by LoggingSystem.get(ClassLoader) to find an actual implementation.
Utility to set system properties that can later be used by log configuration files.
Logging levels supported by a LoggingSystem.
HealthIndicator for configured smtp server(s).
Configuration properties for email support.
Auto configuration for email support.
Auto configuration for testing mail service connectivity on startup.
Auto-configuration for the management context.
Specialized @Configuration class that defines configuration specific for the management context.
Factory for creating a separate management context when the management web server is running on a different port to the main application.
Callback interface that can be implemented by beans wishing to customize Jersey's ResourceConfig in the management context before it is used.
Enumeration of management context types.
@Controller for handling "/error" path when the management servlet is in a child context.
Port types that can be used to control how the management server is started.
Properties for the management server (e.g.
Provides information about the management servlet context for MVC controllers to use.
Auto-configuration for Spring Security when actuator is on the classpath.
WebServerFactoryCustomizer that customizes the WebServerFactory used to create the management context's web server.
A ConfigurationPropertySource backed by a Map and using standard name mapping rules.
A simple InfoContributor that exposes a map.
A MappingDescriptionProvider provides a List of mapping descriptions through implementation-specific introspection of an application context.
@Endpoint to expose HTTP request mappings.
Description of an application's request mappings.
Description of an application context's request mappings.
ObjectFactory that can be used to create a MessageInterpolator.
 
Configuration properties for Message Source.
MeterRegistryCustomizer<T extends io.micrometer.core.instrument.MeterRegistry>
Callback interface that can be used to customize auto-configured MeterRegistries.
A meter value that is used when configuring micrometer.
A filter for excluding types from method validation.
Auto-configuration for Micrometer-based metrics.
An @Endpoint for exposing the metrics held by a MeterRegistry.
A set of tags for further dimensional drill-down and their potential values.
Description of a metric.
Description of metric names.
A measurement sample combining a statistic and a value.
@ConfigurationProperties for configuring Micrometer-based metrics.
 
 
 
 
 
 
 
 
 
 
Intercepts Spring Data Repository invocations and records metrics about execution time and results.
Auto-configuration for the Micrometer Tracing API.
Simple server-independent abstraction for mime mappings.
A single mime mapping.
RuntimeException thrown when an endpoint invocation does not contain required parameters.
Exception thrown when there is no WebServerFactory bean of the required type defined in a WebServerApplicationContext.
Annotation that can be used to add mocks to a Spring ApplicationContext.
Container annotation that aggregates several @MockBean annotations.
A BeanFactoryPostProcessor used to register and inject @MockBeans with the ApplicationContext.
Auto-configuration for MockMvc.
A customizer for a ConfigurableMockMvcBuilder.
MVC print options specified from @AutoConfigureMockMvc.
Auto-configuration for HtmlUnit WebClient MockMVC integration.
Auto-configuration for Selenium WebDriver MockMVC integration.
Reset strategy used on a mock bean.
Auto-configuration for MockRestServiceServer support.
RestTemplateCustomizer that can be applied to a RestTemplateBuilder instances to add MockRestServiceServer support.
Auto-configuration for MockWebServiceClient support.
Auto-configuration for MockWebServiceServer support.
TestExecutionListener to verify and reset MockWebServiceServer.
A factory for a blocking MongoClient.
Base class for setup that is common to MongoDB client factories.
Callback interface that can be implemented by beans wishing to customize the MongoClientSettings through a MongoClientSettings.Builder whilst retaining default auto-configuration.
Details required to establish a connection to a MongoDB service.
GridFS configuration.
Auto-configuration for Spring Data's mongo support.
Simple implementation of a HealthIndicator returning status information for Mongo data stores.
Auto-configuration for Mongo metrics.
Configuration properties for Mongo.
 
 
Deprecated, for removal: This API element is subject to removal in a future version.
Auto-configuration for Reactive Mongo.
Auto-configuration for Spring Data's reactive mongo support.
Auto-configuration for Spring Data's Mongo Reactive Repositories.
Auto-configuration for Spring Data's Mongo Repositories.
Configuration properties for Mongo-backed Spring Session.
Auto-configuration for multipart uploads.
Factory that can be used to create a MultipartConfigElement.
Properties to be used in configuring a MultipartConfigElement.
Auto-configuration for Mustache.
 
 
Mustache TemplateLoader implementation that uses a prefix, suffix and the Spring Resource abstraction to load a template from a file, classpath, URL etc.
TemplateAvailabilityProvider that provides availability information for Mustache view templates.
Spring WebFlux View using the Mustache template engine.
Spring MVC View using the Mustache template engine.
Spring WebFlux ViewResolver for Mustache.
Spring MVC ViewResolver for Mustache.
Exception thrown when more than one mutually exclusive configuration property has been configured.
Annotation that can be used to specify the name when binding to an immutable property.
A single named health endpoint contributors (either HealthContributor or ReactiveHealthContributor).
A collection of named health endpoint contributors (either HealthContributor or ReactiveHealthContributor).
Details required to establish a connection to a Neo4j service.
Auto-configuration for Spring Data Neo4j.
Configuration properties for Spring Data Neo4j.
HealthIndicator that tests the status of a Neo4j by executing a Cypher statement and extracting server and database information.
Configuration properties for Neo4j.
 
 
 
 
Auto-configuration for Spring Data's reactive Neo4j support.
ReactiveHealthIndicator that tests the status of a Neo4j by executing a Cypher statement and extracting server and database information.
Auto-configuration for Spring Data's Neo4j Reactive Repositories.
Auto-configuration for Spring Data's Neo4j Repositories.
Meta-annotation that should be added to annotations that indicate a field is a nested type.
Indicates that a field in a @ConfigurationProperties object should be treated as if it were a nested type.
@ConfigurationProperties for the Netty engine.
 
ReactiveWebServerFactory that can be used to create NettyWebServers.
Function that can add new routes to an HttpServerRoutes instance.
RSocketServer that is based on a Reactor Netty server.
RSocketServerFactory that can be used to create RSocketServers backed by Netty.
Mapping function that can be used to customize a Reactor Netty server instance.
WebServer that can be used to control a Reactor Netty web server.
Customization for Netty-specific features.
Auto-configuration for exporting metrics to New Relic.
@ConfigurationProperties for configuring New Relic metrics export.
Adapter to convert NewRelicProperties to a NewRelicConfig.
Condition that will match when none of the nested class conditions match.
Exception thrown when multiple caches exist with the same name.
Exception indicating that an SslBundle was referenced with a name that does not match any registered bundle.
BindHandler to enforce that all configuration properties under the root name have been bound.
Auto-configuration for OAuth2 authorization server support.
Auto-configuration for JWT support for endpoints of the OAuth2 authorization server that require it (e.g.
OAuth 2.0 Authorization Server properties.
A registered client of the Authorization Server.
Authorization Server endpoints.
OpenID Connect 1.0 endpoints.
Client registration information.
Token settings of the registered client.
Auto-configuration for OAuth client support.
OAuth 2.0 client properties.
 
A single client registration.
Deprecated, for removal: This API element is subject to removal in a future version.
since 3.1.0 for removal in 3.3.0 in favor of OAuth2ClientPropertiesMapper
Auto-configuration for OAuth2 resource server support.
OAuth 2.0 resource server properties.
 
 
Object content usually created from AbstractJsonMarshalTester.
AssertJ Assert for ObjectContent.
Auto-configuration for the Micrometer Observation API.
@ConfigurationProperties for configuring Micrometer observations.
 
 
 
 
 
ObservationRegistryCustomizer<T extends io.micrometer.observation.ObservationRegistry>
Callback interface that can be used to customize auto-configured observation registries.
RestTemplateCustomizer that configures the RestTemplate to record request observations.
WebClientCustomizer that configures the WebClient to record request observations.
Condition that checks if the database initialization of a particular component should be considered.
A condition that checks if DevTools should be enabled.
Base endpoint element condition.
MeterFilter to log only once a warning message and deny a Meter.Id.
Condition that checks if a property whose value is a list is defined in the environment.
Auto-configuration for OpenTelemetry.
An operation on an endpoint.
Resolver for an argument of an Operation.
Interface to perform an operation invocation.
Allows additional functionality to be applied to an OperationInvoker.
Information describing an operation method on an endpoint method.
A single operation parameter.
A collection of operation parameters.
Tagging interface used to indicate that an operation result is intended to be returned in the body of the response.
An enumeration of the different types of operation supported by an endpoint.
Manages an optional LiveReloadServer.
ConnectionFactory capable of providing access to the ConnectionFactoryOptions from which it was built.
CharacterEncodingFilter that also implements Ordered.
FormContentFilter that also implements Ordered.
HiddenHttpMethodFilter that also implements Ordered.
HiddenHttpMethodFilter that also implements Ordered.
RequestContextFilter that also implements Ordered.
Interface that uniquely represents the origin of an item.
An interface that may be implemented by an object that can lookup Origin information from a given key.
Interface to provide access to the origin of an item.
OriginLookup backed by a Map containing OriginTrackedValues.
Decorator that can be used to add Origin information to a Resource or WritableResource.
Variant of OriginTrackedResource for WritableResource instances.
A wrapper for an Object value and Origin.
Information about the Operating System the application is running on.
An InfoContributor that exposes OsInfo.
Auto-configuration for exporting metrics to OTLP.
@ConfigurationProperties for configuring OTLP metrics export.
Configuration properties for exporting traces using OTLP.
The outcome of an HTTP request.
JUnit Jupiter @Extension to capture System.out and System.err.
JUnit @Rule to capture output from System.out and System.err.
Annotation that can be used to override @EnableAutoConfiguration.
A ParameterMappingException is thrown when a failure occurs during operation parameter mapping.
Maps parameter values to the required type when invoking an endpoint.
Extension of MetadataNamingStrategy that supports a parent ApplicationContext.
ApplicationContextInitializer for setting the parent context.
ApplicationEvent fired when a parent context is available.
Listener that closes the application context if its parent is closed.
ApplicationListener to close the context.
Abstract base class for TemplateAvailabilityProvider implementations that find templates from paths.
 
Interface that can be implemented by an ExposableEndpoint that is mapped to a root web path.
A collection of path mapped endpoints.
Strategy interface used to provide a mapping between an endpoint ID and the root path where it will be exposed.
Factory that can be used to create a ServerWebExchangeMatcher for commonly used paths.
Factory that can be used to create a RequestMatcher for commonly used paths.
The request matcher used to match against h2 console path.
Ant style pattern based ClassPathRestartStrategy.
SslBundleProperties for PEM-encoded certificates and private keys.
Store properties.
SslStoreBundle backed by PEM-encoded certificates and private keys.
Details for an individual trust or key store in a PemSslStoreBundle.
Annotation that can be used to indicate the format to use when converting a Period.
A standard set of Period units.
Annotation that can be used to change the default unit used when converting a Period.
Auto-configuration for Spring's persistence exception translation.
Default implementation of HealthIndicator that returns Status.UP.
Optional strategy that used by a Binder to resolve property placeholders.
Utility class that can resolve placeholder text with the actual DatabaseDriver platform.
Callback interface that can be implemented by beans wishing to customize PlatformTransactionManagers whilst retaining default auto-configuration.
A PortInUseException is thrown when a web server fails to start due to a port already being in use.
Strategy interface to provide access to a port (which may change if an existing connection is closed).
Producible<E extends Enum<E> & Producible<E>>
Interface that can be implemented by any Enum that represents a finite set of producible mime-types.
Provides access to environment profiles that have either been set directly on the Environment or will be set based on configuration data property values.
Auto-configuration for various project information.
Configuration properties for project information.
Build specific info properties.
Git specific info properties.
Auto-configuration for Prometheus Exemplars with Micrometer Tracing.
Auto-configuration for exporting metrics to Prometheus.
Configuration for Prometheus Pushgateway.
 
@ConfigurationProperties for configuring metrics export to Prometheus.
Configuration options for push-based interaction with Prometheus.
Class that can be used to manage the pushing of metrics to a Prometheus PushGateway.
The operation that should be performed on shutdown.
@Endpoint that outputs metrics in a format that can be scraped by the Prometheus server.
AutoTimer whose behavior is configured by AutoTimeProperties.
Base class for properties to config adapters.
MeterFilter to apply settings from MetricsProperties.
Strategy to load '.properties' files into a PropertySource.
Utility that can be used to map values from a supplied source to a destination.
A source that is in the process of being mapped.
An operation that can be applied to a PropertyMapper.Source.
Indicates that attributes from a test annotation should be mapped into a @PropertySource.
Strategy interface located through SpringFactoriesLoader and used to load a PropertySource.
PlaceholdersResolver to resolve placeholders from PropertySources.
Base class for properties that configure a metrics registry that pushes aggregated metrics on a regular interval.
Base class for PushRegistryProperties to PushRegistryConfig adapters.
Auto-configuration for Quartz Scheduler.
 
Qualifier annotation for a DataSource to be injected into Quartz auto-configuration.
DataSourceScriptDatabaseInitializer for the Quartz Scheduler database.
Endpoint to expose Quartz Scheduler jobs and triggers.
Description of a CalendarIntervalTrigger.
Description of a CronTrigger.
Description of a custom Trigger.
Description of a DailyTimeIntervalTrigger.
Description of group names.
Description of available job and trigger group names.
Description of each group identified by name.
Description of a Quartz Job.
Description of the jobs in a given group.
Description of a Quartz Job.
Description of the triggers in a given group.
 
Description of a SimpleTrigger.
Base class for descriptions of a Trigger.
Configuration properties for QuartzEndpoint.
Configuration properties for the Quartz Scheduler integration.
 
Qualifier annotation for a TransactionManager to be injected into Quartz auto-configuration.
Details required to establish a connection to an SQL service using R2DBC.
Configuration properties for R2DBC.
 
Auto-configuration for Spring Data R2DBC Repositories.
An InitializingBean that initializes a database represented by an R2DBC ConnectionFactory.
Auto-configuration for RabbitTemplate.
 
 
 
Details required to establish a connection to a RabbitMQ service.
A RabbitMQ address.
Configures RabbitConnectionFactoryBean with sensible defaults.
Simple implementation of a HealthIndicator returning status information for the RabbitMQ messaging system.
A MeterBinder for RabbitMQ Java Client metrics.
Auto-configuration for metrics on all available connection factories.
Configuration properties for Rabbit.
 
 
 
 
 
 
Configuration properties for DirectMessageListenerContainer.
 
 
 
Configuration properties for SimpleMessageListenerContainer.
 
 
 
Callback interface that can be used to customize a RetryTemplate used as part of the Rabbit infrastructure.
Define the available target for a RetryTemplate.
Configure RabbitStreamTemplate with sensible defaults.
Configure RabbitTemplate with sensible defaults.
Callback interface that can be used to customize a RabbitTemplate.
PropertySource that returns a random value for any property that starts with "random.".
Auto-configuration to expose actuator endpoints for Cloud Foundry to use in a reactive environment.
Auto-configuration for Spring Data Elasticsearch's reactive client.
Auto-configuration for Spring Data's Elasticsearch Reactive Repositories.
Tagging interface for classes that contribute to health components to the results returned from the HealthEndpoint.
Strategy interface used to contribute Health to the results returned from the reactive variant of the HealthEndpoint.
@ManagementContextConfiguration for reactive web infrastructure when a separate management context with a web server running on a different port is required.
Auto-configuration for Reactive-specific management context concerns.
Auto-configuration for Reactive Spring Security when actuator is on the classpath.
A factory for a reactive MongoClient.
Auto-configuration for multipart support in Spring WebFlux.
Configuration properties for configuring multipart support in Spring Webflux.
Auto-configuration for Spring Security's Reactive OAuth2 client.
Auto-configuration for Reactive OAuth2 resource server support.
Auto-configuration for Spring Security in a reactive application.
Default user @Configuration for a reactive web application.
Interface to provide configuration for a reactive web application.
Encapsulates the merged context configuration declared on a test class and all of its superclasses for a reactive web application.
A GenericReactiveWebApplicationContext that can be used to bootstrap itself from a contained ReactiveWebServerFactory bean.
Factory interface that can be used to create a reactive WebServer.
Auto-configuration for a reactive web server.
WebServerFactoryCustomizer to apply ServerProperties to reactive servers.
Event to be published after the WebServer is ready.
Configurations for Reactor Netty.
 
Mapper that allows for custom modification of a HttpClient before it is used as the basis for a ReactorClientHttpConnector.
Configuration properties for Reactor Netty.
"Readiness" state of the application.
A HealthIndicator that checks the ReadinessState of the application.
Exception thrown if readiness checking has timed out.
Identifies a method on an @Endpoint as being a read operation.
The recordable parts of an HTTP request used when creating an HttpExchange.
The recordable parts of an HTTP response used when creating an HttpExchange.
Auto-configuration for Spring Data's Redis support.
Callback interface that can be used to customize a RedisCacheManager.RedisCacheManagerBuilder.
CacheMeterBinderProvider implementation for Redis.
CacheMeterBinder for RedisCache.
Details required to establish a connection to a Redis service.
Redis cluster configuration.
A node in a sentinel or cluster configuration.
Redis sentinel configuration.
Redis standalone configuration.
Simple implementation of a HealthIndicator returning status information for Redis data stores.
Configuration properties for Redis.
Type of Redis client to use.
Cluster properties.
Jedis client properties.
Lettuce client properties.
 
 
Pool properties.
Redis sentinel properties.
 
Auto-configuration for Spring Data's reactive Redis support.
Auto-configuration for Spring Data's Redis Repositories.
Configuration properties for Redis backed Spring Session.
Strategies for configuring and validating Redis.
Type of Redis session repository to auto-configure.
An OperationInvoker that invokes an operation using reflection.
Base class for Servlet 3.0+ based registration beans.
A mapping description derived from a Registration.
Configuration used to connect to remote Spring Boot applications.
Auto-configuration for remote development support.
Configuration properties for remote Spring Boot applications.
 
 
Application that can be used to establish a link to remotely running Spring Boot code.
Auto-configuration for Spring Data Repository metrics.
Auto-configuration for Spring Data Rest's MVC integration.
Configuration properties for Spring Data REST.
Provides Tags for Spring Data Repository invocations.
Type of Spring Data repositories to enable.
Description of the conditions of a RequestMappingInfo.
Description of the conditions of a RequestMappingInfo.
A description of a MediaTypeExpression in a request mapping condition.
A description of a MediaTypeExpression in a request mapping condition.
A description of a NameValueExpression in a request mapping condition.
A description of a NameValueExpression in a request mapping condition.
Interface that can be used to provide a RequestMatcher that can be used with Spring Security.
TestExecutionListener to reset any mock beans that have been marked with a MockReset.
Banner implementation that prints from a source text Resource.
SpringBootCondition used to check if a resource can be found using a configurable property and optional default location(s).
Callback interface that can be implemented by beans wishing to customize Jersey's ResourceConfig before it is used.
Callback interface that can be used to customize ResourceHandlerRegistration.
ApplicationListener to initialize the Restarter.
Disposable ClassLoader used to support application restarting.
Allows a running application to be restarted with an updated classpath.
Strategy interface used to initialize a Restarter.
Listener that is notified of application restarts.
Restart @Scope Annotation used to indicate that a bean should remain between restarts.
Support for a 'restart' Scope that allows beans to remain between restarts.
Server used to restart the current application with updated ClassLoaderFiles.
Callback interface that can be implemented by beans wishing to further customize the RestClient through a RestClientBuilder whilst retaining default auto-configuration.
Annotation for a Spring rest client test that focuses only on beans that use RestTemplateBuilder.
Identifies a type as being a REST endpoint that is only exposed over Spring MVC or Spring WebFlux.
Auto-configuration for Spring REST Docs.
A MockMvcBuilderCustomizer that configures Spring REST Docs.
A customizer for MockMvcRestDocumentationConfigurer.
Configuration properties for Spring REST Docs.
A customizer for RestAssuredRestDocumentationConfigurer.
A TestExecutionListener for Spring REST Docs that removes the need for a @Rule when using JUnit or manual before and after test calls when using TestNG.
A customizer for WebTestClientRestDocumentationConfigurer.
Builder that can be used to configure and create a RestTemplate.
Configure RestTemplateBuilder with sensible defaults.
Callback interface that can be used to customize a RestTemplate.
Deprecated, for removal: This API element is subject to removal in a future version.
since 3.0.0 for removal in 3.2.0 in favor of DefaultClientRequestObservationConvention
Deprecated, for removal: This API element is subject to removal in a future version.
since 3.0.0 for removal in 3.2.0 in favor of ClientRequestObservationConvention
Callback interface that can be used to customize the ClientHttpRequest sent from a RestTemplate.
Logback Configurator, registered through META-INF/services, that sets the root log level to Level.INFO.
RequestExpectationManager that strips the specified root URI from the request before verification.
UriTemplateHandler to set the root for URI that starts with '/'.
Auto-configuration for RSocketGraphQlClient.
Callback interface that can be used to customize a RSocketMessageHandler.
Auto-configuration for Spring RSocket support in Spring Messaging.
ApplicationContextInitializer that sets Environment properties for the ports that RSocketServer servers are actually listening on.
properties for RSocket support.
 
Auto-configuration for Spring Security for an RSocket server.
Simple interface that represents a fully configured RSocket server.
Choice of transport protocol for the RSocket server.
Auto-configuration for RSocket servers.
Bootstrap an RSocketServer and start it with the application context.
Callback interface that can be used to customize a RSocketServer.
Exceptions thrown by an RSocket server.
Factory interface that can be used to create a reactive RSocketServer.
Event to be published after the application context is refreshed and the RSocketServer is ready.
 
 
Callback interface that can be used to customize codecs configuration for an RSocket client and/or server with RSocketStrategies.
Provides details of a running docker compose service.
Auto-configuration for Spring Security's SAML 2.0 authentication support.
SAML2 relying party properties.
Represents a remote Identity Provider.
Single sign on details for an Identity Provider.
Verification details for an Identity Provider.
 
 
 
Represents a SAML Relying Party.
 
 
 
Single logout details.
Value object that represents the data that can be used by a SanitizingFunction.
Strategy that should be used by endpoint implementations to sanitize potentially sensitive keys.
Function that takes a SanitizableData and applies sanitization to the value, if necessary.
@Endpoint to expose information about an application's scheduled tasks.
Description of a CronTask or a TriggerTask with a CronTrigger.
Description of a TriggerTask with a custom Trigger.
Description of a FixedDelayTask or a TriggerTask with a fixed-delay PeriodicTrigger.
Description of a FixedRateTask or a TriggerTask with a fixed-rate PeriodicTrigger.
Description of an IntervalTask.
Description of a Task's Runnable.
Description of an application's scheduled Tasks.
Base class for descriptions of a Task.
Callback interface that can be implemented by beans wishing to customize the Quartz SchedulerFactoryBean before it is fully initialized, in particular to tune its configuration.
An enumeration of the available schema management options.
Strategy interface to determine the SchemaManagement of a DataSource.
Callback interface that can be used to customize the SdkTracerProviderBuilder that is used to create the auto-configured SdkTracerProvider.
Some named search strategies for beans in the bean factory hierarchy.
Auto-configuration for Spring Security.
Security context in which an endpoint is being invoked.
Automatically adds Spring Security's integration with Spring Data.
Auto-configuration for Spring Security's Filter.
Configuration properties for Spring Security.
 
 
 
 
Response from the Cloud Foundry security interceptors.
A @Selector can be used on a parameter of an @Endpoint method to indicate that the parameter is used to select a subset of the endpoint's data.
Match types that can be used with the @Selector.
Auto-configuration for SendGrid.