spring_boot_actuator library
What a running application tells about itself, as Spring Boot Actuator's endpoints: the same names, properties and JSON, so the same tools read them.
It holds the endpoints and their model, without HTTP: the actuator
starter (spring_boot_starter_actuator) brings them to an application
and answers them under /actuator. What it contains:
@Endpoint,@ReadOperation,@Selectorand@EndpointWebExtension, to write an endpoint of your own, and the discoverer that finds them;health:HealthIndicatorbeans (ping,diskSpace, thelivenessStateandreadinessStateof the probes, the data starter'sdb),HealthandStatus, the aggregation, the groups and who sees the details;info:InfoContributorbeans (build,git,env,os,dart) andBuildProperties/GitProperties;mappings: everyMappingDescriptionsbean (the web server's handlers, an app's screens).
// In the report as "inbox", and in /actuator/health.
@Component()
class InboxHealthIndicator implements HealthIndicator {
@override
Future<Health> health() async =>
Health.up().withDetail('pending', 3).build();
}
Spring Boot (Java): spring-boot-actuator.
Classes
- AbstractBindingResult
- The common part of every BindingResult: the error list, nested paths, message codes and the field queries.
- AbstractHealthIndicator
-
A HealthIndicator whose check fills a builder, and whose errors
become a
DOWNwith the error as detail (logged as a warning). - AbstractMessageSource
- The base class for message sources: it does the locale fallbacks, the formatting and the parent lookup, so that a subclass only says where the texts are.
- AbstractPropertyResolver
- The common part of property resolvers: placeholder resolution, conversion, defaults and required keys. A subclass only says where raw values come from, in getRawProperty.
-
AbstractPropertySource<
T extends Object> - One place property values come from, under a name: a config file, the command line, the environment variables, a map of defaults.
- AbstractResource
- A base class for new kinds of Resource: it fills in everything that can be derived from a few members.
- AdviceBinding
-
The type of an advice parameter that the pointcut fills in, such as
timedin@annotation(timed)oridinargs(id, ..). - Advised
- The interface every generated AOP proxy implements: it exposes the bean behind the proxy and the advice applied to it.
- Advisor
- A piece of advice packaged as an object: the MethodInterceptor to run around calls of other beans.
- After
-
Marks an aspect method to run after each matched call, whether it
returned or threw, like a
finallyblock. - AfterReturning
- Marks an aspect method to run after each matched call that returned normally, with the returned value.
- AfterThrowing
- Marks an aspect method to run after each matched call that threw, with the error.
- AnnotationConfigApplicationContext
-
The application context of this package: it builds its beans from the
BeanModules the generator writes for
@ComponentScan. -
AnnotationMatchingPointcut<
A> -
A pointcut that matches members carrying an annotation of type
A, or every member of beans whose class carries it. - AnnotationPointcut
-
A marker for pointcuts that match only members or classes carrying
annotations from outside
package:spring_core_dart, such as@Cacheableor@Validated. - AntPathMatcher
-
The PathMatcher for Ant-style patterns, the syntax of locations such
as
resources*:i18n/**/*.properties. - AopContext
- Gives an advised bean access to its own proxy, so it can call itself with the advice applied.
- AopPointcut
- A rule that decides which members of which beans an advisor's advice applies to.
- AopProxyFactory
- Knows how to wrap one bean class in its generated proxy class, and which of its members can be advised.
- AopTarget
- The bean class of a proxy as its members' MethodSignatures see it: its name, supertypes and annotations, written once per proxy by the generator and shared by the signatures (MethodSignature.of).
- AopUtils
- Helpers that tell whether an object is an AOP proxy and find the bean behind it.
- ApplicationArguments
-
The arguments the program was started with, split into
--optionsand plain arguments. - ApplicationAvailability
- The current availability states of the application.
- ApplicationAvailabilityBean
- The ApplicationAvailability bean: it listens to every AvailabilityChangeEvent and keeps the last one of each kind of state.
- ApplicationContext
- A running application's container: it holds the beans and gives access to the configuration, events, translated messages and resource files.
- ApplicationContextAware
- Implemented by a bean that wants the application context handed to it through a method call.
- ApplicationContextAwareProcessor
-
The bean post-processor that calls the
*Awarecallbacks of this library on each bean, with the context's objects. - ApplicationContextEvent
- The base class of the events a context publishes about itself: refreshed, started, stopped, paused, restarted, closed.
- ApplicationContextInitializedEvent
- Published once the context is created and the ApplicationContextInitializers have run, before any bean is created.
- ApplicationContextInitializer
- Code that prepares the context before its beans are created.
- ApplicationEnvironmentPreparedEvent
- Published once every property is known (command line, environment variables, config files, active profiles) and before the context is created.
- ApplicationEvent
- An optional base class for application events: it records which object raised the event and when.
- ApplicationEventMulticaster
- The part of the context that holds the listeners and delivers each published event to those that accept it.
- ApplicationEventPublisher
- Sends an event to every listener interested in it.
- ApplicationEventPublisherAware
- Implemented by a bean that wants the event publisher handed to it through a method call.
- ApplicationFailedEvent
- Published when the start fails or a runner throws, before the failure is reported and the context is closed.
- ApplicationLaunch
-
How the running application was started, so that the same one can be
started again in another isolate: the bean
springApplicationLaunch, present when the application was run with what returns it (SpringApplication.run(hotReload:), which the generatedrunApplicationpasses). -
ApplicationListener<
E extends Object> - A bean that listens to one type of event by implementing an interface.
-
ApplicationListenerAdapter<
E> -
A GenericApplicationListener made from a function or an
ApplicationListener, for events (or published objects) of type
E. - ApplicationMappingsDescriptor
-
The answer of the
mappingsendpoint: the mappings of each application context by its id. - ApplicationPreparedEvent
- Published when the context is fully prepared, just before its beans are created.
- ApplicationProperties
-
The application's identity:
spring.application.*. - ApplicationReadyEvent
- Published when the start is complete: every bean is created and every runner has finished.
- ApplicationRunner
- A bean with work to do once, right after the application has started.
- ApplicationStartedEvent
-
Published once every bean is created and the
Started ...line is logged, just before theApplicationRunners are called. - ApplicationStartingEvent
-
The first event of a run, published as soon as
runbegins, before anything is read or created. - ApplicationStartup
- Where the steps of the start go: none by default, so measuring costs nothing until an application chooses a startup that records them (BufferingApplicationStartup, or one of its own that logs or sends them).
- Around
- Marks an aspect method to run instead of each matched call, deciding whether and how the real method runs.
- ArrayNode
- A JSON array: an ordered list of child nodes, which can be changed in place.
- Aspect
- Marks a bean class as an aspect: a bean whose advice methods run around the calls of other beans.
-
AspectAdvice<
A extends Object> -
One advice method of an
@Aspectclass, described so it can be called without reflection. - AspectAdviceInterceptor
- The MethodInterceptor that runs one aspect advice method: it turns the advice kind (before, after, around, ...) into the right place in the call.
- AspectAutoProxyCreator
- The bean post-processor that puts advice into effect: it replaces each bean that some advice matches with the bean's generated proxy.
- AspectJProxyFactory
-
A ProxyFactory that also takes the advice of an
@Aspectobject. -
AspectMetadata<
A extends Object> -
Everything the container needs to know about an
@Aspectclass: its advice methods, its named pointcuts and its instantiation model. - AssertFalse
-
A constraint that requires a
boolto befalse;nullpasses. - AssertTrue
-
A constraint that requires a
boolto betrue;nullpasses. - Async
-
Runs an
@EventListenermethod on aTaskExecutorinstead of in the publishing call. - AsyncMethodInvocation
-
The MethodInvocation of a method that returns a
Future(orFutureOr), with a way to run code when that future completes. - AsyncStartup
- A bean whose start finishes only after the context's refresh, such as a web server whose socket is bound asynchronously.
- AutoConfiguration
-
Marks a class of a library (a "starter") whose
@Beanmethods give applications default beans, unless an application declares its own. - AutoConfigurationBuild
-
When the generator puts an AutoConfigurationModule into the
application: by property of the application's configuration
(
application.ymlandapplication.propertieswithout a profile), read whenbuild_runnerruns. - AutoConfigurationModule
- Marks the module of beans a library (a "starter") adds to every application that depends on it.
- AutowireCapableBeanFactory
- The part of the container that injects and initializes objects it did not create.
- Autowired
- Asks the container to inject beans into a field, setter, method or constructor.
-
AvailabilityChangeEvent<
S extends AvailabilityState> - Announces a new state of the application's availability.
- AvailabilityState
- A kind of availability of the running application: whether it is alive (LivenessState) and whether it takes requests (ReadinessState).
-
AvailabilityStateHealthIndicator<
S extends AvailabilityState> -
The health of an AvailabilityState: the mappings of the current
state of type
Sto a status. - AvailabilityStateIndicatorProperties
-
The
management.health.livenessstate.*andreadinessstate.*properties. - Aware
- The common supertype of the interfaces through which the container hands a bean one of its own objects: its bean name, the bean factory, the environment and so on.
- Banner
- Text printed once when the application starts, before the context is created.
- Bean
- Marks a method whose return value is a bean.
-
BeanConstructor<
T extends Object> -
The description of the constructor an introspected class is created
with (the unnamed one, or the one marked
@JsonCreator()), with a closure that calls it. -
BeanDefinition<
T extends Object> - The recipe for one bean: its name, the types it can be found by, its scope and flags, and the closures that create, inject, initialize and destroy it.
- BeanDefinitionRegistry
- The write side of the container: where bean definitions are registered, removed and given aliases.
- BeanDefinitionRegistryPostProcessor
-
A BeanFactoryPostProcessor that may also add, remove or replace bean
definitions, before any
postProcessBeanFactoryruns. - BeanExpressionContext
-
The root object of
@Value('#{...}')expressions, whose properties are the beans of a bean factory. - BeanExpressionContextAccessor
-
A PropertyAccessor that reads the beans of a BeanExpressionContext
as its properties, so that
#{mailer}is the beanmailer. - BeanExpressionResolver
-
Evaluates the
#{...}expressions of@Valuestrings, after their${...}placeholders are resolved. - BeanFactory
- The read side of the container: it hands out beans by type or by name and answers questions about them without creating them.
- BeanFactoryAccessor
-
A PropertyAccessor that reads beans as properties of a BeanFactory
itself, for expressions whose value is a bean factory
(
factory.mailer). - BeanFactoryAware
- A bean that is handed the bean factory that created it, so it can look up other beans by itself while it runs.
- BeanFactoryPostProcessor
- A hook that runs once at startup, after all bean definitions are registered and before any ordinary bean is created, to inspect or change them.
- BeanFactoryResolver
-
A BeanResolver that answers
@namereferences with the beans of a BeanFactory. - BeanFactoryUtils
-
Helpers that list beans across a whole hierarchy of factories, and that
handle the
&prefix of factory bean names. -
BeanIntrospection<
T extends Object> - Everything the generator knows about an introspected class: its properties, methods, constructor and annotations, with closures to use them.
- BeanIntrospector
- The registry that finds the BeanIntrospection of a class or object.
-
BeanMethod<
T extends Object> - The description of one public instance method of an introspected class or bean, with a closure that calls it.
- BeanMethodAnnotation
- Marks an annotation class whose methods the runtime can find on beans.
- BeanModule
- Everything the generator found in one scanned directory: the bean definitions, plus the property files, imports and embedded resources that come with them.
- BeanNameAware
- A bean that is told the name it is registered under.
- BeanParameter
- The description of one parameter of a constructor or method: its name, full type, whether it is named or required, and its annotations.
- BeanPostProcessor
- A hook that sees every bean as it is created, and may change or replace it before the container hands it out.
-
BeanProperty<
T extends Object> - The description of one property of an introspected class: its name, type, annotations, and closures that read and write it.
- BeanPropertyBindingResult
-
The BindingResult for an
@Introspectedobject, the one used almost everywhere. - BeanRegistrar
- Code that registers beans, written by hand instead of with annotations.
- BeanRegistry
- Where a BeanRegistrar registers its beans: a short API that turns each call into a bean definition of the context.
- BeanResolver
-
Looks up the object an
@name(or&name) reference stands for. - BeanValidator
-
The validator: it checks an object against the constraint annotations
on its class (
@NotBlank(),@Min(18), custom Constraints) and reports what is broken. - BeanWrapper
-
Reads and writes the properties of an object by path (
address.city,tags[0]), converting written values to the property types. - Before
- Marks an aspect method to run before each matched call.
- Binder
-
Reads a group of properties from the environment as one typed value: a
list, a map, a
Durationor a whole settings object. - BindHandler
- Hooks into a Binder.bind call, called for every property bound on the way: the top-level name, then each nested property and element.
- BindingResult
- The outcome of binding input onto an object and validating it: the Errors together with the object they are about.
-
BindResult<
T> - The outcome of Binder.bind: the value, or the fact that no property was set.
- BooleanNode
-
A JSON
trueorfalse. - BracePlaceholders
-
{{key}}placeholders in a text that is not configuration: Markdown pages, templates of an app's own. Each is replaced by resolve's value of its key; one whose key has no value stays as it is, so a text that shows{{token}}of another tool keeps it.\{{writes{{as text. - BufferingApplicationStartup
- Records the steps of the start, up to capacity, for a report, a log or a test: steps in the order they began. onEnd is told each step that ends (a listener that logs it, marks it in the browser's performance timeline).
- BuildInfoContributor
-
The
builddetails of theinfoendpoint: every key ofbuild-info.properties, the time as an ISO-8601 instant. - BuildInfoLocation
-
The
spring.info.build.*properties. - BuildProperties
-
What the build wrote about the application:
build.name,build.version,build.time,build.group,build.artifactand any otherbuild.*key, fromresources:build-info.properties(spring.info.build.location). - BuiltinMethodResolver
-
A MethodResolver for the common methods of core Dart types, under
their Dart names and the Java names Spring expressions use
(
size(),toUpperCase(),charAt(),equals(),getOrDefault(),putIfAbsent()). - BuiltinPropertyAccessor
- A PropertyAccessor for the common read-only properties of core Dart types, which expressions cannot reach otherwise without reflection.
- ByteArrayResource
- A resource over bytes held in memory.
- CacheStore
-
Where a cache keeps what it may lose: bytes by a path of
/-separated names, read and written asynchronously, kept across restarts when the store can (a folder on a disk, the browser's IndexedDB), cleared by the system when it needs the room. - ClasspathFileResource
-
A
resources:file read from disk (belowlib/resources/or a directory added for tests): a FileSystemResource that knows its pathWithinContext. -
ClassType<
T> -
The TypeInfo of a class or scalar type that needs no further
description:
ClassType<String>(),ClassType<Book>(). - ClockProvider
-
Where the date constraints (
@Past(),@FutureDate(), ...) get the current time. - CommandLineRunner
- A bean with work to do once after the application has started, which receives the program arguments as the raw list.
- CommonAnnotationBeanPostProcessor
-
A marker in the post-processor chain that says where the
@PostConstructmethods run. - Component
- Marks a class as a bean: an object the container creates once, injects into others and closes at shutdown.
- ComponentScan
- Generates a module with every bean declared in the directory of the annotated file and its subdirectories.
- ComposablePointcut
- A pointcut built from other pointcuts with "or" (union) and "and" (intersection).
- CompositeHealthContributor
- Several HealthContributors under one name: the report shows each under its own name and their aggregated status.
- CompositeHealthDescriptor
- The health of several parts together: the aggregated status and, when shown, each part's health under its name.
- CompositePropertySource
- One property source made of several others, asked in order.
- CompositeStringExpression
-
A template made of several parts, text and
#{...}expressions, whose value is the parts joined into one string. - Condition
- A rule that decides whether a bean is registered at all.
- Conditional
-
Registers a bean only when every listed
Conditionmatches. - ConditionalOnBean
- Registers a bean only when some other bean is already registered.
- ConditionalOnBooleanProperty
-
Registers a bean only when a
true/falseproperty has the wanted value. - ConditionalOnCloudPlatform
- Registers a bean only when the application runs on a given cloud platform, such as Kubernetes.
- ConditionalOnEnabledHealthIndicator
-
Registers a health indicator's bean only when it is enabled:
management.health.<name>.enabled, elsemanagement.health.defaults.enabled, else on. - ConditionalOnEnabledInfoContributor
-
Registers an info contributor's bean only when it is enabled:
management.info.<name>.enabled, else (for the contributors on by default, enabledByDefault)management.info.defaults.enabled. - ConditionalOnExpression
-
Registers a bean only when an expression evaluates to
true. - ConditionalOnMissingBean
- Registers a bean only when no such bean is registered yet: the way a library offers a default that the application can replace.
- ConditionalOnPrimaryIsolate
-
Registers a bean only in the application's primary isolate: the first
one, which is the only one unless the web server runs a pool of
isolates (
server.isolates.count). - ConditionalOnProperty
- Registers a bean only when a property is set, or set to a given value.
- ConditionalOnRateLimiting
-
Registers a bean only when the rate limiter is on
(
spring.web.rate-limit.enabled, or a rule when that is not set). - ConditionalOnRateLimitStore
-
Registers a
RateLimitStorebean when it is the one the application asked for, or the best it has: how a library offers its store to the rate limiter, and how the framework's own are chosen. - ConditionalOnResource
- Registers a bean only when every one of some files exists.
- ConditionalOnSingleCandidate
- Registers a bean only when exactly one bean of a type can be injected where that type is asked for.
- ConditionContext
- What a Condition can look at to decide: the configuration, the bean definitions registered so far, resource files, and the definition being decided.
- ConditionEvaluation
- The outcome of one condition evaluated while a context loaded its modules: which bean or class it guarded, and whether it matched.
- ConditionEvaluationCache
- A ConditionContext that remembers results while the modules load, so a ConditionGroup is decided only once.
- ConditionEvaluationRecorder
- Receives the outcome of every condition evaluated, for ConditionEvaluation reports.
- ConditionEvaluationReport
-
The list of
@Conditional...checks made while the beans were registered, with which ones matched and which did not. - ConditionGroup
- The conditions of one configuration class, decided once for the whole class, so that the class is registered all or nothing.
- ConfigDataEnvironment
-
Reads the application's config files (
application.properties,application.ymland their profile variants, imports, config trees) into an environment and sets the active profiles they name. - Configurable
-
Lets the container inject an object it did not create, such as a
Flutter
State. - ConfigurableApplicationContext
- An application context that can also be set up, started, paused and closed.
- ConfigurableBeanFactory
-
The settings side of a bean factory: parent, conversion,
@Valueresolution, bean post-processors, custom scopes, dependency records and shutdown. - ConfigurableEnvironment
- An Environment that can be changed: its list of property sources, its profiles and how it converts and resolves values.
- ConfigurableListableBeanFactory
- The container's full control: besides handing out beans, it lets code change bean definitions and the container's setup before any bean is created.
- ConfigurablePropertyResolver
- A PropertyResolver whose behaviour can be set: the conversion service, the placeholder syntax, and keys that must be present.
- Configuration
- Marks a class whose Bean methods create beans.
- ConfigurationCondition
- A Condition decided in one ConfigurationPhase only; plain conditions count in both.
- ConfigurationProperties
- Turns a class into a typed view of a group of settings: every field is filled from the property of the same name under prefix.
- ConfigurationPropertiesBinder
-
The machinery that fills
@ConfigurationPropertiesbeans from the environment and validates them. - ConfigurationPropertyName
-
A property name split into its elements (
app,read-timeout) and compared the relaxed way, soapp.readTimeout,app.read_timeoutandapp.read-timeoutare the same name. - ConfigurationPropertySources
-
Makes an environment find a property however a source spells it: a
read of
app.read-timeoutalso findsapp.readTimeout,app.read_timeoutor the variableAPP_READTIMEOUT. - ConfigurationPropertySourcesPropertySource
- The property source that ConfigurationPropertySources.attach puts first in an environment, so reads of a property find it under any spelling.
- ConsoleAppender
-
The console output: formats each record with a LogPattern and
passes the text to out,
printby default. - Constraint
-
The base class of every validation rule written as an annotation, such
as
@NotBlank()or@Min(18), and the class to extend for your own. - ConstraintValidatorContext
- The help a constraint gets while it checks one value: the validator's clock, and a way to report violations other than the default one.
- ConstraintViolation
- One broken rule: which constraint failed, where (the property path), on which value, and the finished message.
- ConstraintViolationBuilder
- A violation being put together inside a constraint: its message is set, a property path may be added, and addConstraintViolation reports it.
- ConstructorBound
-
The hook the generated code uses to create a
@ConfigurationPropertiesbean whose class has constructor parameters. - ConstructorResolver
-
A plug-in that tells expressions how to create an object for
new Name(...). - ContextClosedEvent
- Published when a context starts closing, while every bean is still available.
- ContextMappingsDescriptor
- The mappings of one application context, by the name of their kind.
- ContextPausedEvent
-
Published after
pause()(orpauseAsync()) was called on a context: the pauseable lifecycle beans are stopped, for example while a Flutter app is in the background. - ContextRefreshedEvent
- Published once a context has started: every eager singleton exists and the auto-startup lifecycle beans run.
- ContextResource
-
A resource of a context with a path within it: a
resources:file knows its path belowlib/resources/(content/guide/index.md), whether it is embedded or read from disk. A feature that lists files by a pattern (resources:content/**/*.md) reads it to name each file. - ContextRestartedEvent
-
Published after
restart()was called on a context: the auto-startup lifecycle beans run again, typically after a pause. - ContextStartedEvent
-
Published after
start()was called on a context and its lifecycle beans were started. - ContextStoppedEvent
-
Published after
stop()was called on a context and its running lifecycle beans were stopped. - Controller
- Marks a class as a bean of the presentation layer.
- ConversionService
-
Turns a value into a value of another type, such as the text
'10s'from a config file into aDuration. - ConverterRegistry
- The part of a conversion service that accepts new converters.
- ConvertGroup
-
An annotation next to
@Valid()that checks the nested value with another group: when the outer validation runs group from, the nested value is checked with group to. - CustomScope
- A place that keeps bean instances for a span of your choosing, such as a screen, a session or a job, and so defines a custom bean scope.
- DartInfoContributor
-
The
dartdetails: the version of Dart running the application. Off by default:management.info.dart.enabled=true. - DataBinder
-
Copies input values, usually strings from a form or a query, onto the
properties of an
@Introspectedobject, then validates it, collecting every problem in one bindingResult. - DataSize
- An amount of data, such as an upload limit or a cache size, stored as a whole number of bytes.
- DataSizeUnit
-
The unit of a
DataSizeproperty written as a plain number. - DecimalMax
- A constraint that requires a number below a decimal limit, or equal to it when inclusive.
- DecimalMin
- A constraint that requires a number above a decimal limit, or equal to it when inclusive.
- DeclareParents
- Makes the proxies of matching beans implement an extra interface, with an implementation the aspect supplies (an AspectJ "introduction").
- Default
-
The validation group of every constraint declared without
groups. - DefaultClockProvider
-
The ClockProvider of the system clock,
DateTime.now(); the default ofBeanValidator. - DefaultConversionService
- A conversion service that already knows the types configuration values are usually read as: numbers, booleans, durations, data sizes, URIs, dates, encodings, resources and lists, sets and maps of them.
- DefaultHealthContributorRegistry
- The default HealthContributorRegistry: the contributors in a map, in the order they were added.
- DefaultLifecycleProcessor
- The LifecycleProcessor every context uses unless it declares its own: it starts the lifecycle beans phase by phase, lowest first, and stops them in the reverse order.
- DefaultListableBeanFactory
- The bean container itself: it holds the bean definitions, creates the beans in dependency order, injects them, and destroys them at the end.
- DefaultMessageCodesResolver
- The standard message codes of errors, the ones every binding result and validator uses unless told otherwise.
- DefaultMessageRendering
-
Implemented by a MessageSourceResolvable whose default message must
not go through
MessageFormat. - DefaultMessageSourceResolvable
- A ready-made MessageSourceResolvable: codes, arguments and a default message given as values.
- DefaultPointcutAdvisor
- The standard PointcutAdvisor: a pointcut, an interceptor and an order.
- DefaultPropertySourceFactory
-
The factory
@PropertySourceuses when none is named: it reads the file as.properties. - DefaultResourceLoader
-
The ResourceLoader used everywhere: it knows
resources:,file:,http:,https:andpackage:locations, plus any prefix taught by a ProtocolResolver. - DefaultValue
-
The value a constructor parameter of a
@ConfigurationPropertiesclass takes when its property is not set. - DeferredImportSelector
- An ImportSelector that runs after every other module and component has been loaded.
- DeferredLogs
- A copy of every log record written while the application starts, kept for a logging system that is set up later.
- DelegatingMessageSource
- A message source with no messages of its own: it asks its parent, or fails when there is none.
- Dependency
- The description of one injection point of a bean, used to check the bean graph at startup before anything is created.
- DependencyResolver
-
The view of the container that a bean definition's
createandinjectcallbacks receive, to get the dependencies of the bean being built. - DependsOn
- Names beans that must be created before this one and destroyed after it.
- Description
- A human-readable description of a bean.
- DescriptiveResource
- A resource that never exists, standing for a location that cannot be resolved.
- DestructionAwareBeanPostProcessor
- A BeanPostProcessor that is also called before each bean is destroyed.
- Digits
- A constraint that limits how many digits a number has before and after the decimal point.
- DiskSpace
- The space of the file system that holds a path.
- DiskSpaceHealthIndicator
-
UPwhile the file system of path has at least threshold bytes free,DOWNbelow: the report'sdiskSpace, with the sizes as details. - DiskSpaceHealthIndicatorProperties
-
The
management.health.diskspace.*properties. - DisposableBean
- A bean that wants a call when the container discards it, to release what it holds: connections, files, timers, subscriptions.
- DurationStyle
-
Reads and writes durations as text, in the two forms configuration
files use: the short form
10sand ISO-8601PT10S. - DurationUnit
-
The unit of a
Durationproperty written as a plain number. - DynamicType
-
The TypeInfo of
dynamic,Object?or a type that is not described further: values are taken as they are.void(e.g. ofResponseEntity<void>) is DynamicType.forVoid, so a reader can ignore the value. - Each
- An annotation that checks every element of a list or set, or every value of a map, against constraints.
- EachKey
- An annotation that checks every key of a map against constraints.
- A constraint that requires a string to look like an email address.
- EmbeddedResource
-
The content of one file of
lib/resources/, written into the generated code at build time. - EmbeddedValueResolverAware
-
Implemented by a bean that resolves
@Value-style texts itself: it receives a function that resolves${...}placeholders and#{...}expressions. - EncodedResource
-
A resource paired with the character encoding to read it in;
nullmeans UTF-8. - Endpoint
- Marks a bean as an actuator endpoint: something the running application tells about itself (its health, its version, its mappings), under the endpoint's id.
- EndpointDiscoverer
- Finds the endpoints of an application: the beans marked Endpoint, with their ReadOperation methods, and for HTTP the operations of their EndpointWebExtension beans.
- EndpointId
-
The id of an actuator endpoint (
health,info), compared without case, dots and dashes as Spring Boot does. - EndpointOperation
- One operation of an endpoint: a method that reads (or later changes) something, with its parameters.
- EndpointRequestTarget
- The actuator endpoint a web request is for, recorded on the request by the actuator starter before the security filters run, so a request matcher can tell an endpoint request from the others without knowing the base path or the exposed endpoints.
- EndpointsAccessProperties
-
The
management.endpoints.access.*properties. - EndpointsProperties
-
The
management.endpoints.*properties of every endpoint. - EndpointWebExtension
- Marks a bean that replaces the operations of an endpoint over HTTP, with what only HTTP has: a status code (WebEndpointResponse) and the user of the request (SecurityContext).
-
EnumerablePropertySource<
T extends Object> - A property source that can list every key it has.
-
EnumType<
E extends Enum> -
The TypeInfo of an enum, with its values, so a value can be found by
name:
EnumType<Mood>(Mood.values). jsonValue reads the field marked@JsonValue(), when the enum has one. - Environment
- The application's configuration as code sees it: every property from every source (config files, command line, environment variables), and the active profiles.
- EnvironmentAccessor
-
A PropertyAccessor that reads configuration properties of an
Environment, so thatenvironment['app.name']in an expression is the value ofapp.name. - EnvironmentAware
- Implemented by an object that wants the configuration (properties and profiles) handed to it through a method call.
- EnvironmentInfoContributor
-
The details of the
info.*properties, without the prefix (info.app.name=shopshows{"app": {"name": "shop"}}). Off by default since Spring Boot 2.6:management.info.env.enabled=true. - EnvironmentMethodResolver
-
A MethodResolver that lets expressions call the methods of an
Environment(or anyPropertyResolver) under their Java names. - EnvironmentPostProcessor
- Code that changes the application's properties or profiles before any bean is created.
- Errors
- The list of errors found for one object, and the way a validator records them.
- EvaluationContext
- The world an expression is evaluated in: its root object, its variables, and the plug-ins that decide which properties, methods, types and beans it can reach.
- EventListener
- Marks a bean method that the context calls for each published event of its parameter type.
-
EventListenerMethod<
T extends Object> -
One
@EventListenermethod of a bean classT, described by generated code: which events it takes, its condition, its order and how to call it. -
EventResultType<
R extends Object> -
The declared result type
Rof an@EventListenermethod (the element type of anIterableresult), so that its results are published asR. - ExitCodeEvent
- Announces that the application is about to end with a non-zero exit code.
- ExitCodeExceptionMapper
- Turns the error that made a runner fail into an exit code.
- ExitCodeGenerator
- An object that decides the exit code of the process when the application ends.
- ExposableEndpoint
- An endpoint with the operations it has, as the discoverer found it.
- Expression
- A parsed expression, ready to be evaluated as often as needed.
- ExpressionParser
- Turns expression text into an Expression that can be evaluated.
- ExpressionPointcut
-
A pointcut written as an AspectJ-style expression, the syntax of the
@Before/@Around/ ... annotations. - ExpressionState
-
The working state of one evaluation: which object names currently
apply to, what
#thisis, and how many operations have run. -
FactoryBean<
T extends Object> - A bean whose job is to make another object: the container hands out what getObject returns, not the factory itself.
- FailureAnalysis
- A plain-language explanation of why the application failed to start, with what to do about it.
- FailureAnalyzer
-
Explains a startup error that
spring_boot_dartdoes not know, as anAPPLICATION FAILED TO STARTreport instead of a stack trace. - Fallback
- Makes this bean the one used only when no other bean of the type is there.
- FieldError
- A validation or binding error about one field of an object: which field, the value that was rejected, and the message codes.
- FileAppender
- A log file, which the web cannot have: this version keeps the API of the real one so code compiles everywhere, but its constructor throws.
- FileSystemResource
- A Resource for a file (or directory) on the local file system, given by its path.
- Filter
- A rule that selects classes for ComponentScan.includeFilters or ComponentScan.excludeFilters.
-
FunctionMethodResolver<
T extends Object> -
A MethodResolver for objects of type
T, built from one function per method name. -
FunctionPropertyAccessor<
T extends Object> -
A PropertyAccessor for objects of type
T, built from one getter (and optionally one setter) function per property name. - FunctionProtocolResolver
- A ProtocolResolver made from a function, for a resolver too small to deserve a class.
- FutureDate
-
A constraint that requires a
DateTimeafter now. - FutureOrPresent
-
A constraint that requires a
DateTimethat is not in the past. - GenericApplicationListener
- A listener that receives any event and decides at runtime, per event, whether to handle it.
- GenericConversionService
- A conversion service that starts empty and converts only what is registered on it.
-
GenericType<
T> -
The TypeInfo of a generic class other than the collections, with the
descriptions of its type arguments:
GenericType<ResponseEntity<Book>>([ClassType<Book>()]).Tis the whole type; arguments describe its type arguments in order. - GitHubAddressResolver
-
github:owner/repo/path/to/file@ref: the file asraw.githubusercontent.comserves it (refa branch, a tag or a commit;HEADwithout one). - GitInfoContributor
-
The
gitdetails of theinfoendpoint: withmanagement.info.git.mode=simple(the default) the branch, the short commit id and the commit time; withfullevery key ofgit.properties. - GitInfoContributorProperties
-
The
management.info.git.*properties. - GitInfoLocation
-
The
spring.info.git.*properties. - GitProperties
-
What git said about the source of the application:
git.branch,git.commit.id,git.commit.timeand the othergit.*keys, fromresources:git.properties(spring.info.git.location), written by the build. - GroupSequence
- A class annotation that checks the class's rules in stages: the groups in value are checked in order, and checking stops at the first group with a violation.
- Health
- The health of one part of the application: a status and the details that explain it (sizes, versions, the error).
- HealthBuilder
- Builds a Health: a status and details added one by one.
- HealthContributor
- Something that tells the health of a part of the application: a HealthIndicator for one part, a CompositeHealthContributor for several under one name.
- HealthContributorRegistry
- The health contributors of the application, by name, to which code can add contributors while it runs.
- HealthDescriptor
- A node of a health report: a Health of one indicator, or a composite of several (CompositeHealthDescriptor).
- HealthEndpoint
-
The
healthendpoint: whether the application works, from every health contributor, aggregated into one status. - HealthEndpointGroup
- A part of the health report: the contributors it includes, who sees what, how the statuses aggregate and which HTTP status they answer.
- HealthEndpointGroups
- The primary group and the named groups of the health report.
- HealthEndpointProperties
-
The
management.endpoint.health.*properties. - HealthEndpointSupport
- What builds a health report: the contributors of the registry, the groups and their rules. HealthEndpoint and HealthEndpointWebExtension share it.
- HealthEndpointWebExtension
-
The
healthendpoint over HTTP:/actuator/healthand/actuator/health/{*path}, with the HTTP status of the group's status (503forDOWNandOUT_OF_SERVICE) and the details and components shown asshow-detailsandshow-componentssay for the request's user. - HealthGroupProperties
-
One health group:
management.endpoint.health.group.<name>.*. - HealthIndicator
- Tells the health of one part of the application: a database, a queue, a service it calls.
- HealthIndicatorDefaults
-
The
management.health.defaults.*properties. - HealthIndicatorProperties
-
The
management.health.<name>.*properties of one indicator. - HealthLoggingProperties
-
The
management.endpoint.health.logging.*properties. - HealthProbesProperties
-
The
management.endpoint.health.probes.*properties. - HealthStatusProperties
-
The
management.endpoint.health.status.*properties (also of each group). - HierarchicalBeanFactory
- A bean factory with a parent: what it cannot find among its own beans, it looks up in the parent.
- HierarchicalMessageSource
- A MessageSource that asks a parent message source for the codes it does not have.
- HttpCodeStatusMapper
-
The HTTP status of a health status: what a load balancer or Kubernetes
reads from
/actuator/health. - Import
- Adds beans that the component scan does not find: configuration classes from elsewhere, or code that registers beans.
- ImportBeanDefinitionRegistrar
- Code that registers full bean definitions, with access to the ones already registered.
- ImportDeclaration
-
One entry of
@Importthat names code registering beans (a BeanRegistrar, ImportSelector or ImportBeanDefinitionRegistrar), recorded in BeanModule.registrars. - ImportSelector
- Code that chooses, at startup, which modules of beans to add.
- IncludeExcludeEndpointFilter
-
Which endpoints a technology exposes: those include names (
*for all; the default includes when it is empty) that exclude does not name. - IndexAccessor
-
A plug-in that makes
target[index]work for your own indexable types. - Info
-
What the
infoendpoint shows: free-form details by key (build,git,app, ...). - InfoBuilder
- Collects the details of the Info, filled by every InfoContributor.
- InfoContributor
-
Adds details to the
infoendpoint: the version, the build, the commit, anything an operator wants to see. - InfoContributorDefaults
-
The
management.info.defaults.*properties. - InfoContributorProperties
-
The
management.info.build.*properties. - InfoEndpoint
-
The
infoendpoint:GET /actuator/infoanswers the details of every InfoContributor. - InfoEndpointProperties
-
The
management.endpoint.info.*properties. - InfoProperties
-
Key-value information about the application, read from a properties
file whose keys share a prefix (
build.,git.), kept without it. - InitializingBean
- A bean that wants a call once all its dependencies are injected, to finish its setup.
- Inject
- Asks the container to inject a field, setter, method or constructor; the standard Java (JSR-330) name for Autowired.
- InMemoryCacheStore
- A CacheStore in memory: for tests, and where nothing may outlive the run.
- InMemoryProtocolResolver
-
A ProtocolResolver that serves
prefix:pathlocations from a map of paths to text held in memory. - InMemoryRateLimitStore
-
The buckets in the memory of one isolate: the RateLimitStore of an
application with one isolate and no database
(
spring.web.rate-limit.store: memory). - InstantiationAwareBeanPostProcessor
- A BeanPostProcessor that is also called around the creation and the injection of each bean, not only around its initialization.
-
InterfaceMetadata<
T extends Object> - The description of an interface that is implemented by a proxy: its name, its annotations and its methods.
- InterfaceProxies
- The lookup that generated proxy code uses to get its handler; not meant for other code.
- InterfaceProxy
- Marks an annotation class whose interfaces become beans implemented by generated code: each call is handed to an InvocationHandler.
- Introduction
-
An extra interface that a
@DeclareParentsfield adds to the proxies of matching beans, with the way to create its implementation. - Introspected
- Marks a class whose properties, constructor and methods the generator describes, so the framework can read and fill its objects without reflection.
- IntrospectionMethodResolver
-
A MethodResolver that calls the methods of
@Introspectedclasses, using the metadata the code generator wrote for them. - IntrospectionPropertyAccessor
-
A PropertyAccessor that reads and writes the properties of
@Introspectedclasses, using the metadata the code generator wrote for them. - InvocationContext
- What an operation is called with: the request's user, the API version and the arguments read from its path and query.
- InvocationHandler
- The object that does the work of an interface proxy: every call of the generated implementation ends up in invoke.
- InvocationHandlerFactory
-
A bean that provides the InvocationHandler for the interface proxies
it supports, for example those annotated
@FeignClient. - IsolateInfo
-
The isolate the code runs in: its name, as the logs show it
(
%thread), and its place in the application's pool of isolates. - IsolateLoad
- How busy an isolate (or a thread of a Flutter engine) is, as measured over the last few seconds: one row of the task manager.
- IsolateLoads
-
Every isolate the application knows about, with its load: the bean
isolateLoads, which a debug widget and the actuator'sisolatesendpoint read. - IsolateLoadSampler
- Measures the isolate it runs in: how late its event loop is, and from that how busy.
- IsolateLoadsHandler
-
Answers every isolate's load from the application's first isolate
(
isolates.loadsof PrimaryIsolate.ask): the rows of IsolateLoads as JSON, the isolates of the server's pool asked just before. So a request that reaches any isolate can show them all. - IsolateLoadSource
- Tells the load of some isolates or threads: one source of the task manager's rows.
- IsolateLocalState
- A bean that keeps state in the memory of its isolate: sessions, a cache, counters.
- IsolateReporter
- A part of what each isolate of a pool tells the primary every few seconds: a bean that implements it is asked in its own isolate, and what it answers is kept in the primary's IsolateReports under id.
- IsolateReports
-
The last report of every isolate of the pool, by isolate and by
IsolateReporter.id: the bean
isolateReports. Without a pool it has the reports of the one isolate, asked when read. - IsolatesEndpoint
-
The
isolatesendpoint: the application's isolates and how busy each is, the task manager as JSON. - IsolateTaskExecutor
- Runs work in other isolates, taken from a pool: for what would block the isolate it is called from (parsing megabytes of JSON, hashing, resizing an image), so a server goes on answering and an app goes on drawing.
- IsolateTaskExecutorSettings
-
The pool of an IsolateTaskExecutor
(
spring.task.execution.isolates.*). - JoinPoint
- One intercepted call, as advice sees it: which member is called, on which bean, with which arguments.
- JsonAlias
- Other JSON names a property (or constructor parameter) is read from, besides its own.
- JsonAnyGetter
- Writes the entries of a map property as extra properties of the object, after the declared ones.
- JsonAnySetter
- Collects the JSON properties a class does not have, instead of skipping them or failing.
- JsonCreator
- Marks the constructor (or factory constructor) the mapper creates objects with when reading JSON.
-
JsonDeserializer<
T extends Object> -
Custom code that builds values of
Tfrom decoded JSON, for a type the mapper cannot read on its own or should read differently. - JsonFeature
- An on/off setting of a mapper, named after Jackson's feature flags.
- JsonFormat
- Changes the JSON form of one property's value: a date pattern and time zone, or a shape (a number as a string, an enum by index, ...).
- JsonIgnore
- Leaves a property out of JSON in both directions.
- JsonIgnoreProperties
- Lists JSON properties a class ignores, and can make it accept unknown ones when reading.
- JsonInclude
-
Decides which values of a property, or of every property of a class,
are written: for example, leave out
nulls. - JsonMapper
- An ObjectMapper with a builder, for configuring a mapper step by step in Jackson 3's style.
- JsonMapperBuilder
- Collects settings, serializers and modules, then creates a JsonMapper with build.
- JsonMapperBuilderCustomizer
-
A bean that adjusts the auto-configured
ObjectMapperwhile keeping everything else about it. - JsonModule
- A group of serializers and deserializers that is added to a mapper in one step.
- JsonNaming
- Sets the naming strategy of one class's properties, overriding the mapper's.
- JsonNode
-
One value of a JSON document held as a tree: an object, array, string,
number, boolean or
null, with typed accessors for navigating it. - JsonProperty
- Gives a property, constructor parameter or enum constant another name in JSON, or limits it to one direction.
- JsonPropertyOrder
- Puts chosen properties of a class first when it is written, for JSON that people read or that a fixed format expects.
- JsonSchema
- A JSON Schema document (draft 2020-12) that checks decoded JSON.
- JsonSchemaFormats
-
The
formatvalues JsonSchema checks, and how. - JsonSchemaGenerator
-
Writes the JSON Schema (draft 2020-12) of
@Introspectedclasses from their introspection, without reflection. - JsonSchemaLocations
-
Where the schemas of
@JsonSchemaSourcelocations are kept belowlib/resources/. - JsonSchemaRegistry
-
The JSON Schema documents a
$refto another document is resolved in, by their absolute URI. - JsonSchemaRegistryCustomizer
-
A bean that adds schemas to the context's JsonSchemaRegistry: the
auto-configured one or the app's own. Every customizer runs once, when
the registry is made, in
@Orderorder. - JsonSchemaRegistryPostProcessor
- Runs every JsonSchemaRegistryCustomizer bean on each JsonSchemaRegistry bean once it is made, whoever declares it.
- JsonSchemaResult
- The outcome of JsonSchema.validate: valid, or the violations.
- JsonSchemasEndpoint
-
The
jsonschemasendpoint: the JSON Schemas of the application. - JsonSchemaSource
-
Names the JSON Schema that the JSON of an
@Introspectedclass is checked against. - JsonSchemaViolation
- One place where a JSON value does not fit a JsonSchema.
-
JsonSerializer<
T extends Object> -
Custom code that writes values of
Tas JSON, for a type the mapper cannot handle or should write differently. - JsonSubType
-
One entry of JsonSubTypes: a subclass and the type ids it is written
and read with (Jackson's
@JsonSubTypes.Type). - JsonSubTypes
-
Lists the subclasses of a
@JsonTypeInfoclass and their type ids. - JsonTypeInfo
- Makes a class hierarchy polymorphic in JSON: each object carries a type id, so a value of the base type is read back as the right subclass.
- JsonTypeName
-
Sets the type id of a subclass in a
@JsonTypeInfohierarchy. - JsonUnwrapped
- Writes the properties of a nested object inline, in the enclosing object, instead of under its own key.
- JsonValue
- Makes one value stand for the whole object in JSON: an enum constant's JSON form, or a small value class written as a plain string or number.
- JsonView
- Puts a property into one or more views, so the same class can be written with fewer or more properties depending on who reads it.
- Lazy
- Delays the creation of a bean, or of what an injection point receives, until it is first used.
- LazyInitializationBeanFactoryPostProcessor
- Makes every singleton bean lazy: created the first time it is needed, not at startup.
- LazyInitializationExcludeFilter
-
Keeps some beans created at startup when
spring.main.lazy-initialization=truemakes the others lazy. - Lifecycle
- A bean that runs something in the background between a start and a stop, such as a timer, a server or a connection.
- LifecycleProcessor
- The part of the context that starts and stops its Lifecycle beans, at refresh, pause, restart and close.
- LifecycleProperties
-
The shutdown:
spring.lifecycle.*. - ListableBeanFactory
- A bean factory that can list its beans: all names, the beans of a type, the beans carrying an annotation.
- ListenerRegistration
-
What
ApplicationContext.addListenerreturns: call remove to stop the listener. -
ListType<
E> -
The TypeInfo of a
List<E>, with the description of its elements:ListType<Book>(ClassType<Book>()). - LiteralExpression
-
An expression whose value is fixed text: a template with no
#{...}in it, or a text part of a template. - LivenessStateHealthIndicator
-
UPwhile the application is LivenessState.correct,DOWNwhen it is broken: thelivenessStateof thelivenessgroup. - Locales
-
Helpers for locales written as strings, such as
de_CH. - Log
-
An annotation that gives a class a ready-made
loggetter, so its methods can log without declaring a logger. - LogAppender
- One output of the logging system: it receives every log record that passes the logger levels and writes it somewhere.
- LogBuffer
- The most recent log records, kept in memory so the application can show them: records, filtering with LogQuery, live streams, counters and text export.
- LogFormatUtils
- Formats values for log lines: what the framework writes about values from outside (a path, a user name, a header) goes through it.
- LoggingSystem
-
Where log records go once this starter is installed: it receives every
record written through
SpringLogand sends it to the console, the in-memory buffer, the log file and any appender you added. - LoggingSystemInitializer
- The bean that ties the LoggingSystem to the life of an application context. Applications never use it; the starter registers it.
- LogPattern
-
A log line format: a pattern such as
%d %5p [%logger] %m, read once, that turns each SpringLogRecord into text. - LogQuery
-
A filter for the records of a LogBuffer, such as "warnings and
errors of
neon.shopthat mention payment". - Lookup
- Marks a method that returns a bean of the container on every call.
- ManagementHealthProperties
-
The
management.health.*properties: which health indicators exist. - ManagementInfoProperties
-
The
management.info.*properties: which info contributors exist. - MapAccessor
-
A PropertyAccessor that treats the entries of a map as properties,
so
user.nameworks whenuseris a map such as decoded JSON. - MapBindingResult
- A BindingResult for values held in a map instead of an object.
- MappingDescriptions
-
Describes the addresses a part of the application answers, for
/actuator/mappingsand the editor: the web server's handlers, the static resources, an app's screens. - MappingsEndpoint
-
The
mappingsendpoint: every address the application answers, from every MappingDescriptions bean, under itsmappingsName. - MappingsEndpointProperties
-
The
management.endpoint.mappings.*properties. - MapPropertySource
- A property source over a map of keys to values.
-
MapType<
K, V> -
The TypeInfo of a
Map<K, V>, with the descriptions of its keys and values:MapType<String, int>(ClassType<String>(), ClassType<int>()). - MapValueResolver
- A ValueResolver that reads the values from a map keyed by parameter path, the one to use with DataBinder.construct in most cases.
- Matches
- A constraint that requires a string to match the regular expression regexp as a whole.
- Max
- A constraint that requires a number of at most value.
- MergedBeanDefinitionPostProcessor
- A BeanPostProcessor that is shown each bean definition once, when its first bean has been constructed and before it is injected.
- MessageCodesResolver
- The rule that turns an error code and a field into the list of message codes an error carries.
- MessageFormat
-
Fills arguments into a message pattern such as
Hello {0}!, using the syntax of Java'sMessageFormat, which message files are written in. - MessagesBundleCondition
-
A condition that matches when the message bundle exists, that is when
resources:<basename>.propertiesexists for one of the configured basenames. - MessageSource
- Turns a message code and a locale into a text in that language, with the arguments filled in.
- MessageSourceAccessor
- A wrapper around a MessageSource that remembers a locale, so that lookups need not pass it every time.
- MessageSourceAware
- Implemented by a bean that wants the translated messages handed to it through a method call.
- MessageSourceResolvable
- A message described by codes rather than text: the codes to look up, the arguments to fill in and a default text.
- MethodInterceptor
-
Code that runs around calls of other beans, written as a class instead
of an
@Aspectmethod. - MethodInvocation
- One intercepted call as a MethodInterceptor sees it: the call's details plus a way to continue it.
- MethodResolver
-
A plug-in that tells expressions which code to run for a method call
such as
greeter.greet('Ada'). - MethodSignature
- What is known about an advised member without calling it: its name, its types, its annotations and those of its class.
- MethodValidationInterceptor
- The AOP advice that checks the arguments and the return value of a call against the method's constraints.
- MethodValidationPostProcessor
-
The bean that turns on method validation: it applies a
MethodValidationInterceptor to every bean whose class is annotated
@Validated(). - Min
- A constraint that requires a number of at least value.
- MissingNode
-
The stand-in that JsonNode.path and JsonNode.at return where the
document has no node, so navigation can go on without
nullchecks. - MustBeNull
-
A constraint that requires the value to be
null, usually in one validation group only. - MutablePropertySources
- The ordered list of property sources an environment reads from; for each key, the first source that has it wins.
- Name
-
Gives a
@ConfigurationPropertiesfield or constructor parameter a property name other than its Dart name. - Named
- Marks a class as a bean, or selects a bean at an injection point; the standard Java (JSR-330) name for Component and Qualifier.
- NameMatchMethodPointcut
-
A pointcut that matches members by name, with
*wildcards. - Negative
- A constraint that requires a number below 0.
- NegativeOrZero
- A constraint that requires a number of 0 or less.
- NotBlank
-
A constraint that requires text with at least one visible character:
null,''and' 'fail. - NotEmpty
-
A constraint that requires a string, list, set or map that is neither
nullnor empty. - NotNull
-
A constraint that requires a value:
nullfails, anything else passes. - NullBean
-
The object that stands for a bean whose
@Beanmethod (orcreatecallback) returnednull. - NullNode
-
A JSON
nullvalue, which is present (unlike a MissingNode). - NumericNode
-
A JSON number: an
intwhen the JSON had no fraction, else adouble. - ObjectError
- A validation error about a whole object rather than one of its fields, such as "the passwords differ" or a failed class-level constraint.
-
ObjectFactory<
T extends Object> -
Something that returns an object of
Twhen asked: the smallest form of a lazy dependency. - ObjectMapper
- Converts Dart objects to JSON and back: the one place where models, JSON text, decoded maps and JsonNode trees meet.
- ObjectNode
- A JSON object: named child nodes, kept in insertion order.
-
ObjectProvider<
T extends Object> -
A handle on the beans of
Tthat looks them up only when asked: one bean, the bean if there is one, or all of them. - ObjectReader
-
A reader bound to one
@JsonView: it reads only the properties of that view and skips the others, with its mapper's settings. - ObjectWriter
-
A writer bound to one
@JsonView: it writes only the properties of that view, with its mapper's settings. - Observation
- One measured piece of work: started, maybe failed, stopped, with a name and tags. Its handlers turn it into a log line, a metric or a bar of a timeline.
- ObservationContext
- What an ObservationHandler is told about one observation: its name, tags, timing, error and parent.
- ObservationHandler
- Told when an observation starts, fails and stops: it turns observations into something (a log line, a metric, a span of a trace, a bar of a debug timeline).
- ObservationRegistry
- Creates observations and holds the ObservationHandlers they report to.
- Observed
- Measures the calls of a method, or of every method of a class: each call runs in an Observation of the application's ObservationRegistry, through the ObservedAspect.
- ObservedAspect
-
The aspect behind Observed: runs each call of an observed method in
an Observation of registry, stopped when the call returns or, for
a method returning a
Future, when the future completes; an error is recorded and passed on. - ObservedInterceptor
- The advice of ObservedAspect as a method interceptor, for an advisor bean with ObservedPointcut: each call in an observation of the registry.
- ObservedPointcut
-
The pointcut of the members marked
@Observed: a method marked, or a method of a class marked (not its getters and setters), for ObservedInterceptor in an advisor bean. - OperationParameter
- One parameter of an endpoint operation.
- OperationResponseBody
- A value an operation answers that writes itself as JSON, like the health and the mappings: toJson gives maps, lists and plain values.
- OperatorOverloader
-
A plug-in that gives arithmetic operators a meaning for your own types,
such as
+on two money amounts. - OptInInfoContributorProperties
-
The properties of a contributor that is off by default (
env,os,dart). - Order
-
An annotation that gives a bean (or a
@Beanmethod, an event listener method) its place when several are run or injected in turn; lower values come first. - OrderComparator
- Sorts objects the way the framework does: PriorityOrdered first, then by order value, objects with equal values keeping their original order.
- Ordered
- An object that says where it goes when several objects of its kind are run or listed in turn; lower numbers come first.
- OsInfoContributor
-
The
osdetails: the operating system's name, version and architecture. Off by default:management.info.os.enabled=true. - ParserContext
- Tells the parser whether a text is one expression or a template of literal text with embedded expressions, and which delimiters mark them.
- Past
-
A constraint that requires a
DateTimebefore now. - PastOrPresent
-
A constraint that requires a
DateTimethat is not in the future. - PathMatcher
-
Tests paths such as
config/dev/app.propertiesagainst patterns with wildcards such asconfig/**/*.properties, and pulls values out of them. - PathMatchingResourcePatternResolver
-
The ResourcePatternResolver used everywhere: it expands Ant-style
patterns (
*,**,?) infile:and classpath locations. -
PayloadApplicationEvent<
T extends Object> - The envelope the context puts around a published object that is not an ApplicationEvent, adding a source and a timestamp.
- PingHealthIndicator
-
Always
UP: the application answers. The report'sping. - Pointcut
- Gives a pointcut expression a name, so several advice methods can share it.
- PointcutAdvisor
- An Advisor that applies only to the members its pointcut selects.
- Positive
- A constraint that requires a number greater than 0.
- PositiveOrZero
- A constraint that requires a number of 0 or more.
- PostConstruct
- Marks a method the container calls once a bean is fully injected, before anyone uses it.
- PreDestroy
- Marks a method the container calls when a bean is destroyed: when the context closes for a singleton, when its scope ends for a scoped bean.
- Primary
- Makes this bean the one injected when several beans have the requested type.
- PrimaryIsolate
-
Asks the application's first isolate: the bean
primaryIsolate. - PrimaryIsolateHandler
- Something the application's first isolate answers for all of them: a bean that implements it is asked there, whichever isolate the question comes from (PrimaryIsolate.ask).
- PrimaryIsolateRateLimitHandler
- The first isolate's side of PrimaryIsolateRateLimitStore: it answers the isolates' questions from one InMemoryRateLimitStore.
- PrimaryIsolateRateLimitStore
-
The buckets of every isolate in one place, the application's first
isolate: the RateLimitStore of a server with a pool of isolates
(
server.isolates.*;spring.web.rate-limit.store: primary-isolate). - Principal
- The identity of whoever makes a request: a user, a client application or another service, reduced to a name.
- PrincipalRoleChecker
- Tells whether a principal has a role, for SecurityContext.isUserInRole.
- PriorityOrdered
- An Ordered object that goes before every plain Ordered one, whatever the numbers.
- ProceedingJoinPoint
-
The JoinPoint of
@Aroundadvice, which can also run the call. - Profile
- Registers a bean only when the active profiles match.
- ProfileCondition
-
The condition behind
@Profile: it matches when one of its profile expressions matches the active profiles. - Profiles
-
A condition on profiles, such as "
dev, andeuorus", parsed once and tested against the active profiles. - ProjectInfoLocation
- Where a properties file of project information is.
- ProjectInfoProperties
-
The
spring.info.*properties: where the build and git information is read from. - PropertiesJsonSchemas
-
The customizer of the schemas the app names: the
spring.json.schemaslocations, the location of each@JsonSchemaSourceamong the introspections, and everyJsonSchemabean. A location is read fromresources:, a remote one from the copy the build keeps (JsonSchemaLocations.resourceOf); each is added under its location, which theObjectMapperlooks up. A bean is added under its$id. - PropertiesLoaderUtils
-
Reads a
.propertiesResource into a map of keys to values in one call. - PropertiesParser
-
Reads text in the
.propertiesformat (key=valuelines) into a map. - PropertiesPropertySourceLoader
-
The reader for
.propertiesconfig files, used forapplication.propertiesand its profile variants. - PropertyAccessor
-
A plug-in that tells expressions how to read and write the properties
of some kind of object, so that
point.xworks. - PropertyPlaceholderHelper
-
The engine that replaces
${name}and${name:default}placeholders in text, looking each name up with a function you give. - PropertyResolver
-
Reading properties by key: as text or as a typed value, with or without
a default, and resolving
${...}placeholders in any text. - PropertySource
- Adds property files to the environment, on top of the application's configuration files.
- PropertySourceDeclaration
-
One
@PropertySourceannotation, recorded in a BeanModule: which property files to add to the environment, and when. - PropertySourceFactory
-
Turns a file named in
@PropertySourceinto a property source; write one to let@PropertySourceread a format other than.properties. - PropertySourceLoader
- A reader for one config file format: it turns the text of a file into property sources, one per document in the file.
- PropertySourceProcessor
-
The code that reads the files of
@PropertySourceannotations into an environment. - PropertySourcesPropertyResolver
-
The property resolver that reads from a list of property sources, the
first source with a non-
nullvalue winning. - PropertyValues
-
What the editor offers for a field of a
@ConfigurationPropertiesclass: fixed values for aStringfield that must stay aString, or a provider that lists them at run time. - ProtocolResolver
-
A plug-in that teaches a resource loader a location prefix of its own,
such as
asset:ordb:. - ProxyFactory
- Builds extra proxies of a bean in code, with advice chosen by the caller rather than by the context's aspects.
- ProxyInvoker
- The runtime engine behind one proxy: it runs each call of a proxied member through the advice that matches that member.
- ProxyMethod
- The description of one method of an interface proxy: its name, parameters, return type and annotations, and a way to call it.
- ProxyTargetClass
- Marks an annotation class whose members' advice must also see the calls a bean makes on itself, and every member of the bean, not only the annotated ones: reactive state, where a method of the bean assigns a field another member is computed from.
- Qualifier
- Picks one bean among several of the same type, by a label or a bean name.
- RandomValuePropertySource
-
A property source that makes up a new random value for every key that
starts with
random.. - Range
-
The numeric bounds of a
@ConfigurationPropertiesfield, for the editor metadata only (rangeinspring_metadata.json). - RateLimit
- How much one key may do: count permits every period, with a burst of capacity.
- RateLimitDecision
- What a RateLimitStore answered: whether the permits were taken, what is left, and when to come back.
- RateLimitMemoryProperties
-
The
spring.web.rate-limit.memory.*properties. - RateLimitProperties
-
The
spring.web.rate-limit.*properties: the web starter's rate limiter and where it keeps its buckets. - RateLimitRuleProperties
-
One rule of
spring.web.rate-limit.rules. - RateLimitStore
- Where the rate limiter keeps its buckets: one operation, which is atomic.
- RawValue
-
Marks a string property whose value is bound as written, without
resolving
${...}placeholders. - ReadinessStateHealthIndicator
-
UPwhile the application accepts traffic,OUT_OF_SERVICEwhen it refuses it: thereadinessStateof thereadinessgroup. - ReadOperation
-
Marks a method of an Endpoint (or EndpointWebExtension) bean as a
read operation:
GETover HTTP. - RecordedStartupStep
- A step that BufferingApplicationStartup recorded: when it began and how long it ran.
- ReloadableResourceBundleMessageSource
-
A message source that reads its texts from
.propertiesfiles, one file per language, and can re-read them when they change. - RemoteAddress
- An address in the configuration that something is downloaded from: a theme, an image, a page loader. RemoteAddresses reads it from the value as written, through its chain of RemoteAddressResolvers.
- RemoteAddresses
-
The addresses of the configuration: a chain of
RemoteAddressResolvers, the application's own first (in their
order, by
Orderedwhen they implement it), then the built-in ones (GitHubAddressResolver, UrlAddressResolver). Every feature that downloads (themes, images, page loaders) reads its addresses here, so they all accept the same kinds and a new kind works everywhere. - RemoteAddressPolicy
-
Whether the addresses of the configuration may use insecure
connections:
http://, andhttps://with a certificate that is expired, self-signed or for another host. Not by default: an insecure address stops the start. Withspring.remote.allow-insecure=truethey work, and a warning lists them. - RemoteAddressResolver
-
Reads one kind of address of the configuration: a scheme or a shorthand
(
github:, a company'scdn:). RemoteAddresses asks its resolvers in order, and the first that supports a value resolves it: a chain of responsibility, so a new kind of address is a new resolver, not a change of the others. - RenamedPropertiesEnvironmentPostProcessor
- Stops the start when a property still has the name Spring Boot gives it and this project has renamed.
- Repository
- Marks a class as a bean that stores and loads data.
- ResolvableAttribute
-
A string attribute of a constraint, such as the regular expression of
@Matches, passed as an argument of a field error. - Resource
-
A piece of content the application reads, wherever it lives: a file of
lib/resources/(the classpath), a file on disk, a URL, a Flutter asset, bytes in memory. - ResourceBanner
-
A banner whose text comes from a file, such as
lib/resources/banner.txt. - ResourceLoader
-
Turns a location string such as
resources:mail.txt,file:./data.csvorhttps://...into a Resource to read. - ResourceLoaderAware
-
Implemented by an object that wants the context's resource loader (to
read files such as
resources:templates/mail.txt) handed to it through a method call. - ResourcePatternResolver
-
A ResourceLoader that also finds all resources matching a pattern
with wildcards, such as
resources:templates/*.htmlorfile:config/**/*.properties. - ResourcePropertySource
-
A property source with the properties of one
.propertiesfile. - ResourceRoot
-
A set of files that is no directory on disk and not embedded: what
Resources.addRoot adds to
resources:(files the build left out of the binary) and Resources.addProtocolRoot to a protocol of its own (asset:), so their patterns (**/*.md) list them. - Resources
-
The registry behind
resources:locations: the files oflib/resources/of the application and of its dependencies. - Scope
- Sets how many instances of a bean exist and how long each one lives.
- ScopeType
-
The names of the two built-in scopes, for
@Scope(...)andBeanDefinition.scope. - SecurityContext
-
The user of an operation's request, for an operation that shows more
to some users (the health endpoint's
show-details=when-authorized). - Selector
-
Marks a parameter of an operation as a path segment: the operation of a
method with a
@Selector() String nameanswers/actuator/<id>/{name}. - SelfCallInterceptor
-
A MethodInterceptor that also runs for the calls a bean makes on
itself, in a proxy that advises them
(
AopProxyFactory.adviseSelfCalls, a bean with a member whose annotation is marked@ProxyTargetClass()). - Service
- Marks a class as a bean that holds business logic.
-
SetType<
E> -
The TypeInfo of a
Set<E>, with the description of its elements:SetType<String>(ClassType<String>()). - Sha256
- SHA-256 (FIPS 180-4) and HMAC-SHA-256 (RFC 2104) in plain Dart, for the framework's own needs on every platform (the VM, JavaScript and WebAssembly): a digest of a key, a keyed hash of an address. It has no dependency.
- SimpleApplicationEventMulticaster
- The standard ApplicationEventMulticaster: it calls the accepting listeners in order, in the publishing call or on a task executor.
- SimpleAsyncTaskExecutor
-
A TaskExecutor that runs each task in a later event-loop turn
(
Timer.run), so the caller goes on first. - SimpleCommandLinePropertySource
-
The property source over the program's command-line arguments, so that
--server.port=9090sets the propertyserver.port. - SimpleEvaluationContext
- An evaluation context that only lets an expression read (and, if allowed, write) properties: the one to use for expressions that come from outside, such as a filter typed by a user or a field path sent by a client.
- SimpleEvaluationContextBuilder
- Sets up a SimpleEvaluationContext: which methods, index accessors, conversions and root object it has.
- SimpleHealthEndpointGroup
- A HealthEndpointGroup from the properties: the members it includes minus those it excludes, and its settings.
- SimpleHttpCodeStatusMapper
-
An HttpCodeStatusMapper by a map of status codes (compared as by
SimpleStatusAggregator.uniformCode);
200for a status it does not name. - SimpleMapScope
- A ready-made CustomScope that keeps its instances in a map until you call destroy.
- SimpleStatusAggregator
-
A StatusAggregator by an order of status codes: the aggregate is
the status that comes first. Codes are compared in upper case without
other characters than letters and digits (
out-of-serviceisOUT_OF_SERVICE); statuses not in the order are left out. - SingletonBeanRegistry
- The part of the container that accepts ready-made objects as beans.
- Size
- A constraint on the length of a string, or the number of entries of a list, set or map: from min to max, both included.
- SmartApplicationListener
- A GenericApplicationListener that decides by the runtime types of the event and its source, and has an order among the listeners.
-
SmartFactoryBean<
T extends Object> - A FactoryBean that tells the container more about its product: whether it is a prototype, whether to create it at startup, and which other types it can serve.
- SmartInitializingSingleton
- A singleton that wants a call once every non-lazy singleton has been created, at the end of startup.
- SmartInstantiationAwareBeanPostProcessor
- An InstantiationAwareBeanPostProcessor that can also tell the type a bean will have before it is created.
- SmartLifecycle
- A Lifecycle bean that the context starts by itself at the end of the refresh and stops in order at shutdown.
- SmartValidator
- A Validator that can check only the constraints of some validation groups.
- SpelExpression
- One parsed SpEL expression: the syntax tree of the text and the parser options it runs under.
- SpelExpressionParser
- The parser of the Spring Expression Language: it turns expression text into an Expression you can evaluate.
- SpelLimits
- The fixed size limits of what one operator may build, which keep a hostile expression from exhausting memory or time.
- SpelNode
- One node of a parsed expression's syntax tree: a literal, a property reference, an operator, a method call, ...
- SpelOperations
-
The operators of SpEL as plain functions: what an expression computes
for
/,==,<,+on text,andand the like, apart from the tree that holds the operands. - SpelParserConfiguration
-
The options of a
SpelExpressionParser: the limits that protect against hostile or runaway expressions, and auto-grow for data binding. - SpelParserConfigurationBuilder
- Builds a SpelParserConfiguration, starting from the defaults.
- SpelPatterns
-
The compiler of the regular expressions used by
matches(the operator and the String method), with Spring's length limit and a guard against patterns that could hang the program. - SpelType
- The description of a type that expressions may name: its name, its static fields and methods, its constructor, and how to test an instance.
- SpelTypeConstructorResolver
-
The default ConstructorResolver: it runs the constructor function
registered on a SpelType for
new Name(...). - SpelTypeMethodResolver
-
The MethodResolver for static methods,
T(Name).method(...): it runs the functions listed in SpelType.staticMethods. - SpringApplication
- Starts an application: reads its configuration, creates its beans and runs its startup tasks, in a fixed and documented order.
- SpringApplicationEvent
- A step of the application's start, announced to listeners.
- SpringApplicationJsonEnvironmentPostProcessor
-
Reads properties given as one JSON document, in the
SPRING_APPLICATION_JSONenvironment variable or thespring.application.jsonproperty. - SpringBootApplication
-
Marks the
mainfunction of an application, so that the generator writes everything needed to start it. - SpringBootBanner
-
The banner printed when the application sets none: the Spring logo in
ASCII art and the
spring_boot_dartversion. - SpringFactories
-
What the starters of an application add to it before its beans exist:
the constants of every
AutoConfigurationModule.factories, found by their type. - SpringHotReload
- Restarts a running server or command-line application when its beans change during a hot reload on the Dart VM.
- SpringLog
- A named logger: the object code logs through, and the static switches (levels, handler, holds) of logging as a whole.
- SpringLogHold
- The records held back by one SpringLog.hold, until release.
- SpringLogRecord
- One logged message with everything known about it, as a log handler receives it.
- StandardBeanExpressionResolver
-
Evaluates the
#{...}parts of@Valuestrings (and of other framework values, such as@ConditionalOnExpression) against the beans of a bean factory. - StandardEnvironment
- The environment implementation used everywhere: an empty list of property sources except the environment variables, plus profiles.
- StandardEvaluationContext
- An evaluation context with every feature of the language enabled: the one to use for expressions you or your application wrote.
- StandardOperatorOverloader
-
The default OperatorOverloader: it takes over no operator, so
arithmetic on operands without a built-in rule fails with
operatorNotSupportedBetweenTypes(EL1030E). - StandardTypeComparator
-
The default TypeComparator: it orders numbers, strings, dates,
durations, booleans, enums and other
Comparables, withnullbefore everything. - StandardTypeConverter
- The default TypeConverter: it hands every conversion to a ConversionService.
- StandardTypeLocator
- The usual TypeLocator: a registry of SpelTypes by name, with the core Dart types and the common Java names already in it.
- StartupPacer
- Asked between two beans while the context creates its singletons: may the start go on, or should it let something else run first? A paused start lets a UI draw its frames (a splash that moves while the beans are made), at the price of a longer start.
- StartupProgress
-
How far an application's start has come, as
SpringApplicationreports it to SpringApplication.progressListener: done of total steps, where a step is a bean definition created or a runner called. - StartupStep
- One step of the application's start, measured: created by ApplicationStartup.start, tagged with what it is about, ended with end.
- StaticMessageSource
- A message source whose messages are added in code rather than read from files.
- Status
-
The state of a part of the application in a health report:
UP,DOWN,OUT_OF_SERVICE,UNKNOWN, or a code of the application's own. - StatusAggregator
- Combines the statuses of several parts into one: the first of them in an order of severity.
- StringNode
-
A JSON string. asInt, asDouble and asBoolean convert numeric and
"true"/"false"text. - SyncTaskExecutor
- A TaskExecutor that runs each task right away, in the calling code.
- SystemEnvironmentPropertySource
-
The property source over the operating system's environment variables,
which finds
server.portin the variableSERVER_PORT. - SystemHealthDescriptor
-
The health of the whole application, the root of
/actuator/health: a composite that also lists the names of the health groups. - TaskExecutor
- Something that runs a task now or later, so that the code handing it over does not have to wait.
- TemplateParserContext
- A template ParserContext with delimiters of your choice.
- TimerDrivenWork
- A bean that runs work by itself, on timers, outside any request: scheduled methods.
- TokenBucket
- The arithmetic of one token bucket: its tokens at the time updatedMicros, and tryAcquire.
- TruePointcut
- A pointcut that matches every member of every bean.
-
TypeCapture<
T> - A type kept as a value, to be used as a type again: what a generic method needs when it is given only an object.
- TypeComparator
-
Decides how two values are ordered for
<,<=,>,>=andbetween. - TypeConverter
- Converts a value to another type while an expression is evaluated.
-
TypeInfo<
T> -
A description of a full Dart type, such as
List<Book>orString?, that code can take apart at run time without reflection. -
TypeInfoVisitor<
R> - One method per kind of TypeInfo, called by TypeInfo.accept with the kind's type arguments in scope.
- TypeLocator
-
Finds the type a name stands for in
T(Name),new Name(...)andinstanceof T(Name). - UrlAddressResolver
-
https://andhttp://URLs as written. - UrlResource
- A Resource on a web server, read with an HTTP GET request.
- Valid
- An annotation that asks for the constraints inside an object to be checked: of a nested object, of the objects in a list, set or map, or of a request body or method argument.
- Validated
- An annotation that asks for validation, optionally with validation groups.
- ValidationUtils
- Static helpers for writing and running a Validator.
- Validator
- A check of an object written in code: it looks at the object and records each problem in an Errors.
- Value
- Injects a value from the configuration (properties, environment variables) or from an expression, instead of a bean.
- ValueRef
- A handle on the place an assignable expression names (a property, a variable, a list or map element), to read and write it.
- ValueResolver
- The source of the input values when DataBinder.construct creates an object through its constructor.
- VarargsFunction
-
A wrapper that lets a Dart function accept any number of trailing
arguments when an expression calls it, like a Java varargs method
(
String.join(delimiter, String... elements)). - VerifiableRateLimitStore
- A RateLimitStore that can say, when the application starts, whether what it keeps its buckets in is there: a table, a database function, a binding.
- VersionedResource
- A resource that knows the version of its content: a file downloaded and kept, whose digest says which content it holds now.
- WarnValues
-
Values of a
@ConfigurationPropertiesfield that are accepted but that the editor should warn about, with the reason in message. -
WebEndpointResponse<
T> -
An answer of an operation over HTTP with its own status (and media
type), for an EndpointWebExtension that answers more than
200. - YamlPropertySourceLoader
-
The reader for YAML config files (
.yml,.yaml), used forapplication.ymland its profile variants.
Enums
- AdviceKind
- The five kinds of aspect advice, one per annotation, listed in the order they nest inside one aspect.
- ApiVersion
-
The version of the actuator's JSON a client asked for, by its media
type:
application/vnd.spring-boot.actuator.v3+json(and plainapplication/json) or...v2+json. - BannerMode
- Where the startup banner goes: the console, the log, or nowhere.
- BuildInclusion
- Where an AutoConfigurationBuild module goes when its property is not set.
- ChronoUnit
- A unit of time, from nanoseconds to days: the unit in which a plain number is read as a duration.
- CloudPlatform
- A cloud platform an application can run on (Kubernetes, Heroku, Cloud Foundry, ...), recognised from the environment variables the platform sets.
- ConfigurationPhase
- The moment of loading at which a ConfigurationCondition is decided.
- ConfigurationPropertyNameForm
- How an element of a ConfigurationPropertyName is returned by ConfigurationPropertyName.getElement: as written, dashed or reduced to letters and digits. Bracketed elements are always returned as written.
- DataUnit
- A unit a DataSize can be written in, each 1024 times the one before.
- DateTimeFeature
-
On/off settings for writing and reading
DateTimeandDuration, named after Jackson 3'sDateTimeFeature(set byspring.json.datatype.datetime.*; Spring Boot 4:spring.jackson.datatype.datetime.*). - DependencyKind
-
The form of an injection point that a Dependency describes: one bean,
all beans of a type, a provider, a
@Value, and so on. - DeserializationFeature
-
On/off settings for reading JSON, named after Jackson's
DeserializationFeature; the defaults are Spring Boot's. - EndpointAccess
-
What may be done with an endpoint, set by
management.endpoint.<id>.accessandmanagement.endpoints.access.default. - FilterType
- How a Filter decides whether a class matches.
- InfoPropertiesMode
- How much of a properties file an info contributor shows.
- IntrospectionPart
- A part of an introspected class that a BeanIntrospection may leave out.
- JsonFormatShape
-
The JSON shapes JsonFormat.shape can ask for (Jackson's
JsonFormat.Shape). - JsonInclusion
-
Which property values are written, for JsonInclude and the mapper's
inclusion(Jackson'sJsonInclude.Include). - JsonPropertyAccess
-
The directions a property takes part in, for JsonProperty.access
(Jackson's
JsonProperty.Access). - JsonTypeId
-
What identifies the subclass in JSON, for JsonTypeInfo.use
(Jackson's
JsonTypeInfo.Id). - JsonTypeInclusion
-
Where the type id is placed, for JsonTypeInfo.include (Jackson's
JsonTypeInfo.As). - LivenessState
- Whether the application's internal state is correct: a broken application cannot recover by itself and should be restarted.
- MapperFeature
-
On/off settings that change how the mapper sees classes, named after
Jackson's
MapperFeature. - MemberKind
- Whether an advised member is a method, a getter or a setter.
- ModulePlatform
- The platforms an AutoConfigurationModule can be kept to.
- Operation
- The arithmetic operators an OperatorOverloader can take over.
- OperationType
- The kind of an endpoint operation: what it does and the HTTP method it answers.
- PatternFlag
- Options for the regular expression of Matches and Email, such as matching without regard to case.
- PropertyNamingStrategy
-
A rule that turns Dart property names (
publishedAt) into JSON names (published_at), applied to every property of a class or of the whole mapper. - RateLimitStoreFailure
-
What happens to a request when the rate limiter's store cannot be
reached (
on-store-failure). - ReadinessState
- Whether the application is ready to take requests.
- ScopedProxyMode
-
Whether a bean of a custom (or prototype) scope is injected directly or
through a scoped proxy (
@Scope(proxyMode:)). - SearchStrategy
- Which contexts ConditionalOnBean and ConditionalOnMissingBean search for beans, when contexts have parents.
- SelectorMatch
- How many path segments a Selector parameter takes.
- SerializationFeature
-
On/off settings for writing JSON, named after Jackson's
SerializationFeature. - Show
- Who is shown the details or the components of a health report.
- SpelMessage
-
The catalogue of SpEL failures: each value is one kind of error with
its code (
EL1005E) and message text. - SpelMessageKind
- The severity of a SpelMessage. Every message defined today is an error; the other kinds exist because Spring defines them.
- SpringLogLevel
- How important a log message is, from trace (most detail) to error; off silences a logger.
Mixins
- AdvisedSubclass
-
The Advised members of a generated subclass proxy, the bean itself:
its members call
superdirectly until advice is attached by setting aopInvoker. - AdvisedWrapper
- The Advised members of a generated wrapper proxy, which holds the bean and runs its calls through aopInvoker.
Extensions
-
NamedArguments
on Map<
Symbol, Object?> -
How generated code reads an optional named argument from the map of a
BeanConstructor or BeanMethod call, as
Function.applypasses it: the value when the map has it, else the parameter's default. -
PositionalArguments
on List<
Object?> -
How generated code reads an optional positional argument from the list
of a BeanConstructor or BeanMethod call, as
Function.applypasses it: the value when the list is long enough, else the parameter's default.
Constants
- springBootVersion → const String
-
The version of
spring_boot_dartthis program was built with.
Properties
- actuatorProperties → BeanModule
-
The typed properties of the actuator (
management.*,spring.info.*), scanned in this folder. The actuator starter imports the module.final - bootPropertiesBeans → BeanModule
-
The typed properties of
spring_boot_dart(spring.main.*,spring.messages.*,spring.json.*...), scanned in this folder.final -
loggingAutoConfiguration
→ List<
BeanDefinition< Object> > -
The bean definitions this starter adds to every application that
depends on it.
final
- printLogHandlerColours ↔ bool
-
Whether printLogHandler colours its lines with ANSI escape codes.
getter/setter pair
- printLogHandlerOut ↔ void Function(String line)
-
Where printLogHandler writes its lines: standard output on the Dart
VM,
printin Flutter (the device log) and on the web (the browser's console). Replace it to send them elsewhere, or in a test of the output.getter/setter pair
Functions
-
analyzeFailure(
Object error, {Iterable< FailureAnalyzer> analyzers = const []}) → FailureAnalysis? -
Explains a startup error: the FailureAnalysis that
SpringApplicationprints when the start fails, ornullwhen nothing recogniseserror. -
bindRateLimitProperties(
Environment environment) → RateLimitProperties -
The
spring.web.rate-limit.*properties ofenvironment, bound: for a condition, which runs before any bean exists. -
conditionsMatch(
Iterable< Condition> conditions, ConditionContext context, {ConfigurationPhase? phase, String? source}) → bool -
Whether every one of
conditionsmatches; the context calls it for each definition while the modules load. -
hasPhaseCondition(
Iterable< Condition> conditions, ConfigurationPhase phase) → bool -
Whether
conditions(also inside a ConditionGroup) include a ConfigurationCondition ofphase; the context uses it to tell which definitions must wait for theregisterBeanphase. -
healthContributorName(
String beanName) → String -
The name of the health contributor bean
beanNamein the report: the name without the suffixHealthIndicatororHealthContributor(in any case). -
isEndpointEnabled(
PropertyResolver environment, EndpointId id, {bool enableByDefault = true}) → bool - Whether an endpoint is enabled, from the properties, in this order:
-
jsonMapperBuilderFromProperties(
Environment environment, {BeanIntrospector? introspector, Iterable< JsonSerializer< serializers = const [], Iterable<Object> >JsonDeserializer< deserializers = const [], Iterable<Object> >JsonModule> modules = const []}) → JsonMapperBuilder -
The JsonMapperBuilder that objectMapperFromProperties would build,
with the
spring.json.*properties ofenvironmentapplied. -
nestedInfo(
Iterable< MapEntry< entries) → Map<String, Object?> >String, Object?> -
entriesas nested maps, split at the dots of their keys (commit.idis{"commit": {"id": ...}}), as Spring Boot's binder makes of them. Where a key is both a value and a prefix (commit.idandcommit.id.abbrev), the value is kept underfullnext to the longer keys. -
objectMapperFromProperties(
Environment environment, {BeanIntrospector? introspector, Iterable< JsonSerializer< serializers = const [], Iterable<Object> >JsonDeserializer< deserializers = const [], Iterable<Object> >JsonModule> modules = const []}) → ObjectMapper -
Builds an ObjectMapper from the
spring.json.*properties ofenvironment, the same way the auto-configured bean is built. -
parseDataSize(
String value) → int -
Reads a size written in a property, such as
logging.file.rolling-policy.max-file-size, and returns it in bytes. -
parseSpringLogLevel(
String? value) → SpringLogLevel? -
Reads a level name as written in configuration (
logging.level.*):trace,debug,info,warnorwarning,error(alsofatal) andoff, in any case and with spaces around.nullfor anything else, so the caller can report the bad value. -
pointcutMatchesBean(
AopPointcut pointcut, MethodSignature signature, String beanName, List< String> beanAliases, {List<String> introducedTypes = const []}) → bool -
Whether
pointcutmatches the membersignatureof the beanbeanName, with everything the bean is known by. -
printLogHandler(
SpringLogRecord record) → void -
The SpringLog.handler used until a logging backend replaces it:
writes each record as one line,
[logger] LEVEL: message, to standard output on the Dart VM, to the device log in Flutter and to the browser's console on the web. -
retypeFuture<
T> (Object? value) → Future< T> -
Turns the result of an advised call into a
Future<T>. -
selectAutoConfigurations(
List< BeanModule> modules, {Map<BeanModule, AutoConfigurationModule> metadata = const {}, Iterable<Type> excludeTypes = const [], Iterable<String> excludeNames = const []}) → List<BeanModule> - Takes the auto-configuration modules of the libraries an application uses, drops the excluded ones and returns the rest in the order they must be registered.
-
wildcardMatch(
String pattern, String text) → bool -
Whether
textmatchespattern, where*stands for any characters.
Typedefs
- BeanConfigurer = void Function(Object bean, DependencyResolver resolver)
-
A function that injects the dependencies of an object the container
did not create, an instance of a
@Configurableclass. -
ConstructorExecutor
= Object? Function(EvaluationContext context, List<
Object?> arguments) -
The function a ConstructorResolver returns to run one
new Name(...): it gets the evaluated arguments and returns the new object. -
DiskSpaceReader
= Future<
DiskSpace?> Function(String path) - Measures the DiskSpace of a path.
- JsonSchemaResolver = JsonSchema? Function(String location)
-
Finds the JsonSchema of a
@JsonSchemaSourcelocation, forObjectMapper.schemaResolver;nullwhen there is none. -
MethodExecutor
= Object? Function(EvaluationContext context, Object target, List<
Object?> arguments) - The function a MethodResolver returns to run one method call: it gets the target and the evaluated arguments and returns the result.
- SpringLogHandler = void Function(SpringLogRecord record)
- A function that receives log records: the type of SpringLog.handler (where records go) and of SpringLog.listen listeners.
- StringValueResolver = String Function(String value)
-
A function that resolves the
${...}placeholders in a string and returns the result.
Exceptions / Errors
- AccessException
- The exception a plug-in (property or index accessor, method, constructor or bean resolver, executor) throws to say it could not do its job.
- AopConfigException
- Thrown when AOP is set up in a way that cannot work, usually at startup: advice matches a bean that cannot be proxied, an aspect has an unsupported instantiation model, or a proxy's advisors are changed although it has none.
- AopInvocationException
-
Thrown by an advised call when the advice cannot run as written, like
Spring's
AopInvocationException. - ApplicationContextException
- The error a context throws when one of its own steps fails, as opposed to an error in creating a bean.
- BeanCreationException
-
The error thrown when creating a bean failed: its constructor or
@Beanmethod, its injection or an init callback threw. - BeanCreationNotAllowedException
- The error thrown when a singleton that does not exist yet is requested while the factory destroys its singletons.
- BeanCurrentlyInCreationException
- The error thrown when beans depend on each other in a cycle, so none of them can be created first.
- BeanDefinitionOverrideException
- The error thrown when a bean name or alias is registered while the name is already taken.
- BeanDefinitionStoreException
- The error thrown when a bean definition cannot be registered: an invalid name, or a name that is taken.
- BeanIsNotAFactoryException
-
The error thrown when
&nameasks for the factory of a bean that is not aFactoryBean. - BeanNotOfRequiredTypeException
- The error thrown when a bean exists but is not of the requested type.
- BeansException
- The common supertype of the errors the container throws: a missing or ambiguous bean, a failed creation, a clashing name, a bad property path.
- BindException
-
The exception
DataBinder.closethrows when binding or validation found errors; it carries them in bindingResult. - ConfigDataLoadException
- The startup error for config data that exists but cannot be used.
- ConfigDataLocationNotFoundException
-
The startup error for a required directory location that does not
exist, such as
spring.config.import=file:./config/without a./config/directory. - ConfigDataResourceNotFoundException
-
The startup error for a config file that must exist and does not, such
as
spring.config.import=file:./secrets.ymlwhen there is nosecrets.yml. - ConfigurationPropertiesBindException
- The error thrown when configuration values are invalid: a value that cannot be converted, a required value that is missing, or a validation constraint that fails.
- ConstraintDeclarationException
-
Thrown when a constraint is declared wrongly: invalid settings
(
Size(min: -1),min > max, a malformed regular expression),@ConvertGroupwithout@Valid(), or@Eachon a value that is not a collection. Jakarta'sConstraintDeclarationException. - ConstraintViolationException
-
The exception a
@Validated()bean throws when a call's arguments or its return value break their constraints. - ConversionException
- The error a conversion service throws when a value cannot be turned into the requested type.
- ConversionFailedException
-
The conversion error for a value the converter could not handle, such
as
'12x'for anint. - ConverterNotFoundException
- The conversion error for a target type that nothing converts to, or a source that no converter of that target accepts.
- EvaluationException
- An expression was valid but could not be evaluated: a missing property, an unknown type, a failed conversion.
- ExpressionException
- The common supertype of everything that can go wrong with an expression: invalid text (ParseException) or a failed evaluation (EvaluationException).
- GroupDefinitionException
-
Thrown when a group sequence is defined wrongly: a cycle,
Defaultin a class's@GroupSequence, the class missing from it, or Default as a key ofBeanValidator.groupSequences. Jakarta'sGroupDefinitionException. - InsecureConnectionException
- An insecure address the configuration names while insecure connections are not allowed: the application does not start.
- IntrospectionPartError
- The error thrown when code needs a part of an introspected class that its description leaves out.
- InvalidConfigDataPropertyException
- The startup error for a property written in a config file where it is not allowed.
- InvalidConfigurationPropertyNameException
-
The error for a name that should be canonical and is not, such as a
@ConfigurationPropertiesprefix writtenapp.readTimeoutinstead ofapp.read-timeout. - InvalidEndpointRequestException
-
Thrown when an argument of a request cannot be converted to its
parameter's type; answered
400. - InvalidPropertyException
-
The error a BeanWrapper throws when a property path is malformed
(
items[,address..city). - IsolateTaskException
- An error a task threw in its isolate, when the error itself could not be copied back: its text and its stack trace.
- IsolateTaskRejectedException
- A task the IsolateTaskExecutor could not take: its queue is full and so is its pool, or it was shut down.
- JsonMappingException
- The error the JSON mapper throws when JSON cannot be turned into the requested type, or a value cannot be written as JSON.
- JsonNodeException
-
The error a JsonNode accessor throws when the node has the wrong
kind, such as
stringValue()on a number, or cannot be converted. - JsonSchemaValidationException
-
The error
ObjectMapperthrows when JSON read into a class marked@JsonSchemaSourcedoes not fit its schema. - MethodInvocationException
- The error a BeanWrapper throws when a property's setter itself threw, for example because it validates the value.
- MissingParametersException
-
Thrown when a request to an operation lacks a mandatory parameter;
answered
400. - MissingPropertyException
- The error for a property read as required that no source has.
- MissingRequiredPropertiesException
- The error for properties that were declared required and have no value.
- NoSuchBeanDefinitionException
- The error thrown when no bean matches a requested type, qualifier or name.
- NoSuchMessageException
- Thrown when a message code is not found and no default message was given.
- NotReadablePropertyException
- The error a BeanWrapper throws when a property path cannot be read.
- NotWritablePropertyException
- The error a BeanWrapper throws when a property path cannot be written.
- NoUniqueBeanDefinitionException
- The error thrown when several beans match a requested type and none of them wins.
- NullValueInNestedPathException
-
The error a BeanWrapper throws when a path goes through a
nullvalue, such asaddressinaddress.city. - ParseException
- The text of an expression or template is not valid, so it cannot be parsed.
- PlaceholderResolutionException
-
The error for a
${...}placeholder that has no value and no default, or that refers to itself in a loop (a=${b},b=${a}). - PrimaryIsolateException
- An error of a PrimaryIsolateHandler, as it reaches another isolate: its text.
- PropertyBatchUpdateException
- The error BeanWrapper.setPropertyValues throws when one or more of the values could not be written, after trying all of them.
- PropertySourceNotFoundException
-
The startup error for a file named in
@PropertySourcethat does not exist. - RateLimitStoreSetupException
- What a VerifiableRateLimitStore needs is missing: the table or the function of a migration that was not run, a binding that is not declared. The message says what to do.
- RenamedPropertiesException
- The start failed because properties still have a name that was renamed (see RenamedPropertiesEnvironmentPostProcessor.renamed).
- ScopeNotActiveException
- The error thrown when a bean is looked up while its scope is not active, for example a screen-scoped bean while no screen is open.
- ScopeNotRegisteredException
- The error thrown when a bean of a custom scope is looked up and no scope of that name is registered.
- SpelEvaluationException
- Evaluating a SpEL expression failed; messageCode says why.
- SpelParseException
- The text of a SpEL expression is not valid; messageCode says what is wrong.
- TypeMismatchException
-
The error a BeanWrapper throws when a value cannot be converted to the
type of the property it is written to, such as
'old'for anint. - UnexpectedTypeException
-
Thrown when a constraint meets a value of a type it cannot check:
@Sizeon anint,@NotBlankon aList. Jakarta'sUnexpectedTypeException. - UnsatisfiedDependencyException
- The error thrown when an injection point of a bean cannot be filled: the bean, its injection point and the reason are in the message.
- ValidationException
- The base of the exceptions that mean validation itself is set up wrongly: a bad constraint declaration or group definition, never an invalid value.