All Classes and Interfaces
Class
Description
AbstractApplicationContextRunner<SELF extends AbstractApplicationContextRunner<SELF,C,A>,C extends ConfigurableApplicationContext,A extends ApplicationContextAssertProvider<C>>
Utility design to run an
ApplicationContext and provide AssertJ style
assertions.A Bean registration to be applied when the context loaded.
Abstract
ApplicationListener to handle AuditApplicationEvents.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
BuildLog implementations.Abstract
Command implementation.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.Abstract base class for JAR writers.
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.Abstract base class for
ConfigurableServletWebServerFactory implementations.Base class for
@ConfigurationProperties of a
AbstractTemplateViewResolver.Base class for
@ConfigurationProperties of a
ViewResolver.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.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.
A base class for
AST transformations that are solely
interested in AnnotatedNodes.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.Utility for working with
AnsiColor in the context of AWT Colors.Bit depths supported by this class.
An ANSI encodable element.
Generates ANSI encoded output, automatically attempting to detect if the terminal
supports ANSI.
Possible values to pass to
AnsiOutput.setEnabled(org.springframework.boot.ansi.AnsiOutput.Enabled).An
ApplicationListener that configures AnsiOutput depending on the
value of the property spring.output.ansi.enabled.Ansi styles.RequestMatcherProvider that provides an AntPathRequestMatcher.Condition that will match when any nested class condition matches.Auto-configuration for Spring's AOP support.Entry point for AOT processing of a
SpringApplication.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.ContentFilter that matches application items based on an Ant-style path
pattern.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.ApplicationContext backed RequestMatcher.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.An archive that can be launched by the
Launcher.Represents a single entry in the archive.
Strategy interface to filter
Entries.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.
A resolver for artifacts' Maven coordinates, allowing group id, artifact id, or version
to be obtained from a module identifier.
An
ApplicationContext that additionally supports AssertJ style assertions.A
ReactiveWebApplicationContext that additionally supports AssertJ style
assertions.A
WebApplicationContext that additionally supports AssertJ style assertions.General purpose AST utilities.
Auto-configuration for exporting metrics to Atlas.@ConfigurationProperties for configuring Atlas metrics
export.Spring
ApplicationEvent to encapsulate AuditEvents.Auto-configuration for 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.A description of an application's
audit events.Auto-configuration for the AuditEventsEndpoint.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.DeferredImportSelector to handle auto-configuration.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.Annotation processor to store certain annotations from auto-configuration classes in a
property file.
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 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.
Annotation that can be applied to a test class to enable auto-configuration for metrics
exporters.
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.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
BatchConfigurer implementation.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.Qualifier annotation for a DataSource to be injected into Batch auto-configuration.
DataSourceScriptDatabaseInitializer for the Spring Batch database.Configuration properties for Spring Batch.
Available transaction isolation levels.
An
AbstractFailureAnalyzer that performs analysis of failures caused by a
BeanNotOfRequiredTypeException.@Endpoint to expose details of an application's beans, grouped by
application context.A description of an application's beans, primarily intended for serialization to
JSON.
A description of a bean in an application context, primarily intended for
serialization to JSON.
A description of an application context, primarily intended for serialization to
JSON.
Auto-configuration for the BeansEndpoint.Source that can be bound by a
Binder.Restrictions that can be applied when binding values.
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.Volume bindings to apply when creating a container.
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 a 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.Auto-configuration for Brave.ApplicationStartup implementation that buffers steps and
records their timestamp as well as their processing time.Central API for running buildpack operations.
Exception thrown to indicate a Builder error.
An
InfoContributor that exposes BuildProperties.Callback interface used to provide
Builder output logging.An opaque reference to a
Buildpack.Provide build-related information such as group and artifact.
A
BuildPropertiesWriter writes the build-info.properties for
consumption by the Actuator.Exception thrown when an additional property with a null value is encountered.
Build-system agnostic details of a project.
A build request to be handled by the
Builder.Details of a cache for use by the CNB builder.
The format of the cache.
Details of a cache stored in a Docker volume.
Callback interface that can be implemented by beans wishing to customize the default
setup for caches added to the manager via 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.
JCache (JSR-107) specific cache properties.
Redis-specific cache properties.
Basic description of a
Cache, primarily intended for serialization to JSON.Description of a
Cache, primarily intended for serialization to JSON.Description of a
CacheManager, primarily intended for serialization to
JSON.A report of available
caches, primarily intended for serialization to
JSON.@EndpointWebExtension for the CachesEndpoint.Supported cache types (defined in order of precedence).
CompilerAutoConfiguration for the caching infrastructure.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.Runtime exception that materializes a
cancel signal for the WebFlux server metrics instrumentation.Provides access to
System.out and System.err
output that has been captured by the OutputCaptureExtension or
OutputCaptureRule.Auto-configuration for Cassandra.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.An
SslStoreProvider that creates key and trust stores from certificate and
private key PEM files.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.
A supplier for
ClientHttpRequestFactory that detects the preferred candidate
based on the available implementations on the classpath.Callback interface that can be implemented by beans wishing to customize the
ClientResources via 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 via 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.A single command that can be run from the CLI.
JLine
Completer for Spring Boot Commands.Runtime exception wrapper that defines additional
CommandException.Options that are understood
by the CommandRunner.Specific options understood by the
CommandRunner.Factory used to create CLI
Commands.Interface used to indicate that a bean should run when it is contained within
a
SpringApplication.Main class used to run
Commands.DataSourcePoolMetadata for an Apache Commons DBCP2 DataSource.Strategy that can be used to apply some auto-configuration during the
CompilePhase.CONVERSION Groovy compile phase.An
OptionHandler for commands that result in the compilation of one or more
Groovy scripts.A
DataSourcePoolMetadataProvider implementation that returns the first
DataSourcePoolMetadata that is found by one of its delegate.DependencyManagement that delegates to one or more DependencyManagement
instances.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.Composite
ProxySelector.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 or not a default health indicator
is enabled.@Conditional that checks whether or not an info contributor is
enabled.@Conditional that checks whether or not a metrics exporter is
enabled.@Conditional that checks whether or not the Spring resource
handling chain is enabled.Configuration annotation for a conditional element that depends on the value of a SpEL
expression.
@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 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.ApplicationContextInitializer that writes the ConditionEvaluationReport
to the log.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.
@Endpoint to expose the ConditionEvaluationReport.A description of an application's condition evaluation, primarily intended for
serialization to JSON.
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 via 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.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.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 via the
BootstrapRegistry interface.ConfigurableWebServerFactory for Jetty-specific features.Interface to provide configuration for a reactive web application.
Specialization of
ConfigurableEnvironment for reactive application contexts.Configurable
ReactiveWebServerFactory.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.
Auto-configuration for
@ConfigurationProperties beans.Provides access to
@ConfigurationProperties bean
details, regardless of if the annotation was used directly or on a @Bean
factory method.The binding method that is used for the bean.
BindConstructorProvider used when binding
@ConfigurationProperties.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.A description of an application's
@ConfigurationProperties beans.A description of a
@ConfigurationProperties bean.A 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.A source of
ConfigurationProperties.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.BeanDefinitionRegistryPostProcessor to report warnings.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.Callback interface that can be implemented by beans wishing to customize the
ConnectionFactoryOptions via a ConnectionFactoryOptions.Builder whilst retaining default
auto-configuration.A
MeterBinder for a ConnectionPool.Auto-configuration for metrics on all available
R2DBC connection factories.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.
Configuration used when creating a new container.
Update class used to change data when creating a container config.
Additional content that can be written to a created container.
A reference to a Docker container.
Status details returned from
Docker container wait.Content with a known size that can be written to an
OutputStream.Callback interface that can be used to filter layer contents.
Strategy used by
CustomLayers to select the layer of an item.Callback interface used to process an
ApplicationContext with the ability to
throw a (checked) exception.ApplicationContextInitializer that sets the Spring
ApplicationContext ID.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.ParameterValueMapper backed by a ConversionService.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.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 via a CqlSessionBuilder whilst retaining default
auto-configuration.Identifying information about the tooling that created a builder.
Custom
Layers implementation where layer content is selected by the user.Additional interface that can be implemented by
Layouts that write their
own loader classes.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.Default implementation of
CommandFactory.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.Configure
DefaultJmsListenerContainerFactory with sensible defaults.Callback interface for customizing
DefaultKafkaConsumerFactory beans.Callback interface for customizing
DefaultKafkaProducerFactory beans.Default implementation of
LaunchScript.Default implementation of
LayoutFactory.MapPropertySource containing default properties contributed directly to a
SpringApplication.Default
ReactiveHealthContributorRegistry implementation.A
RepositorySystemSessionAutoConfiguration that, in the absence of any
configuration, applies sensible defaults.Default
RepositoryTagsProvider implementation.Default
RestartInitializer that only enable initial restart when running a
standard "main" method.Default implementation of
RestTemplateExchangeTagsProvider.Default implementation of
SourceDirectoryUrlFilter that attempts to match URLs
using common naming conventions.Callback interface trigger from
SpringBootTestContextBootstrapper that can be
used to post-process the list of default TestExecutionListener classes to be
used by a test.Annotation that can be used to specify the default value when binding to an immutable
property.
Default implementation of
WebClientExchangeTagsProvider.Default implementation of
WebFluxTagsProvider.Default implementation of
WebMvcTagsProvider.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.
A single dependency.
A dependency exclusion.
ASTTransformation to apply
dependency
auto-configuration.Customizer that allows dependencies to be added during compilation.
An encapsulation of dependency management information.
Provides one or more additional sources of dependency management that is used when
resolving
@Grab dependencies.ASTTransformation for processing
@DependencyManagementBom annotations.Context used when resolving dependencies.
Thrown to indicate a failure during dependency resolution.
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.Auto-configuration for the Spring
DispatcherServlet.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.ServletRegistrationBean for the auto-configured 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 access to the limited set of Docker APIs needed by pack.
Docker configuration options.
Exception thrown when connection to the Docker daemon fails.
Exception thrown when a call to the Docker API fails.
Docker host connection options.
Docker registry authentication configuration.
A
Socket implementation for Linux of BSD domain sockets.Callback interface that can be implemented by beans wishing to customize the
DriverConfigLoader via 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 Spring Data's Elasticsearch
support.Configuration properties for Elasticsearch.
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.Configuration properties specific to Elasticsearch's
RestClient and
RestHighLevelClient.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.Pseudo annotation used to trigger
GroovyTemplatesCompilerAutoConfiguration.Command to encode passwords for use with Spring Security.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.
Auto-configuration for @Endpoint
support.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.
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.Interface used to write jar entry data.
Provides access to environment variable values.
@Endpoint to expose environment
information.A description of an
Environment.A description of an entry of the
Environment.A description of a
PropertySource.A description of a particular entry of
PropertySource.A summary of a particular entry of the
Environment.A description of a property's value, including its origin if available.
Auto-configuration for the EnvironmentEndpoint.Configuration properties for
EnvironmentEndpoint.@EndpointWebExtension for the 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 via 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.Filter that intercepts error dispatches to ensure authorized access to the
error page.Configuration properties for web error handling.
Include error attributes options.
Include Stacktrace attribute options.
Errors returned from the Docker API.
An individual Docker error.
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 via a WebFlux
WebExceptionHandler.SpringApplicationRunListener to publish SpringApplicationEvents.Base class for executable archive
Launchers.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.Encapsulation of the outcome of a command.
Archive implementation backed by an exploded archive directory.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.
Extension of the
GroovyClassLoader with support for obtaining '.class' files as
resources.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.Utilities for dealing with file permissions and attributes.
Watches specific directories for file changes.
Factory used to create new
FileSystemWatcher instances.Utilities for manipulating files and directories in Spring Boot tooling.
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.Custom
MethodValidationPostProcessor that applies
exclusion filters.A
ServletContextInitializer to register Filters in a Servlet 3.0+
container.A
RegistrationMappingDescription derived from a FilterRegistration.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.
Qualifier annotation for a DataSource to be injected in to Flyway.
@Endpoint to expose flyway info.Description of an application's
Flyway beans, primarily intended for
serialization to JSON.Description of an application context's
Flyway beans, primarily intended
for serialization to JSON.Description of a
Flyway bean, primarily intended for serialization to JSON.Details of a migration performed by Flyway.
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.A base class that lets plugin authors easily add additional BOMs to all apps.
Subclass of
GenericApplicationContext, suitable for reactive web environments.An
InfoContributor that exposes GitProperties.Provide git-related information such as commit id and time.
Command to grab the dependencies of one or more Groovy scripts.A callback for the result of a graceful shutdown request.
The result of a graceful shutdown request.
Utility to install a specific
Grape engine with Groovy.Honours the configuration of
grape.root by customizing the session's local
repository location.Auto-configuration for exporting metrics to Graphite.@ConfigurationProperties for configuring Graphite
metrics export.ASTTransformation to resolve beans declarations inside application source
files.Compiler for Groovy sources.
Configuration for the
GroovyCompiler.The scope in which a groovy compiler operates.
Helpful utilities for working with Groovy
Templates.Auto-configuration support for Groovy templates in MVC.
TemplateAvailabilityProvider that provides availability information for Groovy
view templates.@ConfigurationProperties for configuring Groovy
templates.CompilerAutoConfiguration for Groovy Templates (outside MVC).Auto-configuration for Gson.Callback interface that can be implemented by beans wishing to further customize the
Gson via 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.
URLStreamHandler for Spring Boot loader JarFiles.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.
@EndpointWebExtension for the HealthEndpoint.Strategy interface used to contribute
Health to the results returned from the
HealthEndpoint.Properties used to configure the health endpoint and endpoint groups.
Options for showing items in responses from the
HealthEndpoint web
extensions.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.Internal
Command used for 'help' requests.An example that can be displayed in the help.
Auto-configuration for Hibernate JPA.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.
DataSourcePoolMetadata for a Hikari DataSource.Internal
Command to provide hints for shell auto-completion.Simple server-independent abstraction for HTTP/2 configuration.
Auto-configuration for HTTP client-related metrics.Strategy used to map a
health status to an HTTP status code.Auto-configuration for configuring the encoding to use
in web applications.Traces an HTTP request-response exchange.
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.Adapts
HttpRestartServer to a Handler.Handler that responds with a specific HttpStatus.A trace event for handling of an HTTP request and response exchange.
Principal associated with an HTTP request-response exchange.
Trace of an HTTP request.
Trace of an HTTP response.
Session associated with an HTTP request-response exchange.
Auto-configuration for HTTP tracing.A description of an application's
HttpTrace entries.Auto-configuration for the HttpTraceEndpoint.Servlet
Filter that logs all requests to an HttpTraceRepository.Configuration properties for HTTP tracing.
A repository for
HttpTraces.A
WebFilter for tracing HTTP requests.HTTP transport used for docker access.
An HTTP operation response.
TunnelConnection implementation that uses HTTP to transfer data.Encapsulates a payload data sent via 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.Image details as returned from
Docker inspect.An image archive that can be loaded into Docker.
Update class used to change data when creating an image archive.
Image configuration information.
Update class used to change data when creating a copy.
A Docker image name of the form "docker.io/library/ubuntu".
Utility class that can be used to export a fully packaged archive to an OCI image.
A
ProgressUpdateEvent fired for image events.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.Exception thrown when an attempt is made to resolve a property against an inactive
ConfigData property source.Include options for HTTP tracing.
Exception thrown when the application has configured an incompatible set of
ConfigurationProperties keys.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.
Auto-configuration for standard
InfoContributors.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.Auto-configuration for the InfoEndpoint.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.
Command that initializes a project using Spring initializr.In-memory
AuditEventRepository implementation.In-memory implementation of
HttpTraceRepository.Content that is reads and inspects a source of data only once but allows it to
be consumed multiple times.Interface that can be used to inspect content as it is initially read.
Command to install additional dependencies into the CLI.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.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.BiConsumer that can safely throw
IO exceptions.Consumer that can safely throw
IO exceptions.Supplier that can safely throw
IO exceptions.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 via Jackson2ObjectMapperBuilder retaining its default
auto-configuration.Auto configuration for Jackson.
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.
Command to create a self-contained executable jar file from a CLI application.Extended variant of
JarFile that behaves in the same way but
offers the following additional functionality.Launcher for JAR based archives.Interface registered in
spring.factories to provides extended 'jarmode'
support.Delegate class used to launch the fat jar in a specific mode.
Library implementation for internal jarmode jars.Writes JAR content, ensuring valid directory entries are always created and duplicate
items are ignored.
Provides access to the java binary executable, regardless of OS.
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.
CompilerAutoConfiguration for Spring 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.
Callback interface that can be implemented by beans wishing to customize the
JedisClientConfiguration via a JedisClientConfiguration.JedisClientConfigurationBuilder whilst retaining default
auto-configuration.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
JettyServletWebServerFactory.Auto-configuration for Spring JMS.CompilerAutoConfiguration for Spring JMS.HealthIndicator for a JMS ConnectionFactory.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.Exports
JMX endpoints to a MBeanServer.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.Auto-configuration for JOOQ.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.A
BasicBatchConfigurer tailored 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.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.Factory to create a
JsonParser.Utility class that allows JSON to be parsed and processed as it's received.
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 JTA.Auto-configuration for JVM metrics.Auto-configuration for Apache Kafka.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.
ClassLoader used by the Launcher.Base class for launchers that can start an application with a fully configured
classpath backed by one or more
Archives.A script that can be prepended to the front of a JAR file to make it executable.
A layer that can be written to an
ImageArchive.A named layer used to separate the jar when creating a Docker image.
A layer ID as used inside a Docker image of the form
algorithm: hash.Interface to provide information about layers to the
Repackager.Index describing the layer to which each entry in a jar belongs.
Interface that can be used to write a file/directory layout.
Strategy interface used to determine the layout for a particular type of archive.
Factory interface used to create a
Layout.Common
Layouts.Executable expanded archive layout.
Executable JAR layout.
No layout.
Executable WAR layout.
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.Auto-configuration for LDAP.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 via a LettuceClientConfiguration.LettuceClientConfigurationBuilder whilst retaining default
auto-configuration.Auto-configuration for Lettuce metrics.
Encapsulates information about libraries that may be packed into the archive.
Encapsulates information about a single library that may be packed into the archive.
Callback interface used to iterate
Libraries.ContentFilter that matches Library items based on a coordinates
pattern.Encapsulates information about the artifact coordinates of a library.
The scope of a library.
Auto-configuration relating to the application
context's lifecycle.Configuration properties for lifecycle processing.
Details for a link in a
HAL-formatted
response.
Auto-configuration for Liquibase.Qualifier annotation for a DataSource to be injected in to Liquibase.
@Endpoint to expose liquibase info.Description of an application's
SpringLiquibase beans, primarily intended
for serialization to JSON.A Liquibase change set.
A context expression in a
LiquibaseEndpoint.ChangeSet.Description of an application context's
SpringLiquibase beans, primarily
intended for serialization to JSON.Description of a
SpringLiquibase bean, primarily intended for serialization
to JSON.Configuration properties to configure
SpringLiquibase."Liveness" state of the application.
A
HealthIndicator that checks the LivenessState of the application.A livereload server.
Writer used by
CustomLoaderLayouts to write classes into a
repackaged JAR.A
ProgressUpdateEvent fired as an image is loaded.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.
Simple logger used by the CLI.
LoggingSystem for Log4j 2.LoggingSystemFactory that returns Log4J2LoggingSystem if possible.Auto-configuration for Log4J2 metrics.
Utility to initialize logback (when present) to use INFO level logging.
LoggingSystem for logback.LoggingSystemFactory that returns LogbackLoggingSystem if possible.LoggingSystemProperties for Logback.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.A single logger group.
Logger groups configured via the Spring Environment.
@Endpoint to expose a collection of LoggerConfigurations.Levels configured for a given logger exposed in a JSON friendly way.
Auto-configuration for the LoggersEndpoint.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.An update event used to provide log updates.
Stream types supported by the event.
A
HandlerInterceptor that supports Micrometer's long task timers configured on
a handler using @Timed with longTask set to
true.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.Finds any class with a
public static main method by performing a breadth first
search.Utility class that is used by
Launchers to call a main method.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.
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.Base class for mapped JSON objects.
Strategy used to read JSON content.
A
MappingDescriptionProvider provides a List of mapping descriptions
via implementation-specific introspection of an application context.@Endpoint to expose HTTP request mappings.A description of an application's request mappings.
A description of an application context's request mappings.
DependencyManagement derived from a Maven Model.A
GrapeEngine implementation that uses
Maven Resolver, the
dependency resolution system used by Maven.Utility class to create a pre-configured
MavenResolverGrapeEngine.An encapsulation of settings read from a user's Maven settings.xml.
MavenSettingsReader reads settings from a user's Maven settings.xml file,
decrypting them if necessary using settings-security.xml.A message returned from the Docker API.
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.
Response payload for a metric name listing.
Response payload for a metric name selector.
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.RestTemplateCustomizer that configures the RestTemplate to record
request metrics.WebClientCustomizer that configures the WebClient to record request
metrics.ExchangeFilterFunction applied via a MetricsWebClientCustomizer to
record metrics.Intercepts incoming HTTP requests handled by Spring WebFlux handlers 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.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.Auto-configuration for Mongo.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 via a MongoClientSettings.Builder whilst retaining default auto-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.
A
MongoClientSettingsBuilderCustomizer that applies properties from a
MongoProperties to a MongoClientSettings.Auto-configuration for Reactive Mongo.Auto-configuration for Spring Data's reactive mongo
support.A
ReactiveHealthIndicator for Mongo.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.@ConfigurationProperties 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).A
Socket implementation for named pipes.Auto-configuration for Neo4j.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.Indicates that a field in a
@ConfigurationProperties
object should be treated as if it were a nested type.Auto-configuration for Netty.@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.Exception used to when the help command is called without arguments.
Condition that will match when none of the nested class conditions match.Exception thrown when multiple caches exist with the same name.
Exception thrown when multiple
SessionRepository implementations are available
with no way to know which implementation should be used.Exception used when a command is not found.
BindHandler to enforce that all configuration properties under the root name
have been bound.Auto-configuration for OAuth client support.OAuth 2.0 client properties.
A single client registration.
Adapter class to convert
OAuth2ClientProperties to a
ClientRegistration.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.ObservationRegistryCustomizer<T extends io.micrometer.observation.ObservationRegistry>
Callback interface that can be used to customize auto-configured
observation registries.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.An enumeration of the different types of operation supported by an endpoint.
Manages an optional
LiveReloadServer.Delegate used by
OptionParsingCommand to parse options and run the command.Help for a specific option.
Base class for a
Command that parse options using an OptionHandler.ConnectionFactory capable of providing access to the
ConnectionFactoryOptions from which it was built.Simple adapter class to present an
OptionSet as a
GroovyCompilerConfiguration.DataSourcePoolMetadata for an Oracle UCP DataSource.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.
Variant of
OriginTrackedResource for WritableResource instances.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.The outcome of an HTTP request.
JUnit
@Rule to capture output from System.out and System.err.Annotation that can be used to override
@EnableAutoConfiguration.A user and group ID that can be used to indicate file ownership.
A launcher for a CLI application that has been compiled and packaged as a jar file.
Abstract base class for packagers.
Callback interface used to present a warning when finding the main class takes too
long.
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.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).
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.An
UpdateEvent that includes progress information.Provide details about the progress of a task.
Auto-configuration for various project information.Configuration properties for project information.
Build specific info properties.
Git specific info properties.
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.Base class for properties to config adapters.
Launcher for archives with user-configured classpath and main class via a
properties file.MeterFilter to apply settings from MetricsProperties.An
ApplicationListener that inspects the environment for configuration keys that need to be migrated.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 via
SpringFactoriesLoader and used to load a
PropertySource.Origin from a PropertySource.PlaceholdersResolver to resolve placeholders from PropertySources.A
ProgressUpdateEvent fired as an image is pulled.Image pull policy.
A
ProgressUpdateEvent fired as an image is pushed to a registry.Details of an error embedded in a response stream.
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.A description of a
CalendarIntervalTrigger.A description of a
CronTrigger.A description of a custom
Trigger.A description of a
DailyTimeIntervalTrigger.A set of group names, primarily intended for serialization to JSON.
A summary for each group identified by name, primarily intended for serialization
to JSON.
Details of a
Quartz Job, primarily intended for serialization to JSON.A summary report of the
jobs in a given group.Details of a
Quartz Job, primarily intended for serialization to JSON.A report of available job and trigger group names, primarily intended for
serialization to JSON.
A summary report of the
triggers in a given group.A description of a
SimpleTrigger.Base class for descriptions of a
Trigger.@EndpointWebExtension for the QuartzEndpoint.Configuration properties for the Quartz Scheduler integration.
Qualifier annotation for a TransactionManager to be injected into Quartz
auto-configuration.
Auto-configuration for 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.CompilerAutoConfiguration for Spring Rabbit.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.Interface that provides read-only random access to some underlying data.
RandomAccessData implementation backed by a RandomAccessFile.PropertySource that returns a random value for any property that starts with
"random.".EnvironmentPostProcessor to add the RandomValuePropertySource.Auto-configuration to expose actuator endpoints for
Cloud Foundry to use in a reactive environment.Auto-configuration for Spring Data's Elasticsearch
Reactive Repositories.Auto-configuration for Elasticsearch Reactive REST
clients.Configuration properties for Elasticsearch Reactive REST clients.
Tagging interface for classes that contribute to
health
components to the results returned from the HealthEndpoint.Reactive
@EndpointWebExtension for 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.Registers a
WebServerFactoryCustomizerBeanPostProcessor.WebServerFactoryCustomizer to apply ServerProperties to reactive
servers.Event to be published after the
WebServer is ready.Mapper that allows for custom modification of a
HttpClient before it is used as
the basis for a ReactorClientHttpConnector."Readiness" state of the application.
A
HealthIndicator that checks the ReadinessState of the application.Identifies a method on an
@Endpoint as being a read operation.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.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.A
ReactiveHealthIndicator for Redis.Auto-configuration for Spring Data's Redis
Repositories.Configuration properties for Redis backed Spring Session.
Strategies for configuring and validating Redis.
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.
Utility class that can be used to repackage an archive so that it can be executed using
'java -jar'.
A specialization of
Layout that repackages an existing archive by moving its
content to a new location.Exception with a message that can be reported to the user.
The configuration of a repository.
Factory used to create
RepositoryConfigurations.Auto-configuration for Spring Data Repository metrics.Auto-configuration for Spring Data Rest's MVC
integration.Configuration properties for Spring Data REST.
Strategy that can be used to apply some auto-configuration during the installation of a
MavenResolverGrapeEngine.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.Resolves a
DockerHost from the environment, configuration, or using defaults.ASTTransformation to resolve @Grab artifact coordinates.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 used to customize
ResourceHandlerRegistration.Utilities for manipulating resource paths and URLs.
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 via 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.Factory methods for creating
Tags related to a request-response exchange
performed by a RestTemplate.Provides
Tags for an exchange performed by a RestTemplate.Callback interface that can be used to customize the
ClientHttpRequest sent
from a RestTemplate.RequestExpectationManager that strips the specified root URI from the request
before verification.UriTemplateHandler to set the root for URI that starts with '/'.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.Command to 'run' a groovy script or scripts.Utility used to run a process.
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.A description of a
TriggerTask with a custom Trigger.A description of an
IntervalTask.A report of an application's scheduled
Tasks, primarily intended for
serialization to JSON.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.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.
ManagementContextConfiguration that configures the appropriate
RequestMatcherProvider.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.@ConfigurationProperties for SendGrid.ApplicationContextInitializer that sets Environment properties for the
ports that WebServer servers are actually listening on.@ConfigurationProperties for a web server (e.g.Strategies for supporting forward headers.
Jetty properties.
Jetty access log properties.
Log format for Jetty access logs.
Jetty thread properties.
Netty properties.
Reactive server properties.
Servlet server properties.
Tomcat properties.
Tomcat access log properties.
Tomcat static resource properties.
Tomcat thread properties.
Undertow properties.
Undertow access log properties.
Undertow thread properties.
A boundary for a service-level objective (SLO) for use when configuring Micrometer.
ApplicationContextInitializer for setting the servlet context.Interface used to configure a Servlet 3.0+
context
programmatically.A collection
ServletContextInitializers obtained from a
ListableBeanFactory.Adapter to convert a given Bean type into a
RegistrationBean (and hence a
ServletContextInitializer).Jetty
Configuration that calls ServletContextInitializers.Identifies a type as being an endpoint that supplies a servlet to expose.
@ManagementContextConfiguration for servlet
endpoints.ServletContextInitializer to register servlet
endpoints.A
ServletContextInitializer to register EventListeners in a Servlet
3.0+ container.Auto-configuration for Servlet-specific management
context concerns.A
ServletContextInitializer to register Servlets in a Servlet 3.0+
container.A mapping description derived from a
ServletRegistration.A
MappingDescriptionProvider that describes that mappings of any Servlets registered with a ServletContext.A
WebApplicationContext that can be used to bootstrap itself from a contained
ServletWebServerFactory bean.Utility class to store and restore any user defined scopes.
Factory interface that can be used to create a
WebServer.Auto-configuration for servlet web servers.Registers a
WebServerFactoryCustomizerBeanPostProcessor.WebServerFactoryCustomizer to apply ServerProperties and
WebListenerRegistrars to servlet web servers.Event to be published after the
WebServer is ready.Session properties.
Session cookie properties.
Available session tracking modes (mirrors
SessionTrackingMode.Auto-configuration for Spring Session.Configuration properties for Spring Session.
Servlet-related properties.
Exception thrown when no
SessionRepository is available.@Endpoint to expose a user's Sessions.A description of user's
session.A report of user's
sessions.Auto-configuration for a RepositorySystemSession that uses Maven's settings.xml to
determine the configuration settings.
Provides access to a shared pre-configured
ObjectMapper.A shell for Spring Boot.
Command to start a nested REPL shell.Exception used to stop the
Shell.Abstraction to manage a stack of prompts.
Configuration for shutting down a
WebServer.@Endpoint to shutdown the ApplicationContext.Auto-configuration for the ShutdownEndpoint.Auto-configuration for exporting metrics to SignalFX.@ConfigurationProperties for configuring metrics export
to SignalFX.Adapter to convert
SignalFxProperties to a SignalFxConfig.Utilities for working with signal handling.
Simple 'Java Logging'
Formatter.Simple
HttpCodeStatusMapper backed by map of status
code to HTTP status code.A simple
InfoContributor that exposes a single detail.Auto-configuration for exporting metrics to a
SimpleMeterRegistry.@ConfigurationProperties for configuring metrics export
to a SimpleMeterRegistry.Adapter to convert
SimpleProperties to a SimpleConfig.Configure
SimpleRabbitListenerContainerFactoryConfigurer with sensible
defaults.StatusAggregator backed by an ordered status list.Enum used to control when
@PropertyMapping is skipped.Repository used by
FileSystemWatcher to save file/directory snapshots across
restarts.Socket based
TargetServerConnection.Filter URLs based on a source directory name.
Extract source file options (anything following '--' in an
OptionSet).Class that can be used to bootstrap and launch a Spring application from a Java main
method.
Register a JMX component that allows to administer the current application.
An MBean contract to control and monitor a running
SpringApplication via JMX.Register a
SpringApplicationAdminMXBean implementation to the platform
MBeanServer.Builder for
SpringApplication and ApplicationContext instances with
convenient fluent API and context hierarchy support.Base class for
ApplicationEvent related to a SpringApplication.An
EnvironmentPostProcessor that parses JSON from
spring.application.json or equivalently SPRING_APPLICATION_JSON and
adds it as a map property source to the Environment.A launcher for
SpringApplication or a SpringApplication subclass.Listener for the
SpringApplication run method.Compiles Groovy code running the resulting classes using a
SpringApplication.Configuration for the
SpringApplicationRunner.Interface that can be used to add or remove code that should run when the JVM is
shutdown.
SpringBootServletInitializer for CLI packaged WAR files.CompilerAutoConfiguration for Spring Batch.Indicates a
configuration class that declares one or more
@Bean methods and also triggers auto-configuration and component scanning.Marker interface for AST transformations that should be installed automatically from
META-INF/services.CompilerAutoConfiguration for Spring.Base of all
Condition implementations used with Spring Boot.Indicates that a class provides Spring Boot application
@Configuration.Spring Boot
ConfigurationFactory that customizes Log4J2's default configuration
to:
Prevent logger warnings from being printed when the application first starts.A
ContextLoader that can be used to test Spring Boot applications (those that
normally startup using SpringApplication).DependencyManagement derived from the effective pom of
spring-boot-dependencies.Alternative
DependencyInjectionTestExecutionListener prints the
ConditionEvaluationReport when the context cannot be prepared.Callback interface used to support custom reporting of
SpringApplication
startup errors.MockMvcBuilderCustomizer for a typical Spring Boot application.A
MockResolver for testing Spring Boot applications with Mockito.MockServletContext implementation for Spring Boot.Spring Boot
PropertySource that disables Log4j2's shutdown hook.An opinionated
WebApplicationInitializer to run a SpringApplication
from a traditional WAR deployment.Annotation that can be specified on a test class that runs Spring Boot based tests.
An enumeration web environment modes.
TestContextBootstrapper for Spring Boot.Exposes the Spring Boot version.
WebTestClientBuilderCustomizer for a typical Spring Boot application.Spring Command Line Interface.
Auto-configuration for Spring Data's web support.Configuration properties for Spring Data Web.
Pageable properties.
Sort properties.
Hibernate
ImplicitNamingStrategy that follows Spring recommended naming
conventions.CompilerAutoConfiguration for Spring Integration.Generic Hibernate
AbstractJtaPlatform implementation that simply resolves the
JTA UserTransaction and TransactionManager from the Spring-configured
JtaTransactionManager implementation.CompilerAutoConfiguration for Spring MVC.CompilerAutoConfiguration for Spring Retry.CompilerAutoConfiguration for Spring Security.CompilerAutoConfiguration for Spring Test.Allows Spring Transaction to be used with JOOQ.
CompilerAutoConfiguration for Spring Websocket.Annotation that can be used to apply Mockito spies to a Spring
ApplicationContext.Container annotation that aggregates several
@SpyBean annotations.DataSourceScriptDatabaseInitializer for the primary SQL database.Auto-configuration for initializing an SQL database.Configuration properties for initializing an SQL
database.R2dbcScriptDatabaseInitializer for the primary SQL database.Simple server-independent abstraction for SSL configuration.
Client authentication types.
Provides utilities around SSL.
Builds an
SSLContext for use with an HTTP connection.Deprecated.
this class is meant for Spring Boot internal use only.
Interface to provide SSL key stores for an
WebServer to use.Auto-configuration for exporting metrics to
Stackdriver.@ConfigurationProperties for configuring Stackdriver
metrics export.Adapter to convert
StackdriverProperties to a StackdriverConfig.AnnotationCustomizableTypeExcludeFilter that can be used to any test annotation
that uses the standard includeFilters, excludeFilters and
useDefaultFilters attributes.ConfigDataLoader for Resource backed locations.ConfigDataLocationResolver for standard locations.ConfigDataResource backed by a Resource.Base class for the standard set of
Layers.Environment implementation to be used by Reactive-based web
applications.@Endpoint to expose the timeline of the
application startup.A description of an application startup, primarily intended for serialization to
JSON.
Auto-configuration for the StartupEndpoint.Represent the timeline of
steps recorded by
BufferingApplicationStartup.Event on the current
StartupTimeline.Binds application startup metrics in response to
ApplicationStartedEvent and
ApplicationReadyEvent.Auto-configuration for startup time metrics.PortProvider for a static port that won't change.Common locations for static resources.
Used to create a
ServerWebExchangeMatcher for static resources in commonly used
locations.Used to create a
RequestMatcher for static resources in commonly used
locations.The request matcher used to match against resource
Locations.The server web exchange matcher used to match against resource
locations.Auto-configuration for exporting metrics to StatsD.@ConfigurationProperties for configuring StatsD metrics
export.Adapter to convert
StatsdProperties to a StatsdConfig.Value object to express state of a component or subsystem.
Strategy used to aggregate
Status instances.PushRegistryProperties extensions for registries that are step-normalized.Base class for
StepRegistryProperties to StepRegistryConfig adapters.Supported Spring Session data store types.
Callback interface for customizing
StreamsBuilderFactoryBean beans.Origin for an item loaded from the system environment.An
EnvironmentPostProcessor that replaces the systemEnvironment
SystemEnvironmentPropertySource with an
SystemEnvironmentPropertySourceEnvironmentPostProcessor.OriginAwareSystemEnvironmentPropertySource that can track the
SystemEnvironmentOrigin for every system environment property.SystemEnvironmentPropertySource that also tracks Origin.A
HealthComponent that represents the overall system health and the available
groups.Auto-configuration for system metrics.Access to system properties.
Helper class for resolving placeholders in texts.
A TAR archive that can be written to an output stream.
Manages the connection to the ultimate tunnel target server.
Configuration properties for task execution.
Builder that can be used to configure and create a
TaskExecutor.Callback interface that can be used to customize a
ThreadPoolTaskExecutor.Builder that can be used to configure and create a
TaskScheduler.Callback interface that can be used to customize a
ThreadPoolTaskScheduler.Configuration properties for task scheduling.
Indicates the availability of view templates for a particular templating engine such as
FreeMarker or Thymeleaf.
Collection of
TemplateAvailabilityProvider beans that can be used to check
which (if any) templating engine supports a given view.Contains a location that templates can be loaded from.
@Component that can be used when a bean is intended only for tests,
and should be excluded from Spring Boot's component scanning.@Configuration that can be used to define additional beans or
customizations for a test.Auto-configuration for a test database.
Alternative to
EntityManager for use in JPA tests.Auto-configuration for
TestEntityManager.Test utilities for adding properties.
A single name value pair.
The type of property source.
Convenient alternative of
RestTemplate that is suitable for integration tests.HttpComponentsClientHttpRequestFactory to apply customizations.Options used to customize the Apache HTTP Client.
A
Producible enum for supported Prometheus TextFormat.Origin for an item loaded from a text resource.A location (line and column number) within the resource.
@Endpoint to expose thread info.A description of a thread dump.
Auto-configuration for the ThreadDumpEndpoint.Auto-configuration for Thymeleaf.Properties for Thymeleaf.
TemplateAvailabilityProvider that provides availability information for
Thymeleaf view templates.Utility used to obtain
@Timed annotations from bean methods.The JSON web token provided with each request that originates from Cloud Foundry.
Callback interface that can be used to customize a Tomcat
Connector.Callback interface that can be used to customize a Tomcat
Context.DataSourcePoolMetadata for a Tomcat DataSource.Extension of Tomcat's
ParallelWebappClassLoader that does not consider the
system classloader.Auto-configuration for TomcatMetrics.Binds
TomcatMetrics in response to the ApplicationStartedEvent.Callback interface that can be used to customize the
ProtocolHandler on the
Connector.ReactiveWebServerFactory that can be used to create a TomcatWebServer.WebServerFactoryCustomizer to apply ServerProperties to Tomcat reactive
web servers.AbstractServletWebServerFactory that can be used to create
TomcatWebServers.WebServerFactoryCustomizer to apply ServerProperties to Tomcat web
servers.WebServer that can be used to control a Tomcat web server.Customization for Tomcat-specific features common for both Servlet and Reactive
servers.
WebSocket customizer for
TomcatReactiveWebServerFactory.WebSocket customizer for
TomcatServletWebServerFactory.Utility to render a simple progress bar based on consumed
TotalProgressEvent
objects.Event published by the
TotalProgressPullListener showing the total progress of
an operation.UpdateListener that calculates the total progress of the entire image operation
and publishes TotalProgressEvent.UpdateListener that calculates the total progress of the entire pull operation
and publishes TotalProgressEvent.UpdateListener that calculates the total progress of the entire push operation
and publishes TotalProgressEvent.A representation of an HTTP request that is suitable for tracing.
A representation of an HTTP response that is suitable for tracing.
Configuration properties for tracing.
Auto-configuration for Spring transaction.CompilerAutoConfiguration for Spring MVC.A collection of
PlatformTransactionManagerCustomizer.Configuration properties that can be applied to an
AbstractPlatformTransactionManager.FileFilter that accepts only a specific "trigger" file.The client side component of a socket tunnel.
Listener that can be used to receive
TunnelClient events.Interface used to manage socket tunnel connections.
Provides exclusion
TypeFilters that are loaded from the
BeanFactory and automatically applied to SpringBootApplication
scanning.Annotation that can be on tests to define a set of
TypeExcludeFilter classes
that should be applied to @SpringBootApplication
component scanning.BindException thrown when ConfigurationPropertySource elements were
left unbound.Function used to determine if a
ConfigurationPropertySource should be included
when determining unbound elements.Callback interface that can be used to customize an Undertow
Undertow.Builder.Callback interface that can be used to customize an Undertow
DeploymentInfo.ReactiveWebServerFactory that can be used to create UndertowWebServers.WebServer that can be used to control an embedded Undertow server.ServletWebServerFactory that can be used to create
UndertowServletWebServers.WebServerFactoryCustomizer to apply ServerProperties to Undertow
Servlet web servers.WebServer that can be used to control an Undertow web server.Customization for Undertow-specific features common for both Servlet and Reactive
servers.
WebSocket customizer for
UndertowServletWebServerFactory.Command to uninstall dependencies from the CLI's lib/ext directory.Exception throw if a
ConfigDataLocation is not supported.RuntimeException thrown from DataSourceBuilder when an unsupported
property is used.Base class for update events published by Docker.
Listener for update events published from the
DockerApi.HandlerMapper implementation that maps incoming URLs.Configurations representing user-defined @Configuration classes (i.e.Auto-configuration for a Spring Security in-memory
AuthenticationManager.Auto-configuration to configure the validation
infrastructure.BindHandler to apply Validators to bound results.Callback interface that can be used to customize
Configuration.A collection of
ObjectErrors caused by bind validation failures.Command to display the 'version' number.A Docker volume name.
Command to create a self-contained executable jar file from a CLI application.Launcher for WAR based archives.Auto-configuration for Wavefront common infrastructure.Auto-configuration for exporting metrics to Wavefront.Configuration properties to configure Wavefront.
Adapter to convert
WavefrontProperties to a WavefrontConfig.Auto-configuration for Wavefront tracing.An
ApplicationContext runner for a Servlet
based ConfigurableWebApplicationContext.Variant of
ServletContextAwareProcessor for use with a
ConfigurableWebApplicationContext.An enumeration of possible types of web application.
WebClientCustomizer that configures codecs for the HTTP client.Callback interface that can be used to customize a
WebClient.Builder.Factory methods for creating
Tags related to a request-response exchange
performed by a WebClient.Tags provider for an exchange performed by a
WebClient.Auto-configuration for a web-client
RestTemplate.FormattingConversionService dedicated to web
applications for formatting and converting values to/from the web.Identifies a type as being an endpoint that is only exposed over HTTP.
Auto-configuration for web @Endpoint
support.An enumeration of HTTP methods supported by web endpoint operations.
Configuration properties for web management endpoints.
A
WebEndpointResponse can be returned by an operation on a
@EndpointWebExtension to provide additional, web-specific
information such as the HTTP status code.Configuration equivalent to
@EnableWebFlux.A custom
HandlerMapping that makes web endpoints available over HTTP using
Spring WebFlux.@ManagementContextConfiguration for Reactive
@Endpoint concerns.Auto-configuration for instrumentation of Spring
WebFlux applications.properties for Spring WebFlux.Interface to register key components of the
WebFluxAutoConfiguration in place
of the default ones provided by Spring WebFlux.Factory methods for
Tags associated with a request-response exchange that
is handled by WebFlux.A contributor of
Tags for WebFlux-based request handling.Provides
Tags for WebFlux-based request handling.Annotation that can be used for a Spring WebFlux test that focuses
only on Spring WebFlux components.
Interface to be implemented by types that register
@WebListeners.A registry that holds
@WebListeners.Configuration equivalent to
@EnableWebMvc.A custom
HandlerMapping that makes web endpoints available over HTTP using
Spring MVC.@ManagementContextConfiguration for Spring MVC
@Endpoint concerns.Auto-configuration for instrumentation of Spring Web
MVC servlet-based request mappings.Intercepts incoming HTTP requests handled by Spring MVC handlers and records metrics
about execution time and results.
properties for Spring MVC.Matching strategy options.
Interface to register key components of the
WebMvcConfigurationSupport in place
of the default ones provided by Spring MVC.Factory methods for
Tags associated with a request-response exchange that
is handled by Spring MVC.A contributor of
Tags for Spring MVC-based request handling.Provides
Tags for Spring MVC-based request handling.Annotation that can be used for a Spring MVC test that focuses only on
Spring MVC components.
An operation on a web endpoint.
A predicate for a request to an operation on a web endpoint.
Configuration properties for general web concerns.Cache configuration.
Cache Control HTTP header configuration.
Configuration for the Spring Resource Handling chain.
Strategies for extracting and embedding a resource version in its URL path.
Version Strategy based on content hashing.
Version Strategy based on a fixed version string.
Simple interface that represents a fully configured web server (for example Tomcat,
Jetty, Netty).
Interface to be implemented by
application contexts that
create and manage the lifecycle of an embedded WebServer.Exceptions thrown by a web server.
Tagging interface for factories that create a
WebServer.Strategy interface for customizing
web server factories.BeanPostProcessor that applies all WebServerFactoryCustomizer beans
from the bean factory to WebServerFactory beans.SmartLifecycle to trigger WebServer graceful shutdown.Event to be published when the
WebServer is ready.Enumeration of server namespaces.
An
ApplicationListener that saves embedded server port and management port into
file.Auto-configuration for a web-client
WebServiceTemplate.Annotation that can be used for a typical Spring web service client test.
Auto-configuration for Spring Web Services.Annotation that can be used for a typical Spring web service server test.
@ConfigurationProperties for Spring Web Services.Auto-configuration for WebServiceTemplate.Builder that can be used to configure and create a
WebServiceTemplate.Callback interface that can be used to customize a
WebServiceTemplate.Auto-configuration for
WebSessionIdResolver.Auto-configuration for WebSocket-based messaging.Auto-configuration for WebSocket reactive server in Tomcat, Jetty or Undertow.
Auto configuration for WebSocket servlet server in embedded Tomcat, Jetty or Undertow.
Auto-configuration for
WebTestClient.A customizer for a
WebTestClient.Builder.ThrowablePatternConverter that adds some additional whitespace around the stack
trace.ThrowableProxyConverter that adds some additional whitespace around the stack
trace.Identifies a method on an
@Endpoint as being a write operation.Strategy interface used to wrap a JMS
XAConnectionFactory enrolling it with a
JTA TransactionManager.Auto-configuration for DataSource with XA.Strategy interface used to wrap an
XADataSource enrolling it with a JTA
TransactionManager.ServletWebServerApplicationContext which takes its configuration from XML
documents, understood by an
XmlBeanDefinitionReader.Thin wrapper to adapt Snake
Yaml to JsonParser.Strategy to load '.yml' (or '.yaml') files into a
PropertySource.Adapter class to convert a ZIP file to a
TarArchive.Auto-configuration for Zipkin.Configuration properties for
ZipkinAutoConfiguration.