Uses of Class
org.springframework.core.NestedRuntimeException
Package
Description
Core Spring AOP interfaces, built on AOP Alliance AOP interoperability interfaces.
Classes enabling AspectJ 5 @Annotated classes to be used in Spring AOP.
Package containing Spring's basic AOP infrastructure, compliant with the
AOP Alliance interfaces.
This package contains interfaces and classes for manipulating Java beans.
The core package implementing Spring's lightweight Inversion of Control (IoC) container.
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.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.
Core support package for annotations, meta-annotations, and merged
annotations with attribute overrides.
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.
Provides an HttpMessageConverter abstraction to convert between Java objects and HTTP input/output messages.
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.
Abstraction for handling fields of SQLXML data type.
This package contains integration classes for JMS,
allowing for Spring-style JMS access.
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 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.
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.
Support classes for working with annotated message-handling methods.
Common infrastructure for invoking message handler methods.
Support classes for handling messages from simple messaging protocols
(like STOMP).
Generic support for simple messaging protocols (like STOMP).
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.
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.
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.
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.
Common, generic interfaces that define minimal boundary points
between Spring's web infrastructure and other framework modules.
Support classes for web data binding.
Core package of the client-side web support.
Support classes for annotation-based handler method processing.
Multipart resolution framework for handling file uploads.
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.Core interfaces and classes for Spring's generic, reactive web support.
Server-side abstractions for WebSocket interactions.
Top-level SockJS types.
-
Uses of NestedRuntimeException in org.springframework.aop
Modifier and TypeClassDescriptionclass
Exception that gets thrown when an AOP invocation failed because of misconfiguration or unexpected runtime issues. -
Uses of NestedRuntimeException in org.springframework.aop.aspectj.annotation
Modifier and TypeClassDescriptionclass
Extension of AopConfigException thrown when trying to perform an advisor generation operation on a class that is not an AspectJ annotation-style aspect. -
Uses of NestedRuntimeException in org.springframework.aop.framework
Modifier and TypeClassDescriptionclass
Exception that gets thrown on illegal AOP configuration arguments. -
Uses of NestedRuntimeException in org.springframework.beans
Modifier and TypeClassDescriptionclass
Exception thrown when instantiation of a bean failed.class
Abstract superclass for all exceptions thrown in the beans package and subpackages.class
Exception thrown when no suitable editor or converter can be found for a bean property.class
Thrown on an unrecoverable problem encountered in the beans packages or sub-packages, e.g.class
Exception thrown when referring to an invalid bean property.class
Thrown when a bean property getter or setter method throws an exception, analogous to an InvocationTargetException.class
Exception thrown on an attempt to get the value of a property that isn't readable, because there's no getter method.class
Exception thrown on an attempt to set the value of a property that is not writable (typically because there is no setter method).class
Exception thrown when navigation of a valid nested property path encounters a NullPointerException.class
Superclass for exceptions related to a property access, such as type mismatch or invocation target exception.class
Combined exception, composed of individual PropertyAccessException instances.class
Exception thrown on a type mismatch when trying to set a bean property. -
Uses of NestedRuntimeException in org.springframework.beans.factory
Modifier and TypeClassDescriptionclass
Exception thrown when a BeanFactory encounters an error when attempting to create a bean from a bean definition.class
Exception thrown in case of a bean being requested despite bean creation currently not being allowed (for example, during the shutdown phase of a bean factory).class
Exception thrown in case of a reference to a bean that's currently in creation.class
Exception thrown when a BeanFactory encounters an invalid bean definition: e.g.class
Exception that indicates an expression evaluation attempt having failed.class
Exception that a bean implementation is suggested to throw if its own factory-aware initialization code fails.class
Exception thrown when a bean instance has been requested for a bean definition which has been marked as abstract.class
Exception thrown when a bean is not a factory, but a user tries to get at the factory for the given bean name.class
Thrown when a bean doesn't match the expected type.class
Exception thrown when the BeanFactory cannot load the specified class of a given bean.class
Exception to be thrown from a FactoryBean'sgetObject()
method if the bean is not fully initialized yet, for example because it is involved in a circular reference.class
Exception thrown when aBeanFactory
is asked for a bean instance for which it cannot find a definition.class
Exception thrown when aBeanFactory
is asked for a bean instance for which multiple matching candidates have been found when only one matching bean was expected.class
Exception thrown when a bean depends on other beans or simple properties that were not specified in the bean factory definition, although dependency checking was enabled. -
Uses of NestedRuntimeException in org.springframework.beans.factory.parsing
Modifier and TypeClassDescriptionclass
Exception thrown when a bean definition reader encounters an error during the parsing process. -
Uses of NestedRuntimeException in org.springframework.beans.factory.support
Modifier and TypeClassDescriptionclass
Subclass ofBeanDefinitionStoreException
indicating an invalid override attempt: typically registering a new definition for the same bean name whileDefaultListableBeanFactory.isAllowBeanDefinitionOverriding()
isfalse
.class
Exception thrown when the validation of a bean definition failed.class
A subclass ofBeanCreationException
which indicates that the target scope is not active, e.g. -
Uses of NestedRuntimeException in org.springframework.beans.factory.xml
Modifier and TypeClassDescriptionclass
XML-specific BeanDefinitionStoreException subclass that wraps aSAXException
, typically aSAXParseException
which contains information about the error location. -
Uses of NestedRuntimeException in org.springframework.context
Modifier and TypeClassDescriptionclass
Exception thrown during application context initialization. -
Uses of NestedRuntimeException in org.springframework.core.annotation
Modifier and TypeClassDescriptionclass
Thrown byAnnotationUtils
and synthesized annotations if an annotation is improperly configured. -
Uses of NestedRuntimeException in org.springframework.core.codec
Modifier and TypeClassDescriptionclass
General error that indicates a problem while encoding and decoding to and from an Object stream.class
Indicates an issue with decoding the input stream with a focus on content related issues such as a parse failure.class
Indicates an issue with encoding the input Object stream with a focus on not being able to encode Objects. -
Uses of NestedRuntimeException in org.springframework.core.convert
Modifier and TypeClassDescriptionclass
Base class for exceptions thrown by the conversion system.class
Exception to be thrown when an actual type conversion attempt fails.class
Exception to be thrown when a suitable converter could not be found in a given conversion service. -
Uses of NestedRuntimeException in org.springframework.core.serializer.support
Modifier and TypeClassDescriptionclass
Wrapper for the native IOException (or similar) when aSerializer
orDeserializer
failed. -
Uses of NestedRuntimeException in org.springframework.dao
Modifier and TypeClassDescriptionclass
Exception thrown on failure to acquire a lock during an update, for example during a "select for update" statement.class
Exception thrown on failure to complete a transaction in serialized mode due to update conflicts.class
Exception thrown when we couldn't clean up after a data access operation, but the actual operation went OK.class
Exception thrown on concurrency failure.class
Root of the hierarchy of data access exceptions discussed in Expert One-On-One J2EE Design and Development.class
Data access exception thrown when a resource fails completely: for example, if we can't connect to a database using JDBC.class
Exception thrown when an attempt to insert or update data results in violation of an integrity constraint.class
Exception thrown if certain expected data could not be retrieved, e.g.class
Generic exception thrown when the current process was a deadlock loser, and its transaction rolled back.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. -
Uses of NestedRuntimeException in org.springframework.http.converter
Modifier and TypeClassDescriptionclass
Thrown byHttpMessageConverter
implementations when a conversion attempt fails.class
Thrown byHttpMessageConverter
implementations when theHttpMessageConverter.read(java.lang.Class<? extends T>, org.springframework.http.HttpInputMessage)
method fails.class
Thrown byHttpMessageConverter
implementations when theHttpMessageConverter.write(T, org.springframework.http.MediaType, org.springframework.http.HttpOutputMessage)
method fails. -
Uses of NestedRuntimeException in org.springframework.jdbc
Modifier and TypeClassDescriptionclass
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 columns.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
Exception thrown when we're not ignoringSQLWarnings
.class
Exception thrown when we can't classify an SQLException into one of our generic data access exceptions. -
Uses of NestedRuntimeException in org.springframework.jdbc.datasource.init
Modifier and TypeClassDescriptionclass
Thrown byScriptUtils
if an SQL script cannot be read.class
Root of the hierarchy of data access exceptions that are related to processing of SQL scripts.class
Thrown byScriptUtils
if an SQL script cannot be properly parsed.class
Thrown byScriptUtils
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, aSQLException
from JDBC that we cannot pinpoint more precisely. -
Uses of NestedRuntimeException in org.springframework.jdbc.datasource.lookup
Modifier and TypeClassDescriptionclass
Exception to be thrown by a DataSourceLookup implementation, indicating that the specified DataSource could not be obtained. -
Uses of NestedRuntimeException in org.springframework.jdbc.support.xml
Modifier and TypeClassDescriptionclass
Exception thrown when the underlying implementation does not support the requested feature of the API. -
Uses of NestedRuntimeException in org.springframework.jms
Modifier and TypeClassDescriptionclass
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. -
Uses of NestedRuntimeException in org.springframework.jms.connection
Modifier and TypeClassDescriptionclass
Exception thrown when a synchronized local transaction failed to complete (after the main transaction has already completed). -
Uses of NestedRuntimeException in org.springframework.jms.listener.adapter
Modifier and TypeClassDescriptionclass
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. -
Uses of NestedRuntimeException in org.springframework.jms.support.converter
Modifier and TypeClassDescriptionclass
Thrown byMessageConverter
implementations when the conversion of an object to/from aMessage
fails. -
Uses of NestedRuntimeException in org.springframework.jms.support.destination
Modifier and TypeClassDescriptionclass
Thrown by a DestinationResolver when it cannot resolve a destination name. -
Uses of NestedRuntimeException in org.springframework.jmx
Modifier and TypeClassDescriptionclass
General base exception to be thrown on JMX errors.class
Exception thrown when we cannot locate an instance of anMBeanServer
, or when more than one instance is found. -
Uses of NestedRuntimeException in org.springframework.jmx.access
Modifier and TypeClassDescriptionclass
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. -
Uses of NestedRuntimeException in org.springframework.jmx.export
Modifier and TypeClassDescriptionclass
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. -
Uses of NestedRuntimeException in org.springframework.jmx.export.metadata
Modifier and TypeClassDescriptionclass
Thrown by theJmxAttributeSource
when it encounters incorrect metadata on a managed resource or one of its methods. -
Uses of NestedRuntimeException in org.springframework.jmx.export.notification
-
Uses of NestedRuntimeException in org.springframework.jndi
Modifier and TypeClassDescriptionclass
RuntimeException to be thrown in case of JNDI lookup failures, in particular from code that does not declare JNDI's checkedNamingException
: for example, from Spring'sJndiObjectTargetSource
. -
Uses of NestedRuntimeException in org.springframework.mail
Modifier and TypeClassDescriptionclass
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. -
Uses of NestedRuntimeException in org.springframework.messaging
Modifier and TypeClassDescriptionclass
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. -
Uses of NestedRuntimeException in org.springframework.messaging.converter
-
Uses of NestedRuntimeException in org.springframework.messaging.core
Modifier and TypeClassDescriptionclass
Thrown by aDestinationResolver
when it cannot resolve a destination. -
Uses of NestedRuntimeException in org.springframework.messaging.handler.annotation.support
Modifier and TypeClassDescriptionclass
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. -
Uses of NestedRuntimeException in org.springframework.messaging.handler.invocation
Modifier and TypeClassDescriptionclass
Common exception resulting from the invocation ofHandlerMethodArgumentResolver
. -
Uses of NestedRuntimeException in org.springframework.messaging.simp.annotation.support
-
Uses of NestedRuntimeException in org.springframework.messaging.simp.stomp
Modifier and TypeClassDescriptionclass
Raised after a failure to encode or decode a STOMP message. -
Uses of NestedRuntimeException in org.springframework.orm
Modifier and TypeClassDescriptionclass
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. -
Uses of NestedRuntimeException in org.springframework.orm.hibernate5
Modifier and TypeClassDescriptionclass
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 concreteorg.springframework.dao
exceptions. -
Uses of NestedRuntimeException in org.springframework.orm.jpa
Modifier and TypeClassDescriptionclass
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 concreteorg.springframework.dao
exceptions. -
Uses of NestedRuntimeException in org.springframework.oxm
Modifier and TypeClassDescriptionclass
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. -
Uses of NestedRuntimeException in org.springframework.r2dbc
Modifier and TypeClassDescriptionclass
Exception thrown when SQL specified is invalid.class
Exception thrown when we can't classify aR2dbcException
into one of our generic data access exceptions. -
Uses of NestedRuntimeException in org.springframework.r2dbc.connection.init
Modifier and TypeClassDescriptionclass
Thrown byScriptUtils
if an SQL script cannot be read.class
Root of the hierarchy of data access exceptions that are related to processing of SQL scripts.class
Thrown byScriptUtils
if an SQL script cannot be properly parsed.class
Thrown byScriptUtils
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, anR2dbcException
from R2DBC that we cannot pinpoint more precisely. -
Uses of NestedRuntimeException in org.springframework.r2dbc.connection.lookup
Modifier and TypeClassDescriptionclass
Exception to be thrown by aConnectionFactoryLookup
implementation, indicating that the specifiedConnectionFactory
could not be obtained. -
Uses of NestedRuntimeException in org.springframework.r2dbc.core.binding
Modifier and TypeClassDescriptionstatic class
Exception thrown whenBindMarkersFactoryResolver
cannot resolve aBindMarkersFactory
. -
Uses of NestedRuntimeException in org.springframework.scheduling
Modifier and TypeClassDescriptionclass
General exception to be thrown on scheduling failures, such as the scheduler already having shut down. -
Uses of NestedRuntimeException in org.springframework.scheduling.quartz
Modifier and TypeClassDescriptionclass
Unchecked exception that wraps an exception thrown from a target method. -
Uses of NestedRuntimeException in org.springframework.scripting
Modifier and TypeClassDescriptionclass
Exception to be thrown on script compilation failure. -
Uses of NestedRuntimeException in org.springframework.scripting.bsh
Modifier and TypeClassDescriptionstatic final class
Exception to be thrown on script execution failure. -
Uses of NestedRuntimeException in org.springframework.transaction
Modifier and TypeClassDescriptionclass
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, i.e.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. -
Uses of NestedRuntimeException in org.springframework.web
Modifier and TypeClassDescriptionclass
RuntimeException
that implementsErrorResponse
to expose an HTTP status, response headers, and a body formatted as an RFC 7807ProblemDetail
. -
Uses of NestedRuntimeException in org.springframework.web.bind.support
Modifier and TypeClassDescriptionclass
ServerWebInputException
subclass that indicates a data binding or validation failure. -
Uses of NestedRuntimeException in org.springframework.web.client
Modifier and TypeClassDescriptionclass
Exception thrown when an HTTP 4xx is received.static final class
HttpClientErrorException
for status HTTP 400 Bad Request.static final class
HttpClientErrorException
for status HTTP 409 Conflict.static final class
HttpClientErrorException
for status HTTP 403 Forbidden.static final class
HttpClientErrorException
for status HTTP 410 Gone.static final class
HttpClientErrorException
for status HTTP 405 Method Not Allowed.static final class
HttpClientErrorException
for status HTTP 406 Not Acceptable.static final class
HttpClientErrorException
for status HTTP 404 Not Found.static final class
HttpClientErrorException
for status HTTP 429 Too Many Requests.static final class
HttpClientErrorException
for status HTTP 401 Unauthorized.static final class
HttpClientErrorException
for status HTTP 422 Unprocessable Entity.static final class
HttpClientErrorException
for status HTTP 415 Unsupported Media Type.class
Exception thrown when an HTTP 5xx is received.static final class
HttpServerErrorException
for HTTP status 502 Bad Gateway.static final class
HttpServerErrorException
for status HTTP 504 Gateway Timeout.static final class
HttpServerErrorException
for status HTTP 500 Internal Server Error.static final class
HttpServerErrorException
for status HTTP 501 Not Implemented.static final class
HttpServerErrorException
for status HTTP 503 Service Unavailable.class
Abstract base class for exceptions based on anHttpStatusCode
.class
Exception thrown when an I/O error occurs.class
Base class for exceptions thrown byRestTemplate
in case a request fails because of a server error response, as determined viaResponseErrorHandler.hasError(ClientHttpResponse)
, failure to decode the response, or a low level I/O error.class
Common base class for exceptions that contain actual HTTP response data.class
Raised when no suitableHttpMessageConverter
could be found to extract the response.class
Exception thrown when an unknown (or custom) HTTP status code is received. -
Uses of NestedRuntimeException in org.springframework.web.method.annotation
Modifier and TypeClassDescriptionclass
A ConversionNotSupportedException raised while resolving a method argument.class
A TypeMismatchException raised while resolving a controller method argument. -
Uses of NestedRuntimeException in org.springframework.web.multipart
Modifier and TypeClassDescriptionclass
MultipartException subclass thrown when an upload exceeds the maximum upload size allowed.class
Exception thrown when multipart resolution fails. -
Uses of NestedRuntimeException in org.springframework.web.reactive.function
Modifier and TypeClassDescriptionclass
Exception thrown to indicate that aContent-Type
is not supported. -
Uses of NestedRuntimeException in org.springframework.web.reactive.function.client
Modifier and TypeClassDescriptionclass
Exception thrown when an unknown (or custom) HTTP status code is received.class
Abstract base class for exception published byWebClient
in case of errors.class
Exceptions that contain actual HTTP request data.class
Exceptions that contain actual HTTP response data.static class
WebClientResponseException
for HTTP status 502 Bad Gateway.static class
WebClientResponseException
for status HTTP 400 Bad Request.static class
WebClientResponseException
for status HTTP 409 Conflict.static class
WebClientResponseException
for status HTTP 403 Forbidden.static class
WebClientResponseException
for status HTTP 504 Gateway Timeout.static class
WebClientResponseException
for status HTTP 410 Gone.static class
WebClientResponseException
for status HTTP 500 Internal Server Error.static class
WebClientResponseException
for status HTTP 405 Method Not Allowed.static class
WebClientResponseException
for status HTTP 406 Not Acceptable.static class
WebClientResponseException
for status HTTP 404 Not Found.static class
WebClientResponseException
for status HTTP 501 Not Implemented.static class
WebClientResponseException
for status HTTP 503 Service Unavailable.static class
WebClientResponseException
for status HTTP 429 Too Many Requests.static class
WebClientResponseException
for status HTTP 401 Unauthorized.static class
WebClientResponseException
for status HTTP 422 Unprocessable Entity.static class
WebClientResponseException
for status HTTP 415 Unsupported Media Type. -
Uses of NestedRuntimeException in org.springframework.web.server
Modifier and TypeClassDescriptionclass
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
Subclass ofErrorResponseException
that accepts a "reason", and by default maps that to the"detail"
of theProblemDetail
.class
Exception for anHttpStatus.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). -
Uses of NestedRuntimeException in org.springframework.web.socket.server
Modifier and TypeClassDescriptionclass
Thrown when handshake processing failed to complete due to an internal, unrecoverable error. -
Uses of NestedRuntimeException in org.springframework.web.socket.sockjs
Modifier and TypeClassDescriptionclass
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.