Uses of Package
org.springframework.core

Packages that use org.springframework.core
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.
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.
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.
Convenience classes for using Spring's AOP API.
Support classes for components that contribute generated code equivalent to a runtime behavior.
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.
SPI interfaces and configuration-related convenience classes for bean factories.
Support infrastructure for bean definition parsing.
Classes supporting the org.springframework.beans.factory package.
Contains an abstract XML-based BeanFactory implementation, including a standard "spring-beans" XSD.
AOP-based solution for declarative caching demarcation.
AOP-based solution for declarative caching demarcation using JSR-107 annotations.
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.
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.
Support classes for Spring's serializer abstraction.
Exception hierarchy enabling sophisticated error handling independent of the data access approach in use.
Annotation support for DAOs.
Contains an abstraction over client-side HTTP.
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.
XML encoder and decoder support.
Provides an HttpMessageConverter abstraction to convert between Java objects and HTTP input/output messages.
Support package for load time weaving based on class loaders, as required by JPA providers (but not JPA-specific).
The classes in this package make JDBC easier to use and reduce the likelihood of common errors.
Provides extensible support for initializing databases through scripts.
Provides a strategy for looking up JDBC DataSources by name.
Support classes for the JDBC framework, used by the classes in the jdbc.core and jdbc.object packages.
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.
Provides a PlatformTransactionManager implementation for a single JMS ConnectionFactory, and a SingleConnectionFactory 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.
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.
Provides a strategy for MBeanInfo assembly.
Provides generic JMX metadata classes and basic support for reading JMX metadata in a provider-agnostic manner.
Provides supporting infrastructure to allow Spring-created MBeans to send JMX notifications.
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.
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.
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.
Support classes for handling messages from simple messaging protocols (like STOMP).
Generic support for simple messaging protocols (like STOMP).
Support for handling messages to "user" destinations (i.e.
Mock objects for the functional web framework.
Root package for Spring's O/R Mapping integration classes.
Package providing integration of Hibernate 5.x with Spring concepts.
Package providing integration of JPA (Java Persistence API) with Spring concepts.
Classes supporting the org.springframework.orm.jpa package.
Root package for Spring's O/X Mapping integration classes.
The classes in this package make R2DBC easier to use and reduce the likelihood of common errors.
Provides extensible support for initializing databases through scripts.
Provides a strategy for looking up R2DBC ConnectionFactories by name.
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.
Support classes for the open source scheduler Quartz, allowing to set up Quartz Schedulers, JobDetails and Triggers as beans in a Spring context.
Core interfaces for Spring's scripting support.
Package providing integration of BeanShell (and BeanShell2) into Spring's scripting infrastructure.
Support classes for Spring's scripting package.
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.
Test event support classes for the Spring TestContext Framework.
JDBC support classes for the Spring TestContext Framework, including support for declarative SQL script execution via @Sql.
Support classes for the Spring TestContext Framework.
Transactional support classes for the Spring TestContext Framework.
Web support classes for the Spring TestContext Framework.
Support for testing Spring WebFlux server endpoints via WebTestClient.
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.
Spring's support for listening to transaction events.
AOP-based solution for declarative transaction demarcation.
Support classes for the org.springframework.transaction package.
Provides data binding and validation functionality, for usage in business and/or UI layers.
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.
Common, generic interfaces that define minimal boundary points between Spring's web infrastructure and other framework modules.
Provides web-specific data binding functionality.
Support classes for web data binding.
Core package of the client-side web support.
Classes supporting the org.springframework.web.client package.
Classes supporting the org.springframework.web.context package, such as WebApplicationContext implementations and various utility classes.
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.
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 for various programming model styles including the invocation of different types of handlers, e.g.
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.
Server-side support classes for WebSocket requests.
Core interfaces and classes for Spring's generic, reactive web support.
Support for creating a client proxy for an HTTP service annotated with HttpExchange methods.
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.
Support package for annotation-based Servlet MVC controllers.
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.
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 the integration of Groovy Templates as Spring web view technology.
Support classes for views based on the JSR-223 script engine abstraction (as included in Java 6+), e.g.
Support classes for XSLT, providing a View implementation for XSLT stylesheets.
WebSocket integration for Spring's messaging module.
Server-side abstractions for WebSocket interactions.
Server-side support classes including container-specific strategies for upgrading a request.
Top-level SockJS types.