The Spring Framework

## Uses of Class
org.springframework.core.NestedRuntimeException

Packages that use NestedRuntimeException
org.springframework.aop: Core Spring AOP interfaces, built on AOP Alliance AOP interoperability interfaces.
org.springframework.aop.aspectj.annotation: Classes enabling AspectJ 5 @Annotated classes to be used in Spring AOP.
org.springframework.aop.framework: Package containing Spring's basic AOP infrastructure, compliant with the AOP Alliance interfaces.
org.springframework.beans: This package contains interfaces and classes for manipulating Java beans.
org.springframework.beans.factory: The core package implementing Spring's lightweight Inversion of Control (IoC) container.
org.springframework.beans.factory.access: Helper infrastructure to locate and access bean factories.
org.springframework.beans.factory.parsing: Support infrastructure for bean definition parsing.
org.springframework.beans.factory.support: Classes supporting the `org.springframework.beans.factory` package.
org.springframework.beans.factory.xml: Contains an abstract XML-based `BeanFactory` implementation, including a standard "spring-beans" DTD.
org.springframework.context: 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.
org.springframework.core.task: This package defines Spring's core TaskExecutor abstraction, and provides SyncTaskExecutor and SimpleAsyncTaskExecutor implementations.
org.springframework.dao: Exception hierarchy enabling sophisticated error handling independent of the data access approach in use.
org.springframework.ejb.access: This package contains classes that allow easy access to EJBs.
org.springframework.jca.cci: This package contains Spring's support for the Common Client Interface (CCI), as defined by the J2EE Connector Architecture.
org.springframework.jdbc: The classes in this package make JDBC easier to use and reduce the likelihood of common errors.
org.springframework.jdbc.datasource.lookup: Provides a strategy for looking up JDBC DataSources by name.
org.springframework.jdbc.support.xml: Abstraction for handling fields of SQLXML data type.
org.springframework.jms: This package contains integration classes for JMS, allowing for Spring-style JMS access.
org.springframework.jms.connection: Provides a PlatformTransactionManager implementation for a single JMS ConnectionFactory, and a SingleConnectionFactory adapter.
org.springframework.jms.listener.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.
org.springframework.jms.support.converter: Provides a MessageConverter abstraction to convert between Java objects and JMS messages.
org.springframework.jms.support.destination: Support classes for Spring's JMS framework.
org.springframework.jmx: 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.
org.springframework.jmx.access: Provides support for accessing remote MBean resources.
org.springframework.jmx.export: This package provides declarative creation and registration of Spring-managed beans as JMX MBeans.
org.springframework.jmx.export.metadata: Provides generic JMX metadata classes and basic support for reading JMX metadata in a provider-agnostic manner.
org.springframework.jmx.export.notification: Provides supporting infrastructure to allow Spring-created MBeans to send JMX notifications.
org.springframework.jndi: 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.
org.springframework.mail: Spring's generic mail infrastructure.
org.springframework.orm: Root package for Spring's O/R Mapping integration classes.
org.springframework.orm.hibernate3: Package providing integration of Hibernate3 with Spring concepts.
org.springframework.orm.jdo: Package providing integration of JDO (Java Date Objects) with Spring concepts.
org.springframework.orm.jpa: Package providing integration of JPA (Java Persistence API) with Spring concepts.
org.springframework.orm.toplink: Package providing integration of Oracle TopLink with Spring concepts.
org.springframework.remoting: Exception hierarchy for Spring's remoting infrastructure, independent of any specific remote method invocation system.
org.springframework.remoting.jaxrpc: Remoting classes for Web Services via JAX-RPC.
org.springframework.remoting.jaxws: Remoting classes for Web Services via JAX-WS (the successor of JAX-RPC), as included in Java 6 and Java EE 5.
org.springframework.remoting.soap: SOAP-specific exceptions and support classes for Spring's remoting subsystem.
org.springframework.scheduling: General exceptions for Spring's scheduling support, independent of any specific scheduling system.
org.springframework.scheduling.quartz: Support classes for the open source scheduler Quartz, allowing to set up Quartz Schedulers, JobDetails and Triggers as beans in a Spring context.
org.springframework.scripting: Core interfaces for Spring's scripting support.
org.springframework.scripting.bsh: Package providing integration of BeanShell into Spring's scripting infrastructure.
org.springframework.scripting.jruby: Package providing integration of JRuby into Spring's scripting infrastructure.
org.springframework.transaction: Exception hierarchy for Spring's transaction infrastructure, independent of any specific transaction management system.
org.springframework.web.multipart: Multipart resolution framework for handling file uploads.

