All Classes and Interfaces
Class
Description
Abstract base class for
BindHandler implementations.Abstract base class for most
FailureAnalyzer implementations.Abstract base
ServletContextInitializer to register Filters in a
Servlet 3.0+ container.Abstract base class for a
FailureAnalyzer that handles some kind of injection
failure.Base class for parsers wrapped or implemented in this package.
Abstract base class for
LoggingSystem implementations.Maintains a mapping between native levels and
LogLevel.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.GenericWebApplicationContext 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.AnsiElement implementation for ANSI 8-bit foreground or background color codes.Ansi background colors.Ansi colors.An ANSI encodable element.
Generates ANSI encoded output, automatically attempting to detect if the terminal
supports ANSI.
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.Exception thrown when the AOT initializer couldn't be found.
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.Strategy interface for creating the
ConfigurableApplicationContext used by a
SpringApplication.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.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.
Class can be used to obtain
ResourceLoaders supporting
additional ProtocolResolvers registered in
spring.factories.Strategy interface registered in
spring.factories and used by
ApplicationResourceLoader to determine the file path of loaded resource
when it can also be represented as a FileSystemResource.Interface used to indicate that a bean should run when it is contained within
a
SpringApplication.StandardServletEnvironment for typical use in a typical
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.
ApplicationEvent sent when the AvailabilityState of the application
changes.Tagging interface used on
ApplicationAvailability states.Interface class for writing a banner programmatically.
An enumeration of possible values for configuring the Banner.
Really basic JSON parser for when you have nothing else available.
An
AbstractFailureAnalyzer that performs analysis of failures caused by a
BeanNotOfRequiredTypeException.Source that can be bound by a
Binder.Restrictions that can be applied when binding values.
RuntimeHintsRegistrar that can be used to register ReflectionHints for
Bindable types, discovering any nested type it may expose through a property.Strategy interface used to determine a specific constructor to use when binding.
Context information for use by
BindHandlers.A container object which Binds objects from one or more
ConfigurationPropertySources.Exception thrown when binding fails.
Callback interface that can be used to handle additional logic during element
binding.Configuration property binding methods.
A container object to return the result of a
Binder bind operation.Error thrown when validation fails during a bind operation.
A simple bootstrap context that is available during startup and
Environment
post-processing up to the point that the ApplicationContext is prepared.ApplicationEvent published by a BootstrapContext when it's closed.A simple object registry that is available during startup and
Environment
post-processing up to the point that the ApplicationContext is prepared.Supplier used to provide the actual instance when needed.
The scope of an instance.
Callback interface that can be used to initialize a
BootstrapRegistry before it
is used.Bean to record and provide bound
@ConfigurationProperties.BindHandler that can be used to track bound configuration properties.ApplicationStartup implementation that buffers steps and
records their timestamp as well as their processing time.Provide build-related information such as group and artifact.
An
EnvironmentPostProcessor that knows where to find VCAP (a.k.a.Simple detection for well known cloud platforms.
Log4j2
LogEventPatternConverter to color output using the AnsiOutput
class.Logback
CompositeConverter to color output using the AnsiOutput class.Interface used to indicate that a bean should run when it is contained within
a
SpringApplication.Common structured log formats supported by Spring Boot.
Caching implementation of the
MetadataReaderFactory interface backed by a
ConcurrentReferenceHashMap, caching MetadataReader per Spring
Resource handle (i.e.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.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 through the
BootstrapRegistry interface.Interface to provide configuration for a reactive web application.
Specialization of
ConfigurableEnvironment for reactive application contexts.Annotation for externalized configuration.
Provides access to
@ConfigurationProperties bean
details, regardless of if the annotation was used directly or on a @Bean
factory method.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.Configures the base packages used when scanning for
@ConfigurationProperties classes.Indicates that the annotated type is a source of configuration properties metadata.
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.
AutoCloseable used to control a
cache override.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.Annotation that can be used to indicate which constructor to use when binding
configuration properties using constructor arguments rather than by calling setters.
Helper class to programmatically bind configuration properties that use constructor
injection.
ApplicationContextInitializer that sets the Spring
ApplicationContext ID.Helper that can be used to add JSON pairs from context data (typically the logger MDC)
in the correct location (or drop them altogether).
Log4j2
LogEventPatternConverter to convert a CorrelationIdFormatter
pattern into formatted output using data from the MDC.Logback
DynamicConverter to convert a CorrelationIdFormatter pattern
into formatted output using data from the MDC
and Environment.Utility class that can be used to format a correlation identifier for logging based on
W3C
recommendations.
Internal utility to help when dealing with data object property names.
Annotation that can be used to change the default unit used when converting a
DataSize.Default implementation of
ApplicationArguments.Default
ConfigurableBootstrapContext implementation.MapPropertySource containing default properties contributed directly to a
SpringApplication.Default
SslBundleRegistry implementation.Annotation that can be used to specify the default value when binding to an immutable
property.
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.A
ServletContextInitializer to register DelegatingFilterProxys in a
Servlet 3.0+ container.Declares a field or method parameter should be converted to collection using the
specified delimiter.
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.Enumeration of filter dispatcher types, identical to
DispatcherType and used in configuration as the servlet API may
not be present.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.Properties for Elastic Common Schema structured logging.
Service details.
Enable support for
@ConfigurationProperties annotated
beans.Log4j2
LogEventPatternConverter used to help format optional values that should
be shown enclosed in square brackets.Logback
CompositeConverter used to help format optional values that should be
shown enclosed in square brackets.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.A wrapper class for
MessageSourceResolvable errors that is safe for JSON
serialization.Options controlling the contents of
ErrorAttributes.Error attributes that can be included in an error response.
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.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.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.An
ApplicationListener that halts application startup if the system file
encoding does not match an expected value set in the environment.Custom
MethodValidationPostProcessor that applies
exclusion filters.Registers a
Filter in a Servlet 3.0+ container.A
ServletContextInitializer to register Filters in a Servlet 3.0+
container.Subclass of
GenericApplicationContext, suitable for reactive web environments.Provide git-related information such as commit id and time.
Service details for Graylog Extended Log Format structured logging.
Service details.
Thin wrapper to adapt
Gson to a JsonParser.BindHandler that can be used to ignore binding errors.BindHandler that can be used to ignore top-level
ConverterNotFoundExceptions.Contains
@Configuration import candidates, usually auto-configurations.Exception thrown when an attempt is made to resolve a property against an inactive
ConfigData property source.Exception thrown when the application has configured an incompatible set of
ConfigurationProperties keys.Base class for components exposing unstructured data with dedicated methods for well
known keys.
Property entry.
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.
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.
A
ConfigurationPropertySource with a fully Iterable set of entries.Thin wrapper to adapt Jackson 2
ObjectMapper to JsonParser.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.
LoggingSystemFactory that returns JavaLoggingSystem if possible.Known Java versions.
SslStoreBundle backed by a Java keystore.Details for an individual trust or key store in a
JksSslStoreBundle.IllegalArgumentException thrown when source JSON is invalid.Factory to create a
JsonParser.Interface that can be used to write JSON output.
A member that contributes JSON.
A path used to identify a specific JSON member.
Callback used to configure JSON members.
Callback interface that can be
applied to JsonWriter.Members to change names or filter members.Interface that can be used to extract name/value pairs from an element.
Callback interface that can be
applied to JsonWriter.Members
to process values before they are written.Base class for
StructuredLogFormatter implementations that generates JSON using
a JsonWriter.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.
A filter that can be used to restrict when a callback is used.
The result of a callback which may be a value,
null or absent entirely if
the callback wasn't suitable.Abstract base class for lambda safe callbacks.
BeanFactoryPostProcessor to set lazy-init on bean definitions that are not
excluded and have not already had a value
explicitly set.Filter that can be used to exclude beans definitions from having their
lazy-init set by the
LazyInitializationBeanFactoryPostProcessor."Liveness" state of the application.
LoggingSystem for Log4j 2.LoggingSystemFactory that returns Log4J2LoggingSystem if possible.LoggingSystem for logback.LoggingSystemFactory that returns LogbackLoggingSystem if possible.LoggingSystemProperties for Logback.A reference to a log output file.
Immutable class that represents the configuration of a
LoggingSystem's logger.Supported logger configuration scopes.
Logger level configuration.
A single logger group.
Logger groups configured through the Spring Environment.
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 system properties that can later be used by log configuration files.
Logging levels supported by a
LoggingSystem.A
ConfigurationPropertySource backed by a Map and using standard name
mapping rules.ObjectFactory that can be used to create a MessageInterpolator.A filter for excluding types from method validation.
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 a property.
Meta-annotation that should be added to annotations that indicate a field is a nested
type.
Indicates that a property in a
@ConfigurationProperties
object should be treated as if it were a nested type.Exception indicating that an
SslBundle was referenced with a name that does not
match any registered bundle.BindHandler to enforce that all configuration properties under the root name
have been bound.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.
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.PEM encoded content that can provide
certificates and
private keys.An individual trust or key store that has been loaded from PEM content.
SslStoreBundle backed by PEM-encoded certificates and private keys.Details for an individual trust or key store in a
PemSslStoreBundle.Annotation that can be used to indicate the format to use when converting a
Period.A standard set of
Period units.Annotation that can be used to change the default unit used when converting a
Period.Optional strategy that used by a
Binder to resolve property placeholders.Information about the process of the application.
Memory information.
Garbage collection information.
Virtual threads information.
Provides access to environment profiles that have either been set directly on the
Environment or will be set based on configuration data property values.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.Strategy interface located through
SpringFactoriesLoader and used to load a
PropertySource.Origin from a PropertySource.PlaceholdersResolver to resolve placeholders from PropertySources.PropertySource that returns a random value for any property that starts with
"random.".EnvironmentPostProcessor to add the RandomValuePropertySource.Interface to provide configuration for a reactive web application.
"Readiness" state of the application.
Base class for Servlet 3.0+ based registration beans.
Banner implementation that prints from a source text
Resource.Logback rolling policy system properties that can later be used by log configuration
files.
Logback
Configurator, registered through META-INF/services, that sets
the root log level to Level.INFO.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).A
ServletContextInitializer to register EventListeners in a Servlet
3.0+ container.Registers a
Servlet in a Servlet 3.0+ container.A
ServletContextInitializer to register Servlets in a Servlet 3.0+
container.Builder that can be used to configure and create a
SimpleAsyncTaskExecutor.Callback interface that can be used to customize a
SimpleAsyncTaskExecutor.Builder that can be used to configure and create a
SimpleAsyncTaskScheduler.Callback interface that can be used to customize a
SimpleAsyncTaskScheduler.Simple 'Java Logging'
Formatter.Class that can be used to bootstrap and launch a Spring application from a Java main
method.
Exception that can be thrown to silently exit a running
SpringApplication
without handling run failures.Used to configure and run an augmented
SpringApplication where additional
configuration should be applied.Provides access to details of a
SpringApplication run using
SpringApplication.Augmented.run(String...).An MBean contract to control and monitor a running
SpringApplication over JMX.Register a
SpringApplicationAdminMXBean implementation to the platform
MBeanServer.Entry point for AOT processing of a
SpringApplication.Builder for
SpringApplication and ApplicationContext instances with
convenient fluent API and context hierarchy support.Base class for
ApplicationEvent related to a SpringApplication.Low-level hook that can be used to attach a
SpringApplicationRunListener to a
SpringApplication in order to observe or modify its behavior.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.Listener for the
SpringApplication run method.Interface that can be used to add or remove code that should run when the JVM is
shutdown.
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.Callback interface used to support custom reporting of
SpringApplication
startup errors.Spring Boot
PropertySource that disables Log4j2's shutdown hook.An opinionated
WebApplicationInitializer to run a SpringApplication
from a traditional WAR deployment.Exposes the Spring Boot version.
A bundle of trust material that can be used to establish an SSL connection.
A reference to a single key obtained via
SslBundle.Interface that can be used to register an
SslBundle for a given name.A managed set of
SslBundle instances that can be retrieved by name.Information about the certificates that the application uses.
Certificate validity info.
Validity Status.
A bundle of key and trust managers that can be used to establish an SSL connection.
Configuration options that should be applied when establishing an SSL connection.
A bundle of key and trust stores that can be used to establish an SSL connection.
Interface that can be used to print the stack trace of a
Throwable.ConfigDataLoader for Resource backed locations.ConfigDataLocationResolver for standard locations.ConfigDataResource backed by a Resource.Environment implementation to be used by Reactive-based web
applications.StackTracePrinter that prints a standard form stack trace.Represent the timeline of
steps recorded by
BufferingApplicationStartup.Event on the current
StartupTimeline.Logback encoder for structured logging.Formats a log event to a structured log message.
Factory that can be used to create a fully instantiated
StructuredLogFormatter
for either a common format or a
fully-qualified class name.Factory used to create a
StructuredLogFormatter for a given
CommonStructuredLogFormat.Callback used for configure the
StructuredLogFormatterFactory.CommonFormatterFactory to use for a given
CommonStructuredLogFormat.Customizer that can be injected into
StructuredLogFormatter implementations to
customize JsonWriter JsonWriter.Members.Builder that can be injected into a
StructuredLogFormatter to build the
StructuredLoggingJsonMembersCustomizer when specific settings are required.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.Access to system properties.
Origin for an item loaded from a text resource.A location (line and column number) within the resource.
Threading of the application.
Builder that can be used to configure and create a
ThreadPoolTaskExecutor.Callback interface that can be used to customize a
ThreadPoolTaskExecutor.Builder that can be used to configure and create a
ThreadPoolTaskScheduler.Callback interface that can be used to customize a
ThreadPoolTaskScheduler.Provides exclusion
TypeFilters that are loaded from the
BeanFactory and automatically applied to SpringBootApplication
scanning.BindException thrown when ConfigurationPropertySource elements were
left unbound.Function used to determine if a
ConfigurationPropertySource should be included
when determining unbound elements.Exception throw if a
ConfigDataLocation is not supported.Configurations representing user-defined @Configuration classes (i.e.BindHandler to apply Validators to bound results.A collection of
ObjectErrors caused by bind validation failures.Common initialization logic for Servlet web applications.
An enumeration of possible types of web application.
ThrowablePatternConverter that adds some additional whitespace around the stack
trace.ThrowableProxyConverter that adds some additional whitespace around the stack
trace.JSON content that can be written out.
Strategy to load '.yml' (or '.yaml') files into a
PropertySource.