Uses of Class
org.springframework.core.NestedRuntimeException

Packages that use 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.
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.
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.
Support classes for serving static resources.
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 Type
Class
Description
class
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 Type
Class
Description
class
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 Type
Class
Description
class
Exception that gets thrown on illegal AOP configuration arguments.

Uses of NestedRuntimeException in org.springframework.beans

Modifier and Type
Class
Description
class
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 Type
Class
Description
class
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:
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's getObject() method if the bean is not fully initialized yet, for example because it is involved in a circular reference.
class
Exception thrown when a BeanFactory is asked for a bean instance for which it cannot find a definition.
class
Exception thrown when a BeanFactory 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 Type
Class
Description
class
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 Type
Class
Description
class
BeanDefinitionOverrideException
Subclass of BeanDefinitionStoreException indicating an invalid override attempt: typically registering a new definition for the same bean name while DefaultListableBeanFactory.isAllowBeanDefinitionOverriding() is false .
class
Exception thrown when the validation of a bean definition failed.
class
A subclass of BeanCreationException which indicates that the target scope is not active, e.g.

Uses of NestedRuntimeException in org.springframework.beans.factory.xml

Modifier and Type
Class
Description
class
XML-specific BeanDefinitionStoreException subclass that wraps a SAXException , typically a SAXParseException which contains information about the error location.

Uses of NestedRuntimeException in org.springframework.context

Modifier and Type
Class
Description
class
Exception thrown during application context initialization.

Uses of NestedRuntimeException in org.springframework.core.annotation

Modifier and Type
Class
Description
class
Thrown by AnnotationUtils and synthesized annotations if an annotation is improperly configured.

Uses of NestedRuntimeException in org.springframework.core.codec

Modifier and Type
Class
Description
class
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 Type
Class
Description
class
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 Type
Class
Description
class
Wrapper for the native IOException (or similar) when a Serializer or Deserializer failed.

Uses of NestedRuntimeException in org.springframework.dao

Modifier and Type
Class
Description
class
Exception thrown on failure to acquire a lock during an update, for example during a "select for update" statement.
class
Deprecated.
class
Deprecated.
as of 6.0.3 since it is not in use within core JDBC/ORM support
class
Exception thrown on various data access concurrency failures.
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 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.
class
Exception thrown if certain expected data could not be retrieved, e.g.
class
Deprecated.
class
Exception thrown when an attempt to insert or update data results in violation of a primary key or unique constraint.
class
EmptyResultDataAccessException
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 Type
Class
Description
class
Thrown by HttpMessageConverter implementations when a conversion attempt fails.
class
class

Uses of NestedRuntimeException in org.springframework.jdbc

Modifier and Type
Class
Description
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
Exception thrown when we're not ignoring SQLWarnings .
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 Type
Class
Description
class
Thrown by ScriptUtils 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 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.

Uses of NestedRuntimeException in org.springframework.jdbc.datasource.lookup

Modifier and Type
Class
Description
class
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 Type
Class
Description
class
Exception thrown when the underlying implementation does not support the requested feature of the API.

Uses of NestedRuntimeException in org.springframework.jms

Modifier and Type
Class
Description
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.

Uses of NestedRuntimeException in org.springframework.jms.connection

Modifier and Type
Class
Description
class
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 Type
Class
Description
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.

Uses of NestedRuntimeException in org.springframework.jms.support.converter

Modifier and Type
Class
Description
class
Thrown by MessageConverter implementations when the conversion of an object to/from a Message fails.

Uses of NestedRuntimeException in org.springframework.jms.support.destination

Subclasses of NestedRuntimeException in org.springframework.jms.support.destination
Modifier and Type
Class
Description
class
Thrown by a DestinationResolver when it cannot resolve a destination name.

Uses of NestedRuntimeException in org.springframework.jmx

Modifier and Type
Class
Description
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.

Uses of NestedRuntimeException in org.springframework.jmx.access

Modifier and Type
Class
Description
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.

Uses of NestedRuntimeException in org.springframework.jmx.export

Modifier and Type
Class
Description
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.

Uses of NestedRuntimeException in org.springframework.jmx.export.metadata

Modifier and Type
Class
Description
class
Thrown by the JmxAttributeSource when it encounters incorrect metadata on a managed resource or one of its methods.

Uses of NestedRuntimeException in org.springframework.jmx.export.notification

Modifier and Type
Class
Description
class
Thrown when a JMX Notification is unable to be sent.

Uses of NestedRuntimeException in org.springframework.jndi

Modifier and Type
Class
Description
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 .

Uses of NestedRuntimeException in org.springframework.mail

Modifier and Type
Class
Description
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.

Uses of NestedRuntimeException in org.springframework.messaging

Modifier and Type
Class
Description
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.