Uses of NestedRuntimeException in org.springframework.aop

Subclasses of NestedRuntimeException in org.springframework.aop
`class` `AopInvocationException` 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

Subclasses of NestedRuntimeException in org.springframework.aop.aspectj.annotation
`class` `NotAnAtAspectException` 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

Subclasses of NestedRuntimeException in org.springframework.aop.framework
`class` `AopConfigException` Exception that gets thrown on illegal AOP configuration arguments.

Uses of NestedRuntimeException in org.springframework.beans

Subclasses of NestedRuntimeException in org.springframework.beans
`class` `BeanInstantiationException` Exception thrown when instantiation of a bean failed.
`class` `BeansException` Abstract superclass for all exceptions thrown in the beans package and subpackages.
`class` `FatalBeanException` Thrown on an unrecoverable problem encountered in the beans packages or sub-packages, e.g. bad class or field.
`class` `InvalidPropertyException` Exception thrown when referring to an invalid bean property.
`class` `MethodInvocationException` Thrown when a bean property getter or setter method throws an exception, analogous to an InvocationTargetException.
`class` `NotReadablePropertyException` Exception thrown on an attempt to get the value of a property that isn't readable, because there's no getter method.
`class` `NotWritablePropertyException` Exception thrown on an attempt to set the value of a property that isn't writable, because there's no setter method.
`class` `NullValueInNestedPathException` Exception thrown when navigation of a valid nested property path encounters a NullPointerException.
`class` `PropertyAccessException` Superclass for exceptions related to a property access, such as type mismatch or invocation target exception.
`class` `PropertyBatchUpdateException` Combined exception, composed of individual PropertyAccessException instances.
`class` `TypeMismatchException` Exception thrown on a type mismatch when trying to set a bean property.

Uses of NestedRuntimeException in org.springframework.beans.factory

Subclasses of NestedRuntimeException in org.springframework.beans.factory
`class` `BeanCreationException` Exception thrown when a BeanFactory encounters an error when attempting to create a bean from a bean definition.
`class` `BeanCreationNotAllowedException` 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` `BeanCurrentlyInCreationException` Exception thrown in case of a reference to a bean that's currently in creation.
`class` `BeanDefinitionStoreException` Exception thrown when a BeanFactory encounters an invalid bean definition: e.g. in case of incomplete or contradictory bean metadata.
`class` `BeanInitializationException` Exception that a bean implementation is suggested to throw if its own factory-aware initialization code fails.
`class` `BeanIsAbstractException` Exception thrown when a bean instance has been requested for a bean which has been defined as abstract
`class` `BeanIsNotAFactoryException` Exception thrown when a bean is not a factory, but a user tries to get at the factory for the given bean name.
`class` `BeanNotOfRequiredTypeException` Thrown when a bean doesn't match the expected type.
`class` `CannotLoadBeanClassException` Exception thrown when the BeanFactory cannot load the specified class of a given bean.
`class` `FactoryBeanNotInitializedException` 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` `NoSuchBeanDefinitionException` Exception thrown when a BeanFactory is asked for a bean instance name for which it cannot find a definition.
`class` `UnsatisfiedDependencyException` 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.access

Subclasses of NestedRuntimeException in org.springframework.beans.factory.access
`class` `BootstrapException` Exception thrown if a bean factory could not be loaded by a bootstrap class.

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

Subclasses of NestedRuntimeException in org.springframework.beans.factory.parsing
`class` `BeanDefinitionParsingException` Exception thrown when a bean definition reader encounters an error during the parsing process.

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

Subclasses of NestedRuntimeException in org.springframework.beans.factory.support
`class` `BeanDefinitionValidationException` Exception thrown when the validation of a bean definition failed.

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

