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, following a clear, conventional class structure with field declarations, multiple constructors, and accessor methods. Nesting is minimal—limited to simple conditional checks. Each constructor and method has a distinct purpose, making the intent unambiguous. The code is concise without being overly compressed; Javadocs are thorough but not redundant. Action granularity is well managed: one logical operation per line or statement, with no crowded lines. Reading flow is natural, progressing from the class-level exception concept to field retrieval methods. Minor deductions: multiple overloaded constructors slightly reduce conciseness and the pattern-matching instanceof adds mild complexity that might require a second glance.
Run 3
The code is well-structured and highly readable. It follows a clear logical organization with package declaration, imports, Javadoc, class declaration, fields, constructors, and getters. Nesting is minimal; the only conditional is a simple if statement in getPersistentClassName, and pattern matching for instanceof improves clarity. Intent is unambiguous—the exception conveys missing object retrieval information. Code length is appropriate, not overly verbose; Javadoc adds useful documentation. Each action is granular, with one assignment or method call per line, enhancing clarity. Reading flow is natural, moving from general constructors to specific retrieval methods. Minor deductions: the ternary in getPersistentClassName could be slightly clearer, and multiple constructors increase length, but this is justified by flexibility. Overall, it is idiomatic Spring framework Java.
Run 1
Code Structure: Fields, constructors, and accessors are logically grouped, with consistent formatting. Nesting: Almost entirely flat, with only a simple conditional in one accessor. Clarity of intent: Descriptive names, Javadoc, 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, although repeated constructor documentation and message construction add some verbosity. Action granularity: Assignments and returns each occupy separate lines; multiline constructor delegation remains easy to follow. Reading flow: The progression from state to construction to retrieval is natural, with minor friction from similar overloads and long message expressions.
Run 2
Code Structure: Fields, constructors, and accessors are logically grouped, with constructor delegation reducing duplication. Nesting: Nearly flat; the only conditional block is shallow and easy to follow. Clarity of intent: Descriptive names, Javadoc, and nullability annotations clearly explain the exception's purpose and available metadata. However, storing either a Class or String in an Object field slightly obscures its representation. Code length: Reasonably concise for the supported overloads, though repeated documentation and parallel constructors add some verbosity. Action granularity: Statements generally perform one action each; multiline constructor calls remain coherent. Reading flow: Consistent formatting and a natural fields-to-constructors-to-accessors progression make navigation straightforward. Long message expressions and mixed-type handling introduce only minor friction.
Run 3
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 API; storing either a Class or String in an Object field slightly weakens 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 coherent single actions. Reading flow: Consistent formatting and predictable ordering make the class easy to follow, with minor friction from long message expressions and similar constructor overloads.