| Package | Description |
|---|---|
| org.springframework.aop |
Core Spring AOP interfaces, built on AOP Alliance AOP interoperability interfaces.
|
| org.springframework.aop.aspectj |
AspectJ integration package.
|
| org.springframework.aop.aspectj.annotation |
Classes enabling AspectJ 5 @Annotated classes to be used in Spring AOP.
|
| org.springframework.aop.aspectj.autoproxy |
Base classes enabling auto-proxying based on AspectJ.
|
| org.springframework.aop.config |
Support package for declarative AOP configuration,
with XML schema being the primary configuration format.
|
| org.springframework.aop.framework |
Package containing Spring's basic AOP infrastructure, compliant with the
AOP Alliance interfaces.
|
| org.springframework.aop.framework.autoproxy |
Bean post-processors for use in ApplicationContexts to simplify AOP usage
by automatically creating AOP proxies without the need to use a ProxyFactoryBean.
|
| org.springframework.aop.interceptor |
Provides miscellaneous interceptor implementations.
|
| org.springframework.aop.support |
Convenience classes for using Spring's AOP API.
|
| org.springframework.beans |
This package contains interfaces and classes for manipulating Java beans.
|
| org.springframework.beans.factory |
The core package implementing Spring's lightweight Inversion of Control (IoC) container.
|
| org.springframework.beans.factory.annotation |
Support package for annotation-driven bean configuration.
|
| org.springframework.beans.factory.config |
SPI interfaces and configuration-related convenience classes for bean factories.
|
| org.springframework.beans.factory.parsing |
Support infrastructure for bean definition parsing.
|
| org.springframework.beans.factory.support |
Classes supporting the
org.springframework.beans.factory package. |
| org.springframework.beans.factory.xml |
Contains an abstract XML-based
BeanFactory implementation,
including a standard "spring-beans" XSD. |
| org.springframework.cache.interceptor |
AOP-based solution for declarative caching demarcation.
|
| org.springframework.cache.jcache.interceptor |
AOP-based solution for declarative caching demarcation using JSR-107 annotations.
|
| org.springframework.context |
This package builds on the beans package to add support for
message sources and for the Observer design pattern, and the
ability for application objects to obtain resources using a
consistent API.
|
| org.springframework.context.annotation |
Annotation support for the Application Context, including JSR-250 "common"
annotations, component-scanning, and Java-based metadata for creating
Spring-managed objects.
|
| org.springframework.context.event |
Support classes for application events, like standard context events.
|
| org.springframework.context.expression |
Expression parsing support within a Spring application context.
|
| org.springframework.context.support |
Classes supporting the org.springframework.context package,
such as abstract base classes for ApplicationContext
implementations and a MessageSource implementation.
|
| org.springframework.context.weaving |
Load-time weaving support for a Spring application context, building on Spring's
LoadTimeWeaver abstraction. |
| org.springframework.core |
Provides basic classes for exception handling and version detection,
and other core helpers that are not specific to any part of the framework.
|
| org.springframework.core.annotation |
Core support package for annotations, meta-annotations, and merged
annotations with attribute overrides.
|
| org.springframework.core.codec | |
| org.springframework.core.convert |
Type conversion system API.
|
| org.springframework.core.serializer.support |
Support classes for Spring's serializer abstraction.
|
| org.springframework.dao |
Exception hierarchy enabling sophisticated error handling independent
of the data access approach in use.
|
| org.springframework.dao.annotation |
Annotation support for DAOs.
|
| org.springframework.ejb.access |
This package contains classes that allow easy access to EJBs.
|
| org.springframework.http.client |
Contains an abstraction over client-side HTTP.
|
| org.springframework.http.codec | |
| org.springframework.http.codec.cbor | |
| org.springframework.http.codec.json |
JSON encoder and decoder support.
|
| org.springframework.http.codec.multipart |
Multipart support.
|
| org.springframework.http.codec.protobuf |
Provides an encoder and a decoder for
Google Protocol Buffers.
|
| org.springframework.http.codec.xml |
XML encoder and decoder support.
|
| org.springframework.http.converter |
Provides an HttpMessageConverter abstraction to convert between Java objects and HTTP input/output messages.
|
| org.springframework.instrument.classloading |
Support package for load time weaving based on class loaders,
as required by JPA providers (but not JPA-specific).
|
| org.springframework.jca.cci |
This package contains Spring's support for the Common Client Interface (CCI),
as defined by the J2EE Connector Architecture.
|
| org.springframework.jca.context |
Integration package that allows for deploying a Spring application context
as a JCA 1.7 compliant RAR file.
|
| org.springframework.jdbc |
The classes in this package make JDBC easier to use and
reduce the likelihood of common errors.
|
| org.springframework.jdbc.datasource.init |
Provides extensible support for initializing databases through scripts.
|
| org.springframework.jdbc.datasource.lookup |
Provides a strategy for looking up JDBC DataSources by name.
|
| org.springframework.jdbc.support |
Support classes for the JDBC framework, used by the classes in the
jdbc.core and jdbc.object packages.
|
| org.springframework.jdbc.support.xml |
Abstraction for handling fields of SQLXML data type.
|
| org.springframework.jms |
This package contains integration classes for JMS,
allowing for Spring-style JMS access.
|
| org.springframework.jms.annotation |
Annotations and support classes for declarative JMS listener endpoints.
|
| org.springframework.jms.connection |
Provides a PlatformTransactionManager implementation for a single
JMS ConnectionFactory, and a SingleConnectionFactory adapter.
|
| org.springframework.jms.listener.adapter |
Message listener adapter mechanism that delegates to target listener
methods, converting messages to appropriate message content types
(such as String or byte array) that get passed into listener methods.
|
| org.springframework.jms.support.converter |
Provides a MessageConverter abstraction to convert
between Java objects and JMS messages.
|
| org.springframework.jms.support.destination |
Support classes for Spring's JMS framework.
|
| org.springframework.jmx |
This package contains Spring's JMX support, which includes registration of
Spring-managed beans as JMX MBeans as well as access to remote JMX MBeans.
|
| org.springframework.jmx.access |
Provides support for accessing remote MBean resources.
|
| org.springframework.jmx.export |
This package provides declarative creation and registration of
Spring-managed beans as JMX MBeans.
|
| org.springframework.jmx.export.assembler |
Provides a strategy for MBeanInfo assembly.
|
| org.springframework.jmx.export.metadata |
Provides generic JMX metadata classes and basic support for reading
JMX metadata in a provider-agnostic manner.
|
| org.springframework.jmx.export.notification |
Provides supporting infrastructure to allow Spring-created MBeans
to send JMX notifications.
|
| org.springframework.jndi |
The classes in this package make JNDI easier to use,
facilitating the accessing of configuration stored in JNDI,
and provide useful superclasses for JNDI access classes.
|
| org.springframework.jndi.support |
Support classes for JNDI usage,
including a JNDI-based BeanFactory implementation.
|
| org.springframework.mail |
Spring's generic mail infrastructure.
|
| org.springframework.messaging |
Support for working with messaging APIs and protocols.
|
| org.springframework.messaging.handler |
Basic abstractions for working with message handler methods.
|
| org.springframework.messaging.handler.annotation.reactive |
Support classes for working with annotated message-handling methods with
non-blocking, reactive contracts.
|
| org.springframework.messaging.handler.annotation.support |
Support classes for working with annotated message-handling methods.
|
| org.springframework.messaging.handler.invocation |
Common infrastructure for invoking message handler methods.
|
| org.springframework.messaging.handler.invocation.reactive |
Common infrastructure for invoking message handler methods with non-blocking,
and reactive contracts.
|
| org.springframework.messaging.rsocket |
Support for the RSocket protocol.
|
| org.springframework.messaging.rsocket.annotation.support |
Support classes for working with annotated RSocket stream handling methods.
|
| org.springframework.messaging.simp.annotation.support |
Support classes for handling messages from simple messaging protocols
(like STOMP).
|
| org.springframework.messaging.simp.stomp |
Generic support for simple messaging protocols (like STOMP).
|
| org.springframework.messaging.simp.user |
Support for handling messages to "user" destinations (i.e.
|
| org.springframework.mock.web.reactive.function.server |
Mock objects for the functional web framework.
|
| org.springframework.orm |
Root package for Spring's O/R Mapping integration classes.
|
| org.springframework.orm.hibernate5 |
Package providing integration of
Hibernate 5.x
with Spring concepts.
|
| org.springframework.orm.jpa |
Package providing integration of JPA (Java Persistence API) with Spring concepts.
|
| org.springframework.orm.jpa.support |
Classes supporting the
org.springframework.orm.jpa package. |
| org.springframework.oxm |
Root package for Spring's O/X Mapping integration classes.
|
| org.springframework.r2dbc |
The classes in this package make R2DBC easier to use and
reduce the likelihood of common errors.
|
| org.springframework.r2dbc.connection.lookup |
Provides a strategy for looking up R2DBC ConnectionFactories by name.
|
| org.springframework.r2dbc.core.binding |
Classes providing an abstraction over SQL bind markers.
|
| org.springframework.remoting |
Exception hierarchy for Spring's remoting infrastructure,
independent of any specific remote method invocation system.
|
| org.springframework.remoting.jaxws |
Remoting classes for Web Services via JAX-WS (the successor of JAX-RPC),
as included in Java 6 and Java EE 5.
|
| org.springframework.remoting.rmi |
Remoting classes for conventional RMI and transparent remoting via
RMI invokers.
|
| org.springframework.remoting.soap |
SOAP-specific exceptions and support classes for Spring's remoting subsystem.
|
| org.springframework.scheduling |
General exceptions for Spring's scheduling support,
independent of any specific scheduling system.
|
| org.springframework.scheduling.annotation |
Annotation support for asynchronous method execution.
|
| org.springframework.scheduling.quartz |
Support classes for the open source scheduler
Quartz,
allowing to set up Quartz Schedulers, JobDetails and
Triggers as beans in a Spring context.
|
| org.springframework.scripting |
Core interfaces for Spring's scripting support.
|
| org.springframework.scripting.bsh |
Package providing integration of
BeanShell
(and BeanShell2)
into Spring's scripting infrastructure.
|
| org.springframework.scripting.support |
Support classes for Spring's scripting package.
|
| org.springframework.test.context |
This package contains the Spring TestContext Framework which
provides annotation-driven unit and integration testing support that is
agnostic of the actual testing framework in use.
|
| org.springframework.test.context.event |
Test event support classes for the Spring TestContext Framework.
|
| org.springframework.test.context.jdbc |
JDBC support classes for the Spring TestContext Framework,
including support for declarative SQL script execution via
@Sql. |
| org.springframework.test.context.support |
Support classes for the Spring TestContext Framework.
|
| org.springframework.test.context.transaction |
Transactional support classes for the Spring TestContext Framework.
|
| org.springframework.test.context.web |
Web support classes for the Spring TestContext Framework.
|
| org.springframework.test.web.reactive.server |
Support for testing Spring WebFlux server endpoints via
WebTestClient. |
| org.springframework.transaction |
Spring's core transaction management APIs (independent of any specific transaction
management system); an exception hierarchy for Spring's transaction infrastructure;
and transaction manager, definition, and status interfaces.
|
| org.springframework.transaction.event |
Spring's support for listening to transaction events.
|
| org.springframework.transaction.interceptor |
AOP-based solution for declarative transaction demarcation.
|
| org.springframework.transaction.support |
Support classes for the org.springframework.transaction package.
|
| org.springframework.validation |
Provides data binding and validation functionality,
for usage in business and/or UI layers.
|
| org.springframework.validation.beanvalidation |
Support classes for integrating a JSR-303 Bean Validation provider
(such as Hibernate Validator) into a Spring ApplicationContext
and in particular with Spring's data binding and validation APIs.
|
| org.springframework.web.bind |
Provides web-specific data binding functionality.
|
| org.springframework.web.bind.support |
Support classes for web data binding.
|
| org.springframework.web.client |
Core package of the client-side web support.
|
| org.springframework.web.context.support |
Classes supporting the
org.springframework.web.context package,
such as WebApplicationContext implementations and various utility classes. |
| org.springframework.web.method |
Common infrastructure for handler method processing, as used by
Spring MVC's
org.springframework.web.servlet.mvc.method package. |
| org.springframework.web.method.annotation |
Support classes for annotation-based handler method processing.
|
| org.springframework.web.method.support |
Generic support classes for handler method processing.
|
| org.springframework.web.multipart |
Multipart resolution framework for handling file uploads.
|
| org.springframework.web.multipart.support |
Support classes for the multipart resolution framework.
|
| org.springframework.web.reactive |
Top-level package for the
spring-webflux module that contains
DispatcherHandler, the main entry
point for WebFlux server endpoint processing including key contracts used to
map requests to handlers, invoke them, and process the result. |
| org.springframework.web.reactive.config |
Spring WebFlux configuration infrastructure.
|
| org.springframework.web.reactive.function |
Provides a foundation for both the reactive client and server subpackages.
|
| org.springframework.web.reactive.function.client |
Provides a reactive
WebClient
that builds on top of the
org.springframework.http.client.reactive reactive HTTP adapter layer. |
| org.springframework.web.reactive.function.client.support |
Classes supporting the
org.springframework.web.reactive.function.client package. |
| org.springframework.web.reactive.function.server |
Provides the types that make up Spring's functional web framework for Reactive environments.
|
| org.springframework.web.reactive.function.server.support |
Classes supporting the
org.springframework.web.reactive.function.server package. |
| org.springframework.web.reactive.handler |
Provides HandlerMapping implementations including abstract base classes.
|
| org.springframework.web.reactive.result |
Support for various programming model styles including the invocation of
different types of handlers, e.g.
|
| org.springframework.web.reactive.result.method |
Infrastructure for handler method processing.
|
| org.springframework.web.reactive.result.method.annotation |
Infrastructure for annotation-based handler method processing.
|
| org.springframework.web.reactive.result.view |
Support for result handling through view resolution.
|
| org.springframework.web.reactive.result.view.freemarker |
Support classes for the integration of
FreeMarker
as Spring web view technology.
|
| org.springframework.web.reactive.result.view.script |
Support classes for views based on the JSR-223 script engine abstraction
(as included in Java 6+), e.g.
|
| org.springframework.web.reactive.socket.server.support |
Server-side support classes for WebSocket requests.
|
| org.springframework.web.server |
Core interfaces and classes for Spring's generic, reactive web support.
|
| org.springframework.web.servlet.function.support |
Classes supporting the
org.springframework.web.servlet.function package. |
| org.springframework.web.servlet.handler |
Provides standard HandlerMapping implementations,
including abstract base classes for custom implementations.
|
| org.springframework.web.servlet.mvc.annotation |
Support package for annotation-based Servlet MVC controllers.
|
| org.springframework.web.servlet.mvc.method |
Servlet-based infrastructure for handler method processing,
building on the
org.springframework.web.method package. |
| org.springframework.web.servlet.mvc.method.annotation |
MVC infrastructure for annotation-based handler method processing, building on the
org.springframework.web.method.annotation package. |
| org.springframework.web.servlet.mvc.support |
Support package for MVC controllers.
|
| org.springframework.web.servlet.view |
Provides standard View and ViewResolver implementations,
including abstract base classes for custom implementations.
|
| org.springframework.web.servlet.view.groovy |
Support classes for the integration of
Groovy Templates as Spring web view technology.
|
| org.springframework.web.servlet.view.tiles3 |
Support classes for the integration of
Tiles 3
(the standalone version of Tiles) as Spring web view technology.
|
| org.springframework.web.servlet.view.xslt |
Support classes for XSLT,
providing a View implementation for XSLT stylesheets.
|
| org.springframework.web.socket.messaging |
WebSocket integration for Spring's messaging module.
|
| org.springframework.web.socket.server |
Server-side abstractions for WebSocket interactions.
|
| org.springframework.web.socket.server.support |
Server-side support classes including container-specific strategies
for upgrading a request.
|
| org.springframework.web.socket.sockjs |
Top-level SockJS types.
|
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| ParameterNameDiscoverer
Interface to discover parameter names for methods and constructors.
|
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| ParameterNameDiscoverer
Interface to discover parameter names for methods and constructors.
|
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| PriorityOrdered |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
| AttributeAccessor
Interface defining a generic contract for attaching and accessing metadata
to/from arbitrary objects.
|
| AttributeAccessorSupport
Support class for
AttributeAccessors, providing
a base implementation of all methods. |
| MethodParameter
Helper class that encapsulates the specification of a method parameter, i.e.
|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| ResolvableType
Encapsulates a Java
Type, providing access to
supertypes, interfaces, and
generic parameters along with the ability to ultimately
resolve to a Class. |
| Class and Description |
|---|
| MethodParameter
Helper class that encapsulates the specification of a method parameter, i.e.
|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| ResolvableType
Encapsulates a Java
Type, providing access to
supertypes, interfaces, and
generic parameters along with the ability to ultimately
resolve to a Class. |
| Class and Description |
|---|
| AttributeAccessor
Interface defining a generic contract for attaching and accessing metadata
to/from arbitrary objects.
|
| AttributeAccessorSupport
Support class for
AttributeAccessors, providing
a base implementation of all methods. |
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| PriorityOrdered |
| Class and Description |
|---|
| AttributeAccessor
Interface defining a generic contract for attaching and accessing metadata
to/from arbitrary objects.
|
| MethodParameter
Helper class that encapsulates the specification of a method parameter, i.e.
|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| ParameterNameDiscoverer
Interface to discover parameter names for methods and constructors.
|
| PriorityOrdered |
| ResolvableType
Encapsulates a Java
Type, providing access to
supertypes, interfaces, and
generic parameters along with the ability to ultimately
resolve to a Class. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| AliasRegistry
Common interface for managing aliases.
|
| AttributeAccessor
Interface defining a generic contract for attaching and accessing metadata
to/from arbitrary objects.
|
| AttributeAccessorSupport
Support class for
AttributeAccessors, providing
a base implementation of all methods. |
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| ParameterNameDiscoverer
Interface to discover parameter names for methods and constructors.
|
| ResolvableType
Encapsulates a Java
Type, providing access to
supertypes, interfaces, and
generic parameters along with the ability to ultimately
resolve to a Class. |
| SimpleAliasRegistry
Simple implementation of the
AliasRegistry interface. |
| Class and Description |
|---|
| AliasRegistry
Common interface for managing aliases.
|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| SimpleAliasRegistry
Simple implementation of the
AliasRegistry interface. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| ResolvableType
Encapsulates a Java
Type, providing access to
supertypes, interfaces, and
generic parameters along with the ability to ultimately
resolve to a Class. |
| ResolvableTypeProvider
Any object can implement this interface to provide its actual
ResolvableType. |
| Class and Description |
|---|
| AliasRegistry
Common interface for managing aliases.
|
| AttributeAccessor
Interface defining a generic contract for attaching and accessing metadata
to/from arbitrary objects.
|
| AttributeAccessorSupport
Support class for
AttributeAccessors, providing
a base implementation of all methods. |
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| PriorityOrdered |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| ResolvableType
Encapsulates a Java
Type, providing access to
supertypes, interfaces, and
generic parameters along with the ability to ultimately
resolve to a Class. |
| Class and Description |
|---|
| ParameterNameDiscoverer
Interface to discover parameter names for methods and constructors.
|
| Class and Description |
|---|
| AliasRegistry
Common interface for managing aliases.
|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| PriorityOrdered |
| ResolvableType
Encapsulates a Java
Type, providing access to
supertypes, interfaces, and
generic parameters along with the ability to ultimately
resolve to a Class. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
| AliasRegistry
Common interface for managing aliases.
|
| AttributeAccessor
Interface defining a generic contract for attaching and accessing metadata
to/from arbitrary objects.
|
| Constants.ConstantException
Exception thrown when the
Constants class is asked for
an invalid constant name. |
| DecoratingClassLoader
Base class for decorating ClassLoaders such as
OverridingClassLoader
and ShadowingClassLoader,
providing common handling of excluded packages and classes. |
| MethodClassKey
A common key class for a method against a specific target class,
including
MethodClassKey.toString() representation and Comparable
support (as suggested for custom HashMap keys as of Java 8). |
| MethodIntrospector.MetadataLookup
A callback interface for metadata lookup on a given method.
|
| MethodParameter
Helper class that encapsulates the specification of a method parameter, i.e.
|
OrderComparator
Comparator implementation for Ordered objects, sorting
by order value ascending, respectively by priority descending. |
| OrderComparator.OrderSourceProvider
Strategy interface to provide an order source for a given object.
|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| ParameterizedTypeReference
The purpose of this class is to enable capturing and passing a generic
Type. |
| ParameterNameDiscoverer
Interface to discover parameter names for methods and constructors.
|
PrioritizedParameterNameDiscoverer
ParameterNameDiscoverer implementation that tries several discoverer
delegates in succession. |
| ReactiveAdapter
Adapter for a Reactive Streams
Publisher to and from an async/reactive
type such as CompletableFuture, RxJava Observable, and others. |
| ReactiveAdapterRegistry
A registry of adapters to adapt Reactive Streams
Publisher to/from
various async/reactive types such as CompletableFuture, RxJava
Flowable, and others. |
| ReactiveTypeDescriptor
Describes the semantics of a reactive type including boolean checks for
ReactiveTypeDescriptor.isMultiValue(), ReactiveTypeDescriptor.isNoValue(), and ReactiveTypeDescriptor.supportsEmpty(). |
| ResolvableType
Encapsulates a Java
Type, providing access to
supertypes, interfaces, and
generic parameters along with the ability to ultimately
resolve to a Class. |
| Class and Description |
|---|
| MethodParameter
Helper class that encapsulates the specification of a method parameter, i.e.
|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
OrderComparator
Comparator implementation for Ordered objects, sorting
by order value ascending, respectively by priority descending. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| ResolvableType
Encapsulates a Java
Type, providing access to
supertypes, interfaces, and
generic parameters along with the ability to ultimately
resolve to a Class. |
| Class and Description |
|---|
| MethodParameter
Helper class that encapsulates the specification of a method parameter, i.e.
|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| ResolvableType
Encapsulates a Java
Type, providing access to
supertypes, interfaces, and
generic parameters along with the ability to ultimately
resolve to a Class. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| ParameterizedTypeReference
The purpose of this class is to enable capturing and passing a generic
Type. |
| Class and Description |
|---|
| ResolvableType
Encapsulates a Java
Type, providing access to
supertypes, interfaces, and
generic parameters along with the ability to ultimately
resolve to a Class. |
| Class and Description |
|---|
| ResolvableType
Encapsulates a Java
Type, providing access to
supertypes, interfaces, and
generic parameters along with the ability to ultimately
resolve to a Class. |
| Class and Description |
|---|
| MethodParameter
Helper class that encapsulates the specification of a method parameter, i.e.
|
| ResolvableType
Encapsulates a Java
Type, providing access to
supertypes, interfaces, and
generic parameters along with the ability to ultimately
resolve to a Class. |
| Class and Description |
|---|
| ResolvableType
Encapsulates a Java
Type, providing access to
supertypes, interfaces, and
generic parameters along with the ability to ultimately
resolve to a Class. |
| Class and Description |
|---|
| ResolvableType
Encapsulates a Java
Type, providing access to
supertypes, interfaces, and
generic parameters along with the ability to ultimately
resolve to a Class. |
| Class and Description |
|---|
| ResolvableType
Encapsulates a Java
Type, providing access to
supertypes, interfaces, and
generic parameters along with the ability to ultimately
resolve to a Class. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| DecoratingClassLoader
Base class for decorating ClassLoaders such as
OverridingClassLoader
and ShadowingClassLoader,
providing common handling of excluded packages and classes. |
OverridingClassLoader
ClassLoader that does not always delegate to the parent loader
as normal class loaders do. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| AliasRegistry
Common interface for managing aliases.
|
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| NestedCheckedException
Handy class for wrapping checked
Exceptions with a root cause. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| MethodParameter
Helper class that encapsulates the specification of a method parameter, i.e.
|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| ParameterNameDiscoverer
Interface to discover parameter names for methods and constructors.
|
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| ResolvableType
Encapsulates a Java
Type, providing access to
supertypes, interfaces, and
generic parameters along with the ability to ultimately
resolve to a Class. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| MethodParameter
Helper class that encapsulates the specification of a method parameter, i.e.
|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
| MethodParameter
Helper class that encapsulates the specification of a method parameter, i.e.
|
| ReactiveAdapterRegistry
A registry of adapters to adapt Reactive Streams
Publisher to/from
various async/reactive types such as CompletableFuture, RxJava
Flowable, and others. |
| Class and Description |
|---|
| MethodParameter
Helper class that encapsulates the specification of a method parameter, i.e.
|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| MethodParameter
Helper class that encapsulates the specification of a method parameter, i.e.
|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| ParameterNameDiscoverer
Interface to discover parameter names for methods and constructors.
|
| ReactiveAdapterRegistry
A registry of adapters to adapt Reactive Streams
Publisher to/from
various async/reactive types such as CompletableFuture, RxJava
Flowable, and others. |
| Class and Description |
|---|
| MethodParameter
Helper class that encapsulates the specification of a method parameter, i.e.
|
| ReactiveAdapterRegistry
A registry of adapters to adapt Reactive Streams
Publisher to/from
various async/reactive types such as CompletableFuture, RxJava
Flowable, and others. |
| Class and Description |
|---|
| ParameterizedTypeReference
The purpose of this class is to enable capturing and passing a generic
Type. |
| ReactiveAdapterRegistry
A registry of adapters to adapt Reactive Streams
Publisher to/from
various async/reactive types such as CompletableFuture, RxJava
Flowable, and others. |
| ResolvableType
Encapsulates a Java
Type, providing access to
supertypes, interfaces, and
generic parameters along with the ability to ultimately
resolve to a Class. |
| Class and Description |
|---|
| MethodParameter
Helper class that encapsulates the specification of a method parameter, i.e.
|
| ReactiveAdapterRegistry
A registry of adapters to adapt Reactive Streams
Publisher to/from
various async/reactive types such as CompletableFuture, RxJava
Flowable, and others. |
| Class and Description |
|---|
| MethodParameter
Helper class that encapsulates the specification of a method parameter, i.e.
|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
| ParameterizedTypeReference
The purpose of this class is to enable capturing and passing a generic
Type. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| PriorityOrdered |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| ConfigurableObjectInputStream
Special ObjectInputStream subclass that resolves class names
against a specific ClassLoader.
|
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
| AttributeAccessor
Interface defining a generic contract for attaching and accessing metadata
to/from arbitrary objects.
|
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
| AttributeAccessor
Interface defining a generic contract for attaching and accessing metadata
to/from arbitrary objects.
|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
| ParameterizedTypeReference
The purpose of this class is to enable capturing and passing a generic
Type. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
| MethodParameter
Helper class that encapsulates the specification of a method parameter, i.e.
|
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| ParameterNameDiscoverer
Interface to discover parameter names for methods and constructors.
|
| Class and Description |
|---|
| MethodParameter
Helper class that encapsulates the specification of a method parameter, i.e.
|
| Class and Description |
|---|
| MethodParameter
Helper class that encapsulates the specification of a method parameter, i.e.
|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| ParameterizedTypeReference
The purpose of this class is to enable capturing and passing a generic
Type. |
| Class and Description |
|---|
| AliasRegistry
Common interface for managing aliases.
|
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
| MethodParameter
Helper class that encapsulates the specification of a method parameter, i.e.
|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| MethodParameter
Helper class that encapsulates the specification of a method parameter, i.e.
|
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
| MethodParameter
Helper class that encapsulates the specification of a method parameter, i.e.
|
| Class and Description |
|---|
| MethodParameter
Helper class that encapsulates the specification of a method parameter, i.e.
|
| ResolvableType
Encapsulates a Java
Type, providing access to
supertypes, interfaces, and
generic parameters along with the ability to ultimately
resolve to a Class. |
| Class and Description |
|---|
| ReactiveAdapterRegistry
A registry of adapters to adapt Reactive Streams
Publisher to/from
various async/reactive types such as CompletableFuture, RxJava
Flowable, and others. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| ParameterizedTypeReference
The purpose of this class is to enable capturing and passing a generic
Type. |
| ResolvableType
Encapsulates a Java
Type, providing access to
supertypes, interfaces, and
generic parameters along with the ability to ultimately
resolve to a Class. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| ParameterizedTypeReference
The purpose of this class is to enable capturing and passing a generic
Type. |
| Class and Description |
|---|
| ParameterizedTypeReference
The purpose of this class is to enable capturing and passing a generic
Type. |
| Class and Description |
|---|
| ParameterizedTypeReference
The purpose of this class is to enable capturing and passing a generic
Type. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| ParameterizedTypeReference
The purpose of this class is to enable capturing and passing a generic
Type. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| ReactiveAdapter
Adapter for a Reactive Streams
Publisher to and from an async/reactive
type such as CompletableFuture, RxJava Observable, and others. |
| ReactiveAdapterRegistry
A registry of adapters to adapt Reactive Streams
Publisher to/from
various async/reactive types such as CompletableFuture, RxJava
Flowable, and others. |
| Class and Description |
|---|
| MethodParameter
Helper class that encapsulates the specification of a method parameter, i.e.
|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| ParameterNameDiscoverer
Interface to discover parameter names for methods and constructors.
|
| ReactiveAdapterRegistry
A registry of adapters to adapt Reactive Streams
Publisher to/from
various async/reactive types such as CompletableFuture, RxJava
Flowable, and others. |
| Class and Description |
|---|
| MethodParameter
Helper class that encapsulates the specification of a method parameter, i.e.
|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| ReactiveAdapterRegistry
A registry of adapters to adapt Reactive Streams
Publisher to/from
various async/reactive types such as CompletableFuture, RxJava
Flowable, and others. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| ReactiveAdapterRegistry
A registry of adapters to adapt Reactive Streams
Publisher to/from
various async/reactive types such as CompletableFuture, RxJava
Flowable, and others. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
| MethodParameter
Helper class that encapsulates the specification of a method parameter, i.e.
|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| ResolvableType
Encapsulates a Java
Type, providing access to
supertypes, interfaces, and
generic parameters along with the ability to ultimately
resolve to a Class. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
| MethodParameter
Helper class that encapsulates the specification of a method parameter, i.e.
|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| ParameterNameDiscoverer
Interface to discover parameter names for methods and constructors.
|
| ReactiveAdapterRegistry
A registry of adapters to adapt Reactive Streams
Publisher to/from
various async/reactive types such as CompletableFuture, RxJava
Flowable, and others. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |
| Class and Description |
|---|
Ordered
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection. |
| Class and Description |
|---|
| NestedRuntimeException
Handy class for wrapping runtime
Exceptions with a root cause. |