Subclasses of NestedRuntimeException in org.springframework.beans.factory.xml
`class` `XmlBeanDefinitionStoreException` 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

Subclasses of NestedRuntimeException in org.springframework.context
`class` `ApplicationContextException` Exception thrown during application context initialization.

Uses of NestedRuntimeException in org.springframework.core.task

Subclasses of NestedRuntimeException in org.springframework.core.task
`class` `TaskRejectedException` Exception thrown when a `TaskExecutor` rejects to accept a given task for execution.
`class` `TaskTimeoutException` Exception thrown when a `AsyncTaskExecutor` rejects to accept a given task for execution because of the specified timeout.

Uses of NestedRuntimeException in org.springframework.dao

Subclasses of NestedRuntimeException in org.springframework.dao
`class` `CannotAcquireLockException` Exception thrown on failure to aquire a lock during an update, for example during a "select for update" statement.
`class` `CannotSerializeTransactionException` Exception thrown on failure to complete a transaction in serialized mode due to update conflicts.
`class` `CleanupFailureDataAccessException` Exception thrown when we couldn't cleanup after a data access operation, but the actual operation went OK.
`class` `ConcurrencyFailureException` Exception thrown on concurrency failure.
`class` `DataAccessException` Root of the hierarchy of data access exceptions discussed in Expert One-On-One J2EE Design and Development.
`class` `DataAccessResourceFailureException` Data access exception thrown when a resource fails completely: for example, if we can't connect to a database using JDBC.
`class` `DataIntegrityViolationException` Exception thrown when an attempt to insert or update data results in violation of an integrity constraint.
`class` `DataRetrievalFailureException` Exception thrown if certain expected data could not be retrieved, e.g.
`class` `DeadlockLoserDataAccessException` Generic exception thrown when the current process was a deadlock loser, and its transaction rolled back.
`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` `IncorrectResultSizeDataAccessException` 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` `IncorrectUpdateSemanticsDataAccessException` Data access exception thrown when something unintended appears to have happened with an update, but the transaction hasn't already been rolled back.
`class` `InvalidDataAccessApiUsageException` Exception thrown on incorrect usage of the API, such as failing to "compile" a query object that needed compilation before execution.
`class` `InvalidDataAccessResourceUsageException` Root for exceptions thrown when we use a data access resource incorrectly.
`class` `NonTransientDataAccessException` 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` `NonTransientDataAccessResourceException` Data access exception thrown when a resource fails completely and the failure is permanent.
`class` `OptimisticLockingFailureException` Exception thrown on an optimistic locking violation.
`class` `PermissionDeniedDataAccessException` Exception thrown when the underlying resource denied a permission to access a specific element, such as a specific database table.
`class` `PessimisticLockingFailureException` Exception thrown on a pessimistic locking violation.
`class` `RecoverableDataAccessException` 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` `TransientDataAccessException` Root of the hierarchy of data access exceptions that are considered transient - where a previoulsy failed operation might be able to succeed when the operation is retried without any intervention by application-level functionality.
`class` `TransientDataAccessResourceException` Data access exception thrown when a resource fails temporarily and the operation can be retried.
`class` `TypeMismatchDataAccessException` 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` `UncategorizedDataAccessException` Normal superclass when we can't distinguish anything more specific than "something went wrong with the underlying resource": for example, a SQLException from JDBC we can't pinpoint more precisely.

Uses of NestedRuntimeException in org.springframework.ejb.access

Subclasses of NestedRuntimeException in org.springframework.ejb.access
`class` `EjbAccessException` Exception that gets thrown when an EJB stub cannot be accessed properly.

Uses of NestedRuntimeException in org.springframework.jca.cci

Subclasses of NestedRuntimeException in org.springframework.jca.cci
`class` `CannotCreateRecordException` Exception thrown when the creating of a CCI Record failed for connector-internal reasons.
`class` `CannotGetCciConnectionException` Fatal exception thrown when we can't connect to an EIS using CCI.
`class` `CciOperationNotSupportedException` Exception thrown when the connector doesn't support a specific CCI operation.
`class` `InvalidResultSetAccessException` Exception thrown when a ResultSet has been accessed in an invalid fashion.
`class` `RecordTypeNotSupportedException` Exception thrown when the creating of a CCI Record failed because the connector doesn't support the desired CCI Record type.

