Data access exception thrown when a resource fails completely:
for example, if we can't connect to a database using JDBC.
Exception thrown when an attempt to execute an SQL statement fails to map
the given data, typically but no limited to an insert or update data
results in violation of an integrity constraint.
Exception thrown if certain expected data could not be retrieved, e.g.
Deprecated.
class
Exception thrown when an attempt to insert or update data
results in violation of a primary key or unique constraint.
class
Data access exception thrown when a result was expected to have at least
one row (or element) but zero rows (or elements) were actually returned.
class
Data access exception thrown when a result was not of the expected size,
for example when expecting a single row but getting 0 or more than 1 rows.
class
Data access exception thrown when something unintended appears to have
happened with an update, but the transaction hasn't already been rolled back.
class
Exception thrown on incorrect usage of the API, such as failing to
"compile" a query object that needed compilation before execution.
class
Root for exceptions thrown when we use a data access resource incorrectly.
class
Root of the hierarchy of data access exceptions that are considered non-transient -
where a retry of the same operation would fail unless the cause of the Exception
is corrected.
class
Data access exception thrown when a resource fails completely and the failure is permanent.
class
Exception thrown on an optimistic locking violation.
class
Exception thrown when the underlying resource denied a permission
to access a specific element, such as a specific database table.
class
Exception thrown on a pessimistic locking violation.
class
Exception to be thrown on a query timeout.
class
Data access exception thrown when a previously failed operation might be able
to succeed if the application performs some recovery steps and retries the entire
transaction or in the case of a distributed transaction, the transaction branch.
class
Root of the hierarchy of data access exceptions that are considered transient -
where a previously failed operation might be able to succeed when the operation
is retried without any intervention by application-level functionality.
class
Data access exception thrown when a resource fails temporarily
and the operation can be retried.
class
Exception thrown on mismatch between Java type and database type:
for example on an attempt to set an object of the wrong type
in an RDBMS column.
class
Normal superclass when we can't distinguish anything more specific
than "something went wrong with the underlying resource": for example,
an SQLException from JDBC we can't pinpoint more precisely.
class
class
class
class
Exception thrown when SQL specified is invalid.
class
Fatal exception thrown when we can't connect to an RDBMS using JDBC.
class
Data access exception thrown when a result set did not have the correct column count,
for example when expecting a single column but getting 0 or more than 1 column.
class
Exception thrown when a ResultSet has been accessed in an invalid fashion.
class
Exception thrown when a JDBC update affects an unexpected number of rows.
class
Exception to be thrown when a LOB could not be retrieved.
class
class
Exception thrown when we can't classify an SQLException into
one of our generic data access exceptions.
class
class
Root of the hierarchy of data access exceptions that are related to processing
of SQL scripts.
class
Thrown by
ScriptUtils
if an SQL script cannot be properly parsed.
class
Thrown by
ScriptUtils
if a statement in an SQL script failed when
executing it against the target database.
class
Thrown when we cannot determine anything more specific than "something went
wrong while processing an SQL script": for example, a
SQLException
from JDBC that we cannot pinpoint more precisely.
class
Exception to be thrown by a DataSourceLookup implementation,
indicating that the specified DataSource could not be obtained.
class
Exception thrown when the underlying implementation does not support the
requested feature of the API.
class
Runtime exception mirroring the JMS IllegalStateException.
class
Runtime exception mirroring the JMS InvalidClientIDException.
class
Runtime exception mirroring the JMS InvalidDestinationException.
class
Runtime exception mirroring the JMS InvalidSelectorException.
class
Base class for exception thrown by the framework whenever it
encounters a problem related to JMS.
class
Runtime exception mirroring the JMS JMSSecurityException.
class
Runtime exception mirroring the JMS MessageEOFException.
class
Runtime exception mirroring the JMS MessageFormatException.
class
Runtime exception mirroring the JMS MessageNotReadableException.
class
Runtime exception mirroring the JMS MessageNotWriteableException.
class
Runtime exception mirroring the JMS ResourceAllocationException.
class
Runtime exception mirroring the JMS TransactionInProgressException.
class
Runtime exception mirroring the JMS TransactionRolledBackException.
class
JmsException to be thrown when no other matching subclass found.
class
Exception thrown when a synchronized local transaction failed to complete
(after the main transaction has already completed).
class
Exception to be thrown when the execution of a listener method failed.
class
Exception to be thrown when the reply of a message failed to be sent.
class
class
Thrown by a DestinationResolver when it cannot resolve a destination name.
class
General base exception to be thrown on JMX errors.
class
Exception thrown when we cannot locate an instance of an
MBeanServer
,
or when more than one instance is found.
class
Thrown when an invocation on an MBean resource failed with an exception (either
a reflection exception or an exception thrown by the target method itself).
class
Thrown when an invocation failed because of an I/O problem on the
MBeanServerConnection.
class
Thrown if an exception is encountered when trying to retrieve
MBean metadata.
class
Exception thrown in case of failure when exporting an MBean.
class
Exception thrown when we are unable to register an MBean,
for example because of a naming conflict.
class
Thrown by the
JmxAttributeSource
when it encounters
incorrect metadata on a managed resource or one of its methods.
class
class
RuntimeException to be thrown in case of JNDI lookup failures,
in particular from code that does not declare JNDI's checked
NamingException
: for example, from Spring's
JndiObjectTargetSource
.
class
Exception thrown on failed authentication.
class
Base class for all mail exceptions.
class
Exception thrown if illegal message properties are encountered.
class
Exception to be thrown by user code if a mail cannot be prepared properly,
for example when a FreeMarker template cannot be rendered for the mail text.
class
Exception thrown when a mail sending error is encountered.
class
Exception that indicates an error occurred during message delivery.
class
Exception that indicates an error occurred during message handling.
class
The base exception for any failures related to messaging.
class
class
class
Exception to be thrown when a method argument fails validation perhaps as a
result of
@Valid
style validation, or perhaps because it is required.
class
Exception that indicates that a method argument has not the expected type.
class
class
class
Raised after a failure to encode or decode a STOMP message.
class
Exception thrown on an optimistic locking violation for a mapped object.
class
Exception thrown if a mapped object could not be retrieved via its identifier.
class
Hibernate-specific subclass of UncategorizedDataAccessException,
for JDBC exceptions that Hibernate wrapped.
class
Hibernate-specific subclass of ObjectRetrievalFailureException.
class
Hibernate-specific subclass of ObjectOptimisticLockingFailureException.
class
Hibernate-specific subclass of InvalidDataAccessResourceUsageException,
thrown on invalid HQL query syntax.
class
Hibernate-specific subclass of UncategorizedDataAccessException,
for Hibernate system errors that do not match any concrete
org.springframework.dao
exceptions.
class
JPA-specific subclass of ObjectRetrievalFailureException.
class
JPA-specific subclass of ObjectOptimisticLockingFailureException.
class
JPA-specific subclass of UncategorizedDataAccessException,
for JPA system errors that do not match any concrete
org.springframework.dao
exceptions.
class
Base class for exception thrown when a marshalling or unmarshalling error occurs.
class
Exception thrown on marshalling failure.
class
Exception that indicates that the cause cannot be distinguished further.
class
Exception thrown on unmarshalling failure.
class
Exception thrown on marshalling validation failure.
class
Root of the hierarchy of Object XML Mapping exceptions.
class
Exception thrown when SQL specified is invalid.
class
Exception thrown when we can't classify a
R2dbcException
into
one of our generic data access exceptions.
class
class
Root of the hierarchy of data access exceptions that are related to processing
of SQL scripts.
class
Thrown by
ScriptUtils
if an SQL script cannot be properly parsed.
class
Thrown by
ScriptUtils
if a statement in an SQL script failed when
executing it against the target database.
class
Thrown when we cannot determine anything more specific than "something went wrong
while processing an SQL script": for example, an
R2dbcException
from R2DBC that we cannot pinpoint more precisely.
class
static class
class
General exception to be thrown on scheduling failures,
such as the scheduler already having shut down.
class
Unchecked exception that wraps an exception thrown from a target method.
class
Exception to be thrown on script compilation failure.
static final class
Exception to be thrown on script execution failure.
class
Exception thrown when a transaction can't be created using an
underlying transaction API such as JTA.
class
Exception that represents a transaction failure caused by a heuristic
decision on the side of the transaction coordinator.
class
Exception thrown when the existence or non-existence of a transaction
amounts to an illegal state according to the transaction propagation
behavior that applies.
class
Exception that gets thrown when an invalid isolation level is specified,
class
Exception that gets thrown when an invalid timeout is specified,
that is, the specified timeout valid is out of range or the
transaction manager implementation doesn't support timeouts.
class
Exception thrown when attempting to work with a nested transaction
but nested transactions are not supported by the underlying backend.
class
Exception thrown when an operation is attempted that
relies on an existing transaction (such as setting
rollback status) and there is no existing transaction.
class
Superclass for all transaction exceptions.
class
Exception thrown when attempting to suspend an existing transaction
but transaction suspension is not supported by the underlying backend.
class
Exception thrown when a general transaction system error is encountered,
like on commit or rollback.
class
Exception to be thrown when a transaction has timed out.
class
Superclass for exceptions caused by inappropriate usage of
a Spring transaction API.
class
Thrown when an attempt to commit a transaction resulted
in an unexpected rollback.
class
class
class
Exception thrown when an HTTP 4xx is received.
static final class
static final class
static final class
static final class
static final class
static final class
static final class
static final class
static final class
static final class
static final class
class
Exception thrown when an HTTP 5xx is received.
static final class
static final class
static final class
static final class
static final class
class
class
Exception thrown when an I/O error occurs.
class
class
Common base class for exceptions that contain actual HTTP response data.
class
class
Exception thrown when an unknown (or custom) HTTP status code is received.
class
class
A ConversionNotSupportedException raised while resolving a method argument.
class
A TypeMismatchException raised while resolving a controller method argument.
class
MultipartException subclass thrown when an upload exceeds the
maximum upload size allowed.
class
Exception thrown when multipart resolution fails.
class
Exception thrown to indicate that a
Content-Type
is not supported.
class
Exception thrown when an unknown (or custom) HTTP status code is received.
class
Abstract base class for exception published by
WebClient
in case of errors.
class
Exceptions that contain actual HTTP request data.
class
Exceptions that contain actual HTTP response data.
static class
static class
static class
static class
static class
static class
static class
static class
static class
static class
static class
static class
static class
static class
static class
static class
class
Raised when
ResourceWebHandler
is mapped to the request but can not
find a matching resource.
class
Exception for errors that fit response status 405 (method not allowed).
class
ServerWebInputException
subclass that indicates a missing request
value such as a request header, cookie value, query parameter, etc.
class
Exception for errors that fit response status 406 (not acceptable).
class
class
Exception for an
HttpStatus.INTERNAL_SERVER_ERROR
that exposes extra
information about a controller method that failed, or a controller method
argument that could not be resolved.
class
Exception for errors that fit response status 400 (bad request) for use in
Spring Web applications.
class
ServerWebInputException
subclass that indicates an unsatisfied
parameter condition, as typically expressed using an
@RequestMapping
annotation at the
@Controller
type level.
class
Exception for errors that fit response status 415 (unsupported media type).
class
Thrown when handshake processing failed to complete due to an internal, unrecoverable
error.
class
Base class for exceptions raised while processing SockJS HTTP requests.
class
An exception thrown when a message frame was successfully received over an HTTP POST
and parsed but one or more of the messages it contained could not be delivered to the
WebSocketHandler either because the handler failed or because the connection got
closed.
class
Indicates a serious failure that occurred in the SockJS implementation as opposed to
in user code (e.g.
PessimisticLockingFailureException
/CannotAcquireLockException