Source code
package org.springframework.orm;
import org.jspecify.annotations.Nullable;
import org.springframework.dao.DataRetrievalFailureException;
/**
* Exception thrown if a mapped object could not be retrieved via its identifier.
* Provides information about the persistent class and the identifier.
*
* @author Juergen Hoeller
* @since 13.10.2003
*/
@SuppressWarnings("serial")
public class ObjectRetrievalFailureException extends DataRetrievalFailureException {
private final @Nullable Object persistentClass;
private final @Nullable Object identifier;
/**
* Create a general ObjectRetrievalFailureException with the given message,
* without any information on the affected object.
* @param msg the detail message
* @param cause the source exception
*/
public ObjectRetrievalFailureException(@Nullable String msg, Throwable cause) {
super(msg, cause);
this.persistentClass = null;
this.identifier = null;
}
/**
* Create a new ObjectRetrievalFailureException for the given object,
* with the default "not found" message.
* @param persistentClass the persistent class
* @param identifier the ID of the object that should have been retrieved
*/
public ObjectRetrievalFailureException(Class<?> persistentClass, Object identifier) {
this(persistentClass, identifier,
"Object of class [" + persistentClass.getName() + "] with identifier [" + identifier + "]: not found",
null);
}
/**
* Create a new ObjectRetrievalFailureException for the given object,
* with the given explicit message and exception.
* @param persistentClass the persistent class
* @param identifier the ID of the object that should have been retrieved
* @param msg the detail message
* @param cause the source exception
*/
public ObjectRetrievalFailureException(
Class<?> persistentClass, @Nullable Object identifier, String msg, @Nullable Throwable cause) {
super(msg, cause);
this.persistentClass = persistentClass;
this.identifier = identifier;
}
/**
* Create a new ObjectRetrievalFailureException for the given object,
* with the default "not found" message.
* @param persistentClassName the name of the persistent class
* @param identifier the ID of the object that should have been retrieved
*/
public ObjectRetrievalFailureException(String persistentClassName, Object identifier) {
this(persistentClassName, identifier,
"Object of class [" + persistentClassName + "] with identifier [" + identifier + "]: not found",
null);
}
/**
* Create a new ObjectRetrievalFailureException for the given object,
* with the given explicit message and exception.
* @param persistentClassName the name of the persistent class
* @param identifier the ID of the object that should have been retrieved
* @param msg the detail message
* @param cause the source exception
*/
public ObjectRetrievalFailureException(
String persistentClassName, @Nullable Object identifier, @Nullable String msg, @Nullable Throwable cause) {
super(msg, cause);
this.persistentClass = persistentClassName;
this.identifier = identifier;
}
/**
* Return the persistent class of the object that was not found.
* If no Class was specified, this method returns null.
*/
public @Nullable Class<?> getPersistentClass() {
return (this.persistentClass instanceof Class<?> clazz ? clazz : null);
}
/**
* Return the name of the persistent class of the object that was not found.
* Will work for both Class objects and String names.
*/
public @Nullable String getPersistentClassName() {
if (this.persistentClass instanceof Class<?> clazz) {
return clazz.getName();
}
return (this.persistentClass != null ? this.persistentClass.toString() : null);
}
/**
* Return the identifier of the object that was not found.
*/
public @Nullable Object getIdentifier() {
return this.identifier;
}
}
Run 1
The code is highly readable, following clear structure and best practices. It uses a logical class organization with grouped fields, multiple well-documented constructors, and clearly named accessor methods. Nesting is minimal; the only conditional logic appears in short, flat helper methods. Each constructor and method has a distinct, single responsibility. Action granularity is excellent—each line performs one clear operation or assignment. Javadoc comments thoroughly explain intent, parameters, and edge cases, making the ambiguity low. The code length is appropriate for the class's purpose, with concise implementation and no redundancy. Reading flow is natural: class documentation, fields, constructors in order of increasing specificity, then getters. Null-safety annotations improve clarity. Minor deductions are only theoretical, such as the slight duplication between Class-based and String-based constructors, but overall this is exemplary readable production code.
Run 2
The code is highly readable. It follows a clear, logical structure with a well-defined class hierarchy and comprehensive Javadoc comments on every constructor and method. Nesting is minimal, limited to simple conditional checks in getters. Intent is clear: this is a specialized exception for object retrieval failures. The code is concise, with no unnecessary duplication (constructor chaining is used effectively). Each action generally has its own line, improving clarity. Reading flow is natural, from fields to constructors to accessors. Minor deductions: the getPersistentClassName method could be slightly clearer, and the @Nullable annotations add some visual noise, but overall the code is exceptionally clean and maintainable.
Run 3
The code is well-structured with clear separation of constructors and getters, follows Java conventions, and shows flat nesting. Javadocs explicitly document each constructor's purpose and parameters. While there are several overloaded constructors, they remain readable due to consistent ordering and delegation. Minor improvements could include reducing repetitive Javadoc or using a builder pattern, but overall clarity is high with single actions per line.
Run 1
Code Structure: Fields, constructor overloads, and accessors are logically grouped, with consistent formatting. Nesting: Almost entirely flat, with only one shallow conditional. Clarity of intent: Descriptive names, Javadocs, and nullability annotations clearly explain the exception's purpose; storing either a Class or String in an Object field slightly obscures its representation. Code length: Methods are concise, though repeated constructor documentation and default-message construction add some verbosity. Action granularity: Each statement performs a single clear action; multiline constructor calls remain easy to follow. Reading flow: The progression from state to initialization to retrieval is natural, and constructor delegation makes relationships clear. Minor friction comes from long message expressions and repetitive overloads.
Run 2
Code Structure: Fields, constructors, and accessors are logically grouped, with constructor delegation reducing duplication. Nesting: Almost entirely flat, with only one simple conditional. Clarity of intent: Descriptive names, Javadoc, and nullability annotations clearly explain the exception's purpose and behavior; storing either a Class or String in an Object field slightly weakens type clarity. Code length: Reasonably concise, though repeated constructor documentation and default-message construction add some verbosity. Action granularity: Each assignment and return occupies its own line; multiline constructor calls remain understandable. Reading flow: Consistent formatting and a natural progression from initialization to accessors make the class easy to follow, with only minor friction from similar overloads and long message expressions.
Run 3
Code Structure: Fields, constructors, and accessors are logically grouped, with constructor delegation reducing duplication. Nesting: Methods are flat, with only one shallow conditional. Clarity of intent: Descriptive names, Javadoc, and nullability annotations clearly communicate the exception's purpose; storing either a Class or String in an Object field slightly obscures the representation. Code length: Implementations are concise, though repeated constructor documentation and similar overloads add some verbosity. Action granularity: Statements generally perform one action per line; wrapped constructor calls remain understandable. Reading flow: Consistent formatting and a natural fields-to-constructors-to-accessors progression make the class easy to follow, with only minor interruptions from long message expressions and repetitive documentation.