Spring Framework 6.1.9 API

This is the public Java API documentation (Javadoc) for the Spring Framework.

See also the Kotlin API documentation (KDoc).

Packages
Package
Description
The core AOP Alliance advice marker.
The AOP Alliance reflective interception abstraction.
Spring's variant of the Commons Logging API: with special support for Log4J 2, SLF4J and java.util.logging.
Spring's variant of the Commons Logging API: with special support for Log4J 2, SLF4J and java.util.logging.
Core Spring AOP interfaces, built on AOP Alliance AOP interoperability interfaces.
AspectJ integration package.
Classes enabling AspectJ 5 @Annotated classes to be used in Spring AOP.
Base classes enabling auto-proxying based on AspectJ.
Support package for declarative AOP configuration, with XML schema being the primary configuration format.
Package containing Spring's basic AOP infrastructure, compliant with the AOP Alliance interfaces.
SPI package allowing Spring AOP framework to handle arbitrary advice types.
Bean post-processors for use in ApplicationContexts to simplify AOP usage by automatically creating AOP proxies without the need to use a ProxyFactoryBean.
Various TargetSourceCreator implementations for use with Spring's AOP auto-proxying support.
Provides miscellaneous interceptor implementations.
Support for AOP-based scoping of target objects, with configurable backend.
Convenience classes for using Spring's AOP API.
Annotation support for AOP pointcuts.
Various TargetSource implementations for use with Spring AOP.
Support for dynamic, refreshable TargetSource implementations for use with Spring AOP.
Core package for Spring AOT infrastructure.
Support for recording method invocations relevant to RuntimeHints metadata.
Support classes for components that contribute generated code equivalent to a runtime behavior.
Support for registering the need for reflection, resources, java serialization and proxies at runtime.
Annotation support for runtime hints.
Predicate support for runtime hints.
Convenience classes for using runtime hints.
Support for generating GraalVM native configuration from runtime hints.
Testing support for the RuntimeHintsAgent.
Test support for core AOT classes.
Spring's repackaging of ASM 9.x (with Spring-specific patches; for internal use only).
This package contains interfaces and classes for manipulating Java beans.
The core package implementing Spring's lightweight Inversion of Control (IoC) container.
Support package for annotation-driven bean configuration.
AOT support for bean factories.
AspectJ-based dependency injection support.
SPI interfaces and configuration-related convenience classes for bean factories.
Support package for Groovy-based bean definitions.
Support infrastructure for bean definition parsing.
Support package for the Java ServiceLoader facility.
Classes supporting the org.springframework.beans.factory package.
Mechanism to determine bean wiring metadata from a bean instance.
Contains an abstract XML-based BeanFactory implementation, including a standard "spring-beans" XSD.
Properties editors used to convert from String values to object types such as java.util.Properties.
Classes supporting the org.springframework.beans package, such as utility classes for sorting and holding lists of beans.
Spring's generic cache abstraction.
Annotations and supporting classes for declarative cache management.
AspectJ-based caching support.
Support classes for the open source cache in Caffeine library, allowing to set up Caffeine caches within Spring's cache abstraction.
Implementation package for java.util.concurrent based caches.
Support package for declarative caching configuration, with XML schema being the primary configuration format.
AOP-based solution for declarative caching demarcation.
Implementation package for JSR-107 (javax.cache aka "JCache") based caches.
Support package for declarative JSR-107 caching configuration.
AOP-based solution for declarative caching demarcation using JSR-107 annotations.
Support classes for the org.springframework.cache package.
Transaction-aware decorators for the org.springframework.cache package.
Spring's repackaging of CGLIB 3.3 (with Spring-specific patches; for internal use only).
Spring's repackaging of the CGLIB beans package (for internal use only).
Spring's repackaging of the CGLIB core package (for internal use only).
Spring's repackaging of the CGLIB core internal package (for internal use only).
Spring's repackaging of the CGLIB proxy package (for internal use only).
Spring's repackaging of the CGLIB reflect package (for internal use only).
Spring's repackaging of the CGLIB transform package (for internal use only).
Spring's repackaging of the CGLIB transform impl package (for internal use only).
Spring's repackaging of the CGLIB util package (for internal use only).
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.
Annotation support for the Application Context, including JSR-250 "common" annotations, component-scanning, and Java-based metadata for creating Spring-managed objects.
AspectJ-based dependency injection support driven by the @Configurable annotation.
AOT support for application contexts.
Support package for advanced application context configuration, with XML schema being the primary configuration format.
Support classes for application events, like standard context events.
Expression parsing support within a Spring application context.
Abstraction for determining the current Locale, plus global holder that exposes a thread-bound Locale.
Support package for reading and managing the components index.
Core package for Spring Framework's scanned component index.
Classes supporting the org.springframework.context package, such as abstract base classes for ApplicationContext implementations and a MessageSource implementation.
Load-time weaving support for a Spring application context, building on Spring's LoadTimeWeaver abstraction.
Provides basic classes for exception handling and version detection, and other core helpers that are not specific to any part of the framework.
Core support package for annotations, meta-annotations, and merged annotations with attribute overrides.
Encoder and Decoder abstractions to convert between a reactive stream of bytes and Java objects.
Type conversion system API.
SPI to implement Converters for the type conversion system.
Default implementation of the type conversion system.
Spring's environment abstraction consisting of bean definition profile and hierarchical property source support.
Generic abstraction for (file-based) resources, used throughout the framework.
Generic abstraction for working with byte buffer implementations.
Support classes for Spring's resource abstraction.
Useful delegates for Spring's logging conventions.
Support package for recording metrics during application startup.
Support package for recording startup metrics using Java Flight Recorder.
Root package for Spring's serializer interfaces and implementations.
Support classes for Spring's serializer abstraction.
Support for styling values as Strings, with ToStringCreator as central class.
This package defines Spring's core TaskExecutor abstraction, and provides SyncTaskExecutor and SimpleAsyncTaskExecutor implementations.
Support classes for Spring's TaskExecutor abstraction.
Test support classes for Spring's I/O support.
Support classes for compiling and testing generated code.
Core support package for type introspection.
Support classes for reading annotation and class-level metadata.
Core support package for type filtering (e.g.
Exception hierarchy enabling sophisticated error handling independent of the data access approach in use.
Annotation support for DAOs.
Support classes for DAO implementations, providing miscellaneous utility methods.
Support package for EJB/Jakarta EE-related configuration, with XML schema being the primary configuration format.
Core abstractions behind the Spring Expression Language.
Common utility classes behind the Spring Expression Language.
SpEL's central implementation package.
SpEL's abstract syntax tree.
SpEL's standard parser implementation.
SpEL's default implementations for various core abstractions.
An API for defining Formatters to format field model values for display in a UI.
Annotations for declaratively configuring field formatting rules.
Formatters for java.util.Date properties.
Integration with the JSR-310 java.time package in JDK 8.
Formatters for java.lang.Number properties.
Integration with the JSR-354 javax.money package.
Support classes for the formatting package, providing common implementations as well as adapters.
Contains a basic abstraction over client/server-side HTTP.
Contains an abstraction over client-side HTTP.
This package provides support for client HTTP Observation.
Abstractions for reactive HTTP client support including ClientHttpRequest and ClientHttpResponse as well as a ClientHttpConnector.
This package provides generic HTTP support classes, to be used by higher-level classes like RestTemplate.
Provides implementations of Encoder and Decoder for web use.
CBOR encoder and decoder support.
JSON encoder and decoder support.
Multipart support.
Provides an encoder and a decoder for Google Protocol Buffers.
Provides implementations of ClientCodecConfigurer and ServerCodecConfigurer based on the converter implementations from org.springframework.http.codec.json and co.
XML encoder and decoder support.
Provides an HttpMessageConverter abstraction to convert between Java objects and HTTP input/output messages.
Provides an HttpMessageConverter for the CBOR data format.
Provides HttpMessageConverter implementations for handling Atom and RSS feeds.
Provides HttpMessageConverter implementations for handling JSON.
Provides an HttpMessageConverter implementation for handling Google Protocol Buffers.
Provides an HttpMessageConverter for the Smile data format ("binary JSON").
Provides a comprehensive HttpMessageConverter variant for form handling.
Provides HttpMessageConverter implementations for handling XML.
Contains an abstraction over server-side HTTP.
Instrumentation for observing HTTP server applications.
Abstractions for reactive HTTP server support including a ServerHttpRequest and ServerHttpResponse along with an HttpHandler for processing.
Instrumentation for observing reactive HTTP server applications.
This package provides internal HTTP support classes, to be used by higher-level client and server classes.
Core package for byte code instrumentation.
Support package for load time weaving based on class loaders, as required by JPA providers (but not JPA-specific).
Support for class instrumentation on GlassFish.
Support for class instrumentation on JBoss AS 6 and 7.
Support for class instrumentation on Tomcat.
This package provides a facility for generic JCA message endpoint management.
Provides generic support classes for JCA usage within Spring, mainly for local setup of a JCA ResourceAdapter and/or ConnectionFactory.
The classes in this package make JDBC easier to use and reduce the likelihood of common errors.
Defines the Spring JDBC configuration namespace.
Provides the core JDBC framework, based on JdbcTemplate and its associated callback interfaces and helper objects.
Context metadata abstraction for the configuration and execution of table inserts and stored procedure calls.
JdbcTemplate variant with named parameter support.
Simplification layer for common JDBC interactions.
Classes supporting the org.springframework.jdbc.core package.
Provides a utility class for easy DataSource access, a PlatformTransactionManager for a single DataSource, and various simple DataSource implementations.
Provides extensible support for creating embedded database instances.
Provides extensible support for initializing databases through scripts.
Provides a strategy for looking up JDBC DataSources by name.
The classes in this package represent RDBMS queries, updates, and stored procedures as threadsafe, reusable objects.
Support classes for the JDBC framework, used by the classes in the jdbc.core and jdbc.object packages.
Provides a support framework for incrementing database table values via sequences, with implementations for various databases.
Provides a strategy interface for Large OBject handling, as well as a customizable default implementation.
Provides a convenient holder for disconnected result sets.
Abstraction for handling fields of SQLXML data type.
This package contains integration classes for JMS, allowing for Spring-style JMS access.
Annotations and support classes for declarative JMS listener endpoints.
Support package for declarative messaging configuration, with Java configuration and XML schema support.
Provides a PlatformTransactionManager implementation for a single JMS ConnectionFactory, and a SingleConnectionFactory adapter.
Core package of the JMS support.
Classes supporting the org.springframework.jms.core package.
This package contains the base message listener container facility.
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.
This package provides JCA-based endpoint management for JMS message listeners.
This package provides generic JMS support classes, to be used by higher-level classes like JmsTemplate.
Provides a MessageConverter abstraction to convert between Java objects and JMS messages.
Support classes for Spring's JMS framework.
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.
Provides support for accessing remote MBean resources.
This package provides declarative creation and registration of Spring-managed beans as JMX MBeans.
Annotations for MBean exposure.
Provides a strategy for MBeanInfo assembly.
Provides generic JMX metadata classes and basic support for reading JMX metadata in a provider-agnostic manner.
Provides a strategy for ObjectName creation.
Provides supporting infrastructure to allow Spring-created MBeans to send JMX notifications.
Contains support classes for connecting to local and remote MBeanServers and for exposing an MBeanServer to remote clients.
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.
Support classes for JNDI usage, including a JNDI-based BeanFactory implementation.
Common annotations with language-level semantics: nullability as well as JDK API indications.
Spring's generic mail infrastructure.
JavaMail support for Spring's mail infrastructure.
Support for working with messaging APIs and protocols.
Provides support for message conversion.
Defines interfaces and implementation classes for messaging templates.
Basic abstractions for working with message handler methods.
Annotations and support classes for handling messages.
Support classes for working with annotated message-handling methods with non-blocking, reactive contracts.
Support classes for working with annotated message-handling methods.
Common infrastructure for invoking message handler methods.
Common infrastructure for invoking message handler methods with non-blocking, and reactive contracts.
Support for the RSocket protocol.
Annotations and support classes for handling RSocket streams.
Support classes for working with annotated RSocket stream handling methods.
Annotations to declare an RSocket service contract with request methods along with a proxy factory backed by an RSocketRequester.
Generic support for Simple Messaging Protocols including protocols such as STOMP.
Annotations and for handling messages from SImple Messaging Protocols such as STOMP.
Support classes for handling messages from simple messaging protocols (like STOMP).
Provides a "simple" message broker implementation along with an abstract base class and other supporting types such as a registry for subscriptions.
Configuration support for WebSocket messaging using higher level messaging protocols.
Generic support for simple messaging protocols (like STOMP).
Support for handling messages to "user" destinations (i.e.
Provides implementations of Message along with a MessageBuilder and MessageHeaderAccessor for building and working with messages and message headers, as well as various MessageChannel implementations and channel interceptor support.
Contains abstractions and implementation classes for establishing TCP connections via TcpOperations, handling messages via TcpConnectionHandler, as well as sending messages via TcpConnection.
Contains support for TCP messaging based on Reactor.
This package contains mock implementations of the Environment and PropertySource abstractions.
Mock implementations of client/server-side HTTP abstractions.
Mock implementations of client-side HTTP abstractions.
Mock implementations of reactive HTTP client contracts.
Mock implementations of reactive HTTP server contracts.
A comprehensive set of Servlet API 6.0 mock objects, targeted at usage with Spring's Web MVC framework.
Mock objects for the functional web framework.
Mock implementations of Spring's reactive server web API abstractions.
Spring's repackaging of Objenesis 3.2 (with SpringObjenesis entry point; for internal use only).
Root package for Spring's O/R Mapping integration classes.
Package providing integration of Hibernate 5.x with Spring concepts.
Classes supporting the org.springframework.orm.hibernate5 package.
Package providing integration of JPA (Java Persistence API) with Spring concepts.
Internal support for managing JPA persistence units.
Classes supporting the org.springframework.orm.jpa package.
Support classes for adapting to specific JPA vendors.
Root package for Spring's O/X Mapping integration classes.
Provides an namespace handler for the Spring Object/XML namespace.
Package providing integration of JAXB with Spring's O/X Mapping support.
Contains (un)marshallers optimized to store binary data in MIME attachments.
Provides generic support classes for using Spring's O/X Mapping integration within various scenario's.
Package providing integration of XStream with Spring's O/X Mapping support.
The classes in this package make R2DBC easier to use and reduce the likelihood of common errors.
Provides a utility class for easy ConnectionFactory access, a ReactiveTransactionManager for a single ConnectionFactory, and various simple ConnectionFactory implementations.
Provides extensible support for initializing databases through scripts.
Provides a strategy for looking up R2DBC ConnectionFactories by name.
Core domain types around DatabaseClient.
Classes providing an abstraction over SQL bind markers.
General exceptions for Spring's scheduling support, independent of any specific scheduling system.
Annotation support for asynchronous method execution.
AspectJ-based scheduling support.
Scheduling convenience classes for the java.util.concurrent and jakarta.enterprise.concurrent packages, allowing to set up a ThreadPoolExecutor or ScheduledThreadPoolExecutor as a bean in a Spring context.
Support package for declarative scheduling configuration, with XML schema being the primary configuration format.
Support classes for the open source scheduler Quartz, allowing to set up Quartz Schedulers, JobDetails and Triggers as beans in a Spring context.
Generic support classes for scheduling.
Core interfaces for Spring's scripting support.
Package providing integration of BeanShell (and BeanShell2) into Spring's scripting infrastructure.
Support package for Spring's dynamic language machinery, with XML schema being the primary configuration format.
Package providing integration of Groovy into Spring's scripting infrastructure.
Support classes for Spring's scripting package.
Annotations denoting the roles of types or methods in the overall architecture (at a conceptual, rather than implementation, level).
Support classes for annotation-driven tests.
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.
Ahead-of-time (AOT) support for the Spring TestContext Framework.
Support for context caching within the Spring TestContext Framework.
Test event support classes for the Spring TestContext Framework.
Test execution event annotations for the Spring TestContext Framework.
JDBC support classes for the Spring TestContext Framework, including support for declarative SQL script execution via @Sql.
Core support for integrating the Spring TestContext Framework with the JUnit Jupiter extension model in JUnit 5.
Web support for integrating the Spring TestContext Framework with the JUnit Jupiter extension model in JUnit 5.
Support classes for integrating the Spring TestContext Framework with JUnit 4.12 or higher.
Custom JUnit 4 Rules used in the Spring TestContext Framework.
Custom JUnit 4 Statements used in the Spring TestContext Framework.
Support classes for the Spring TestContext Framework.
Support classes for integrating the Spring TestContext Framework with TestNG.
Transactional support classes for the Spring TestContext Framework.
Common utilities used within the Spring TestContext Framework.
Web support classes for the Spring TestContext Framework.
Support classes for tests based on JDBC.
General utility classes for use in unit and integration tests.
Helper classes for unit tests based on Spring's web support.
Contains client-side REST testing support.
Contains built-in RequestMatcher implementations.
Contains built-in ResponseCreator implementations.
Support for testing Spring WebFlux server endpoints via WebTestClient.
Contains server-side support for testing Spring MVC applications.
Support for testing Spring MVC applications via WebTestClient with MockMvc for server request handling.
Server-side support for testing Spring MVC applications with MockMvc and HtmlUnit.
Server-side support for testing Spring MVC applications with MockMvc and the Selenium HtmlUnitDriver.
Contains built-in RequestBuilder implementations.
Contains built-in ResultMatcher and ResultHandler implementations.
Contains built-in MockMvcBuilder implementations.
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.
Spring's support for annotation-based transaction demarcation.
AspectJ-based transaction management support.
Support package for declarative transaction configuration, with XML schema being the primary configuration format.
Spring's support for listening to transaction events.
AOP-based solution for declarative transaction demarcation.
Transaction SPI implementation for JTA.
Support classes for reactive transaction management.
Support classes for the org.springframework.transaction package.
Generic support for UI layer concepts.
Contains classes defining the application context subinterface for UI applications.
Classes supporting the org.springframework.ui.context package.
Support classes for setting up FreeMarker within a Spring application context.
Miscellaneous utility classes, such as utilities for working with strings, classes, collections, reflection, etc.
A generic back-off abstraction.
Useful generic java.util.Comparator implementations, such as an invertible comparator and a compound comparator.
Useful generic java.util.concurrent.Future extensions.
Useful generic java.util.function helper classes.
Useful unit data types.
Miscellaneous utility classes for XML parsing and transformation, such as error handlers that log warnings via Commons Logging.
Provides data binding and validation functionality, for usage in business and/or UI layers.
Support classes for annotation-based constraint evaluation, e.g.
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.
Abstractions and support classes for method validation, independent of the underlying validation library.
Support classes for handling validation results.
Common, generic interfaces that define minimal boundary points between Spring's web infrastructure and other framework modules.
This package contains classes used to determine the requested the media types in a request.
Provides web-specific data binding functionality.
Annotations for binding requests to controllers and handler methods as well as for binding request parameters to method arguments.
Support classes for web data binding.
Core package of the client-side web support.
Classes supporting the org.springframework.web.client package.
Contains a variant of the application context interface for web applications, and the ContextLoaderListener that bootstraps a root web application context.
Provides convenience annotations for web scopes.
Support for generic request context holding, in particular for scoping of application objects per HTTP request or HTTP session.
Support for asynchronous request processing.
Classes supporting the org.springframework.web.context package, such as WebApplicationContext implementations and various utility classes.
Support for CORS (Cross-Origin Resource Sharing), based on a common CorsProcessor strategy.
Reactive support for CORS (Cross-Origin Resource Sharing), based on a common CorsProcessor strategy.
Provides generic filter base classes allowing for bean-style configuration.
WebFilter implementations for use in reactive web applications.
Support classes for integrating a JSF web layer with a Spring service layer which is hosted in a Spring root WebApplicationContext.
ELResolvers for integrating a JSF web layer with a Spring service layer which is hosted in a Spring root WebApplicationContext.
Common infrastructure for handler method processing, as used by Spring MVC's org.springframework.web.servlet.mvc.method package.
Support classes for annotation-based handler method processing.
Generic support classes for handler method processing.
Multipart resolution framework for handling file uploads.
Support classes for the multipart resolution framework.
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.
RequestedContentTypeResolver strategy and implementations to resolve the requested content type for a given request.
Spring WebFlux configuration infrastructure.
Provides a foundation for both the reactive client and server subpackages.
Provides a reactive WebClient that builds on top of the org.springframework.http.client.reactive reactive HTTP adapter layer.
Classes supporting the org.springframework.web.reactive.function.client package.
Provides the types that make up Spring's functional web framework for Reactive environments.
Classes supporting the org.springframework.web.reactive.function.server package.
Provides HandlerMapping implementations including abstract base classes.
Support classes for serving static resources.
Support for various programming model styles including the invocation of different types of handlers, e.g.
RequestCondition and implementations for matching requests based on different criteria.
Infrastructure for handler method processing.
Infrastructure for annotation-based handler method processing.
Support for result handling through view resolution.
Support classes for the integration of FreeMarker as Spring web view technology.
Support classes for views based on the JSR-223 script engine abstraction (as included in Java 6+), e.g.
Abstractions and support classes for reactive WebSocket interactions.
Classes adapting Spring's Reactive WebSocket API to and from WebSocket runtimes.
Client support for WebSocket interactions.
Server support for WebSocket interactions.
Server-side support classes for WebSocket requests.
Holds implementations of RequestUpgradeStrategy.
Core interfaces and classes for Spring's generic, reactive web support.
Implementations to adapt to the underlying org.springframework.http.client.reactive reactive HTTP adapter and HttpHandler.
Provides common WebHandler implementations and a WebHandlerDecorator.
Locale related support classes.
Auxiliary interfaces and implementation classes for WebSession support.
Annotations for declaring HTTP service request methods.
Support for creating a client proxy for an HTTP service annotated with HttpExchange methods.
Provides servlets that integrate with the application context infrastructure, and the core interfaces and classes for the Spring web MVC framework.
Defines the XML configuration namespace for Spring MVC.
Annotation-based setup for Spring MVC.
Provides the types that make up Spring's functional web framework for Servlet environments.
Classes supporting the org.springframework.web.servlet.function package.
Provides standard HandlerMapping implementations, including abstract base classes for custom implementations.
Locale support classes for Spring's web MVC framework.
Standard controller implementations for the Servlet MVC framework that comes with Spring.
Support package for annotation-based Servlet MVC controllers.
Common MVC logic for matching incoming requests based on conditions.
Servlet-based infrastructure for handler method processing, building on the org.springframework.web.method package.
MVC infrastructure for annotation-based handler method processing, building on the org.springframework.web.method.annotation package.
Support package for MVC controllers.
Support classes for serving static resources.
Support classes for Spring's web MVC framework.
This package contains Spring's JSP standard tag library for JSP 2.0+.
Spring's form tag library for JSP views in Spring's Web MVC framework.
Theme support classes for Spring's web MVC framework.
Provides standard View and ViewResolver implementations, including abstract base classes for custom implementations.
Support classes for document generation, providing View implementations for PDF and Excel.
Support classes for feed generation, providing View implementations for Atom and RSS.
Support classes for the integration of FreeMarker as Spring web view technology.
Support classes for the integration of Groovy Templates as Spring web view technology.
Support classes for providing a View implementation based on JSON serialization.
Support classes for views based on the JSR-223 script engine abstraction (as included in Java 6+), e.g.
Support classes for providing a View implementation based on XML Marshalling.
Support classes for XSLT, providing a View implementation for XSLT stylesheets.
Common abstractions and Spring configuration support for WebSocket applications.
Classes adapting Spring's WebSocket API to and from WebSocket providers.
Adapter classes for the Jetty WebSocket API.
Adapter classes for the standard Jakarta WebSocket API.
Client-side abstractions for WebSocket applications.
Client-side classes for use with standard Jakarta WebSocket endpoints.
Configuration support for WebSocket request handling.
Support for annotation-based WebSocket setup in configuration classes.
Convenient WebSocketHandler implementations and decorators.
WebSocket integration for Spring's messaging module.
Server-side abstractions for WebSocket interactions.
Server-side support for the Jetty WebSocket API.
Server-side classes for use with standard JSR-356 WebSocket endpoints.
Server-side support classes including container-specific strategies for upgrading a request.
Top-level SockJS types.
SockJS client implementation of WebSocketClient.
Support classes for creating SockJS frames including the encoding and decoding of SockJS message frames.
Support classes for SockJS including an AbstractSockJsService implementation.
Server-side support for SockJS transports including TransportHandler implementations for processing incoming requests, their session counterparts for sending messages over the various transports, and DefaultSockJsService.
TransportHandler implementation classes as well as a concrete SockJsService.
SockJS specific implementations of WebSocketSession.
Miscellaneous web utility classes, such as HTML escaping and cookie handling.
Dedicated support for matching HTTP request paths.