Uses of NestedRuntimeException in org.springframework.jdbc

Subclasses of NestedRuntimeException in org.springframework.jdbc
`class` `BadSqlGrammarException` Exception thrown when SQL specified is invalid.
`class` `CannotGetJdbcConnectionException` Fatal exception thrown when we can't connect to an RDBMS using JDBC.
`class` `IncorrectResultSetColumnCountException` 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` `JdbcUpdateAffectedIncorrectNumberOfRowsException` Exception thrown when a JDBC update affects an unexpected number of rows.
`class` `LobRetrievalFailureException` Exception to be thrown when a LOB could not be retrieved.
`class` `SQLWarningException` Exception thrown when we're not ignoring `SQLWarnings`.
`class` `UncategorizedSQLException` Exception thrown when we can't classify a SQLException into one of our generic data access exceptions.

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

Subclasses of NestedRuntimeException in org.springframework.jdbc.datasource.lookup
`class` `DataSourceLookupFailureException` 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

Subclasses of NestedRuntimeException in org.springframework.jdbc.support.xml
`class` `SqlXmlFeatureNotImplementedException` Exception thrown when the underlying implementation does not support the requested feature of the API.

Uses of NestedRuntimeException in org.springframework.jms

Subclasses of NestedRuntimeException in org.springframework.jms
`class` `IllegalStateException` Runtime exception mirroring the JMS IllegalStateException.
`class` `InvalidClientIDException` Runtime exception mirroring the JMS InvalidClientIDException.
`class` `InvalidDestinationException` Runtime exception mirroring the JMS InvalidDestinationException.
`class` `InvalidSelectorException` Runtime exception mirroring the JMS InvalidSelectorException.
`class` `JmsException` Base class for exception thrown by the framework whenever it encounters a problem related to JMS.
`class` `JmsSecurityException` Runtime exception mirroring the JMS JMSSecurityException.
`class` `MessageEOFException` Runtime exception mirroring the JMS MessageEOFException.
`class` `MessageFormatException` Runtime exception mirroring the JMS MessageFormatException.
`class` `MessageNotReadableException` Runtime exception mirroring the JMS MessageNotReadableException.
`class` `MessageNotWriteableException` Runtime exception mirroring the JMS MessageNotWriteableException.
`class` `ResourceAllocationException` Runtime exception mirroring the JMS ResourceAllocationException.
`class` `TransactionInProgressException` Runtime exception mirroring the JMS TransactionInProgressException.
`class` `TransactionRolledBackException` Runtime exception mirroring the JMS TransactionRolledBackException.
`class` `UncategorizedJmsException` JmsException to be thrown when no other matching subclass found.

Uses of NestedRuntimeException in org.springframework.jms.connection

Subclasses of NestedRuntimeException in org.springframework.jms.connection
`class` `SynchedLocalTransactionFailedException` 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

Subclasses of NestedRuntimeException in org.springframework.jms.listener.adapter
`class` `ListenerExecutionFailedException` Exception to be thrown when the execution of a listener method failed.

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

Subclasses of NestedRuntimeException in org.springframework.jms.support.converter
`class` `MessageConversionException` 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
`class` `DestinationResolutionException` Thrown by a DestinationResolver when it cannot resolve a destination name.

Uses of NestedRuntimeException in org.springframework.jmx

Subclasses of NestedRuntimeException in org.springframework.jmx
`class` `JmxException` General base exception to be thrown on JMX errors.
`class` `MBeanServerNotFoundException` 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

Subclasses of NestedRuntimeException in org.springframework.jmx.access
`class` `InvocationFailureException` Thrown when trying to invoke an operation on a proxy that is not exposed by the proxied resource's management interface.
`class` `MBeanInfoRetrievalException` Thrown if an exception is encountered when trying to retrieve MBean metadata.

Uses of NestedRuntimeException in org.springframework.jmx.export

Subclasses of NestedRuntimeException in org.springframework.jmx.export
`class` `MBeanExportException` Exception thrown in case of failure when exporting an MBean.
`class` `UnableToRegisterMBeanException` 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

Subclasses of NestedRuntimeException in org.springframework.jmx.export.metadata
`class` `InvalidMetadataException` 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

Subclasses of NestedRuntimeException in org.springframework.jmx.export.notification
`class` `UnableToSendNotificationException` Thrown when a JMX `Notification` is unable to be sent.

Uses of NestedRuntimeException in org.springframework.jndi

Subclasses of NestedRuntimeException in org.springframework.jndi
`class` `JndiLookupFailureException` 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

Subclasses of NestedRuntimeException in org.springframework.mail
`class` `MailAuthenticationException` Exception thrown on failed authentication.
`class` `MailException` Base class for all mail exceptions.
`class` `MailParseException` Exception thrown if illegal message properties are encountered.
`class` `MailPreparationException` Exception to be thrown by user code if a mail cannot be prepared properly, for example when a Velocity template cannot be rendered for the mail text.
`class` `MailSendException` Exception thrown when a mail sending error is encountered.

Uses of NestedRuntimeException in org.springframework.orm

Subclasses of NestedRuntimeException in org.springframework.orm
`class` `ObjectOptimisticLockingFailureException` Exception thrown on an optimistic locking violation for a mapped object.
`class` `ObjectRetrievalFailureException` Exception thrown if a mapped object could not be retrieved via its identifier.

Uses of NestedRuntimeException in org.springframework.orm.hibernate3

Subclasses of NestedRuntimeException in org.springframework.orm.hibernate3
`class` `HibernateJdbcException` Hibernate-specific subclass of UncategorizedDataAccessException, for JDBC exceptions that Hibernate wrapped.
`class` `HibernateObjectRetrievalFailureException` Hibernate-specific subclass of ObjectRetrievalFailureException.
`class` `HibernateOptimisticLockingFailureException` Hibernate-specific subclass of ObjectOptimisticLockingFailureException.
`class` `HibernateQueryException` Hibernate-specific subclass of InvalidDataAccessResourceUsageException, thrown on invalid HQL query syntax.
`class` `HibernateSystemException` 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.jdo

Subclasses of NestedRuntimeException in org.springframework.orm.jdo
`class` `JdoObjectRetrievalFailureException` JDO-specific subclass of ObjectRetrievalFailureException.
`class` `JdoOptimisticLockingFailureException` JDO-specific subclass of ObjectOptimisticLockingFailureException.
`class` `JdoResourceFailureException` JDO-specific subclass of DataAccessResourceFailureException.
`class` `JdoSystemException` JDO-specific subclass of UncategorizedDataAccessException, for JDO system errors that do not match any concrete `org.springframework.dao` exceptions.
`class` `JdoUsageException` JDO-specific subclass of InvalidDataAccessApiUsageException.

Uses of NestedRuntimeException in org.springframework.orm.jpa

Subclasses of NestedRuntimeException in org.springframework.orm.jpa
`class` `JpaObjectRetrievalFailureException` JPA-specific subclass of ObjectRetrievalFailureException.
`class` `JpaOptimisticLockingFailureException` JPA-specific subclass of ObjectOptimisticLockingFailureException.
`class` `JpaSystemException` 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.orm.toplink

Subclasses of NestedRuntimeException in org.springframework.orm.toplink
`class` `TopLinkJdbcException` TopLink-specific subclass of DataAccessException, for JDBC exceptions that TopLink rethrew.
`class` `TopLinkOptimisticLockingFailureException` TopLink-specific subclass of ObjectOptimisticLockingFailureException.
`class` `TopLinkQueryException` TopLink-specific subclass of InvalidDataAccessResourceUsageException, thrown on invalid TopLink query syntax or behavior.
`class` `TopLinkSystemException` TopLink-specific subclass of UncategorizedDataAccessException, for TopLink system errors that do not match any concrete `org.springframework.dao` exceptions.

Uses of NestedRuntimeException in org.springframework.remoting

Subclasses of NestedRuntimeException in org.springframework.remoting
`class` `RemoteAccessException` Generic remote access exception.
`class` `RemoteConnectFailureException` RemoteAccessException subclass to be thrown when no connection could be established with a remote service.
`class` `RemoteInvocationFailureException` RemoteAccessException subclass to be thrown when the execution of the target method failed on the server side, for example when a method was not found on the target object.
`class` `RemoteLookupFailureException` RemoteAccessException subclass to be thrown in case of a lookup failure, typically if the lookup happens on demand for each method invocation.
`class` `RemoteProxyFailureException` RemoteAccessException subclass to be thrown in case of a failure within the client-side proxy for a remote service, for example when a method was not found on the underlying RMI stub.

Uses of NestedRuntimeException in org.springframework.remoting.jaxrpc

Subclasses of NestedRuntimeException in org.springframework.remoting.jaxrpc
`class` `JaxRpcSoapFaultException` Spring SoapFaultException adapter for the JAX-RPC `SOAPFaultException` class.

Uses of NestedRuntimeException in org.springframework.remoting.jaxws

Subclasses of NestedRuntimeException in org.springframework.remoting.jaxws
`class` `JaxWsSoapFaultException` Spring SoapFaultException adapter for the JAX-WS `SOAPFaultException` class.

Uses of NestedRuntimeException in org.springframework.remoting.soap

Subclasses of NestedRuntimeException in org.springframework.remoting.soap
`class` `SoapFaultException` RemoteInvocationFailureException subclass that provides the details of a SOAP fault.

Uses of NestedRuntimeException in org.springframework.scheduling

Subclasses of NestedRuntimeException in org.springframework.scheduling
`class` `SchedulingException` General exception to be thrown on scheduling failures, such as the scheduler already having shut down.

Uses of NestedRuntimeException in org.springframework.scheduling.quartz

Subclasses of NestedRuntimeException in org.springframework.scheduling.quartz
`class` `JobMethodInvocationFailedException` Unchecked exception that wraps an exception thrown from a target method.

Uses of NestedRuntimeException in org.springframework.scripting

Subclasses of NestedRuntimeException in org.springframework.scripting
`class` `ScriptCompilationException` Exception to be thrown on script compilation failure.

Uses of NestedRuntimeException in org.springframework.scripting.bsh

Subclasses of NestedRuntimeException in org.springframework.scripting.bsh
`static class` `BshScriptUtils.BshExecutionException` Exception to be thrown on script execution failure.

Uses of NestedRuntimeException in org.springframework.scripting.jruby

Subclasses of NestedRuntimeException in org.springframework.scripting.jruby
`static class` `JRubyScriptUtils.JRubyExecutionException` Exception thrown in response to a JRuby `RaiseException` being thrown from a JRuby method invocation.

Uses of NestedRuntimeException in org.springframework.transaction

Subclasses of NestedRuntimeException in org.springframework.transaction
`class` `CannotCreateTransactionException` 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` `IllegalTransactionStateException` 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` `InvalidIsolationLevelException` Exception that gets thrown when an invalid isolation level is specified, i.e. an isolation level that the transaction manager implementation doesn't support.
`class` `InvalidTimeoutException` 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` `NestedTransactionNotSupportedException` Exception thrown when attempting to work with a nested transaction but nested transactions are not supported by the underlying backend.
`class` `NoTransactionException` 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` `TransactionException` Superclass for all transaction exceptions.
`class` `TransactionSuspensionNotSupportedException` Exception thrown when attempting to suspend an existing transaction but transaction suspension is not supported by the underlying backend.
`class` `TransactionSystemException` Exception thrown when a general transaction system error is encountered, like on commit or rollback.
`class` `TransactionTimedOutException` Exception to be thrown when a transaction has timed out.
`class` `TransactionUsageException` Superclass for exceptions caused by inappropriate usage of a Spring transaction API.
`class` `UnexpectedRollbackException` Thrown when an attempt to commit a transaction resulted in an unexpected rollback.

Uses of NestedRuntimeException in org.springframework.web.multipart

Subclasses of NestedRuntimeException in org.springframework.web.multipart
`class` `MaxUploadSizeExceededException` MultipartException subclass thrown when an upload exceeds the maximum upload size allowed.
`class` `MultipartException` Exception thrown when multipart resolution fails.

The Spring Framework

Copyright © 2002-2008 The Spring Framework.