org.springframework.dao (Spring Framework API 2.1) - Spring Framework 2.1.0 API 文档英文版

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

The Spring Framework

PREV PACKAGE NEXT PACKAGE

FRAMES NO FRAMES

Package org.springframework.dao

Exception hierarchy enabling sophisticated error handling independent of the data access approach in use.

See:
Description

Exception Summary

CannotAcquireLockException Exception thrown on failure to aquire a lock during an update, for example during a "select for update" statement.

CannotSerializeTransactionException Exception thrown on failure to complete a transaction in serialized mode due to update conflicts.

CleanupFailureDataAccessException Exception thrown when we couldn't cleanup after a data access operation, but the actual operation went OK.

ConcurrencyFailureException Exception thrown on concurrency failure.

DataAccessException Root of the hierarchy of data access exceptions discussed in Expert One-On-One J2EE Design and Development.

DataAccessResourceFailureException Data access exception thrown when a resource fails completely: for example, if we can't connect to a database using JDBC.

DataIntegrityViolationException Exception thrown when an attempt to insert or update data results in violation of an integrity constraint.

DataRetrievalFailureException Exception thrown if certain expected data could not be retrieved, e.g.

DeadlockLoserDataAccessException Generic exception thrown when the current process was a deadlock loser, and its transaction rolled back.

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.

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.

IncorrectUpdateSemanticsDataAccessException Data access exception thrown when something unintended appears to have happened with an update, but the transaction hasn't already been rolled back.

InvalidDataAccessApiUsageException Exception thrown on incorrect usage of the API, such as failing to "compile" a query object that needed compilation before execution.

InvalidDataAccessResourceUsageException Root for exceptions thrown when we use a data access resource incorrectly.

OptimisticLockingFailureException Exception thrown on an optimistic locking violation.

PermissionDeniedDataAccessException Exception thrown when the underlying resource denied a permission to access a specific element, such as a specific database table.

PessimisticLockingFailureException Exception thrown on a pessimistic locking violation.

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.

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.

Exception Summary
CannotAcquireLockException	Exception thrown on failure to aquire a lock during an update, for example during a "select for update" statement.
CannotSerializeTransactionException	Exception thrown on failure to complete a transaction in serialized mode due to update conflicts.
CleanupFailureDataAccessException	Exception thrown when we couldn't cleanup after a data access operation, but the actual operation went OK.
ConcurrencyFailureException	Exception thrown on concurrency failure.
DataAccessException	Root of the hierarchy of data access exceptions discussed in Expert One-On-One J2EE Design and Development.
DataAccessResourceFailureException	Data access exception thrown when a resource fails completely: for example, if we can't connect to a database using JDBC.
DataIntegrityViolationException	Exception thrown when an attempt to insert or update data results in violation of an integrity constraint.
DataRetrievalFailureException	Exception thrown if certain expected data could not be retrieved, e.g.
DeadlockLoserDataAccessException	Generic exception thrown when the current process was a deadlock loser, and its transaction rolled back.
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.
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.
IncorrectUpdateSemanticsDataAccessException	Data access exception thrown when something unintended appears to have happened with an update, but the transaction hasn't already been rolled back.
InvalidDataAccessApiUsageException	Exception thrown on incorrect usage of the API, such as failing to "compile" a query object that needed compilation before execution.
InvalidDataAccessResourceUsageException	Root for exceptions thrown when we use a data access resource incorrectly.
OptimisticLockingFailureException	Exception thrown on an optimistic locking violation.
PermissionDeniedDataAccessException	Exception thrown when the underlying resource denied a permission to access a specific element, such as a specific database table.
PessimisticLockingFailureException	Exception thrown on a pessimistic locking violation.
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.
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.

Package org.springframework.dao Description

Exception hierarchy enabling sophisticated error handling independent of the data access approach in use. For example, when DAOs and data access frameworks use the exceptions in this package (and custom subclasses), calling code can detect and handle common problems such as deadlocks without being tied to a particular data access strategy, such as JDBC.

All these exceptions are unchecked, meaning that calling code can leave them uncaught and treat all data access exceptions as fatal.

The classes in this package are discussed in Chapter 9 of Expert One-On-One J2EE Design and Development by Rod Johnson (Wrox, 2002).