Uses of Package
org.springframework.lang

Packages that use org.springframework.lang
Package
Description
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.
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.
 
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.
 
 
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.
Support for generating GraalVM native configuration from runtime hints.
Support classes for compiling and testing generated code.
Support classes for running assertions on generated files.
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.
SPI interfaces and configuration-related convenience classes for bean factories.
Support for generating code that represents the state of a bean factory.
Support infrastructure for bean definition parsing.
Support package for the Java 6 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.
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.
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.
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.
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.
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.
Root package for Spring's serializer interfaces and implementations.
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.
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.
Support classes for DAO implementations, providing miscellaneous utility methods.
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.
Integration with the JSR-310 java.time package in JDK 8.
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.
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.
JSON encoder and decoder support.
Multipart support.
Provides an encoder and a decoder for Google Protocol Buffers.
XML encoder and decoder support.
Provides an HttpMessageConverter abstraction to convert between Java objects and HTTP input/output messages.
Provides HttpMessageConverter implementations for handling JSON.
Provides an HttpMessageConverter implementation for handling Google Protocol Buffers.
Provides HttpMessageConverter implementations for handling XML.
Contains an abstraction over server-side HTTP.
Abstractions for reactive HTTP server support including a ServerHttpRequest and ServerHttpResponse along with an HttpHandler for processing.
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.
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 table inserts and stored procedure calls.
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 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.
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.
Provides support for accessing remote MBean resources.
This package provides declarative creation and registration of Spring-managed beans as JMX MBeans.
Java 5 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.
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.
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.
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.
Support classes for working with annotated RSocket stream handling methods.
Generic support for Simple Messaging Protocols including 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.
Mock implementations of reactive HTTP server contracts.
A comprehensive set of Servlet API 4.0 mock objects, targeted at usage with Spring's Web MVC framework.
Mock implementations of Spring's reactive server web API abstractions.
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.
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.
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.
Java 5 annotation for asynchronous method execution.
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.
Package providing integration of Groovy into Spring's scripting infrastructure.
Support classes for Spring's scripting package.
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.
Support for context caching within the Spring TestContext Framework.
Test event support classes for the Spring TestContext Framework.
Core 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 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.
Web support classes for the Spring TestContext Framework.
General utility classes for use in unit and integration tests.
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.
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.
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 String manipulation utilities, a Log4J configurer, and a state holder for paged lists of objects.
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.
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.
Support classes for web data binding.
Core package of the client-side web support.
Contains a variant of the application context interface for web applications, and the ContextLoaderListener that bootstraps a root web application context.
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.
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.
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.
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.
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.
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 the integration of FreeMarker 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 Java WebSocket API.
Client-side abstractions for WebSocket applications.
Client-side support for the Jetty WebSocket API.
Client-side classes for use with standard Java WebSocket endpoints.
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 9+ 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, Log4j initialization, and cookie handling.
Dedicated support for matching HTTP request paths.