Uses of NestedRuntimeException in org.springframework.messaging.converter

Modifier and Type
Class
Description
class
MessageConversionException
An exception raised by MessageConverter implementations.

Uses of NestedRuntimeException in org.springframework.messaging.core

Modifier and Type
Class
Description
class
Thrown by a DestinationResolver when it cannot resolve a destination.

Uses of NestedRuntimeException in org.springframework.messaging.handler.annotation.support

Modifier and Type
Class
Description
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.

Uses of NestedRuntimeException in org.springframework.messaging.handler.invocation

Modifier and Type
Class
Description
class
Common exception resulting from the invocation of HandlerMethodArgumentResolver .

Uses of NestedRuntimeException in org.springframework.messaging.simp.annotation.support

Modifier and Type
Class
Description
class
MessagingException thrown when a session is missing.

Uses of NestedRuntimeException in org.springframework.messaging.simp.stomp

Modifier and Type
Class
Description
class
Raised after a failure to encode or decode a STOMP message.

Uses of NestedRuntimeException in org.springframework.orm

Modifier and Type
Class
Description
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.

Uses of NestedRuntimeException in org.springframework.orm.hibernate5

Modifier and Type
Class
Description
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.

Uses of NestedRuntimeException in org.springframework.orm.jpa

Modifier and Type
Class
Description
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.

Uses of NestedRuntimeException in org.springframework.oxm

Modifier and Type
Class
Description
class
Base class for exception thrown when a marshalling or unmarshalling error occurs.
class
Exception thrown on marshalling failure.
class
UncategorizedMappingException
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 Type
Class
Description
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.

Uses of NestedRuntimeException in org.springframework.r2dbc.connection.init

Modifier and Type
Class
Description
class
Thrown by ScriptUtils 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 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.

Uses of NestedRuntimeException in org.springframework.r2dbc.connection.lookup

Modifier and Type
Class
Description
class
Exception to be thrown by a ConnectionFactoryLookup implementation, indicating that the specified ConnectionFactory could not be obtained.

Uses of NestedRuntimeException in org.springframework.r2dbc.core.binding

Modifier and Type
Class
Description
static class
Exception thrown when BindMarkersFactoryResolver cannot resolve a BindMarkersFactory .

Uses of NestedRuntimeException in org.springframework.scheduling

Modifier and Type
Class
Description
class
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 Type
Class
Description
class
Unchecked exception that wraps an exception thrown from a target method.

Uses of NestedRuntimeException in org.springframework.scripting

Modifier and Type
Class
Description
class
Exception to be thrown on script compilation failure.

Uses of NestedRuntimeException in org.springframework.scripting.bsh

Modifier and Type
Class
Description
static final class
Exception to be thrown on script execution failure.

Uses of NestedRuntimeException in org.springframework.transaction

Modifier and Type
Class
Description
class
Exception thrown when a transaction can't be created using an underlying transaction API such as JTA.
class
HeuristicCompletionException
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.

Uses of NestedRuntimeException in org.springframework.web

Modifier and Type
Class
Description
class
RuntimeException that implements ErrorResponse to expose an HTTP status, response headers, and a body formatted as an RFC 9457 ProblemDetail .

Uses of NestedRuntimeException in org.springframework.web.bind.support

Modifier and Type
Class
Description
class
ServerWebInputException subclass that indicates a data binding or validation failure.

Uses of NestedRuntimeException in org.springframework.web.client

Modifier and Type
Class
Description
class
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.UnsupportedMediaType
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 an HttpStatusCode .
class
Exception thrown when an I/O error occurs.
class
Base class for exceptions thrown by RestTemplate in case a request fails because of a server error response, as determined via ResponseErrorHandler.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 suitable HttpMessageConverter 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 Type
Class
Description
class
class
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 Type
Class
Description
class
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 Type
Class
Description
class
Exception thrown to indicate that a Content-Type is not supported.

Uses of NestedRuntimeException in org.springframework.web.reactive.function.client

Modifier and Type
Class
Description
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
WebClientResponseException for HTTP status 502 Bad Gateway.
static class
WebClientResponseException.BadRequest
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.reactive.resource

Modifier and Type
Class
Description
class
Raised when ResourceWebHandler is mapped to the request but can not find a matching resource.

Uses of NestedRuntimeException in org.springframework.web.server

Modifier and Type
Class
Description
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
Subclass of ErrorResponseException that accepts a "reason", and by default maps that to the "detail" of the ProblemDetail .
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).

Uses of NestedRuntimeException in org.springframework.web.socket.server

Modifier and Type
Class
Description
class
Thrown when handshake processing failed to complete due to an internal, unrecoverable error.

Uses of NestedRuntimeException in org.springframework.web.socket.sockjs

Modifier and Type
Class
Description
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.