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 exhibits a clear, logical structure with a predictable exception hierarchy and well-organized constructors. Nesting is minimal, with only simple conditional checks in getters. The intent is unambiguous—each constructor and accessor has a distinct purpose and is documented with Javadoc. Code length is appropriate for the functionality provided, avoiding unnecessary verbosity while maintaining clarity. Action granularity is mostly one action per line, though constructor delegation lines are slightly longer. Reading flow is natural: fields, constructors, then accessors, each with explanatory comments. Minor deductions: parameter lists in multi-arg constructors could be slightly more compact, and the class-level @SuppressWarnings could merit a brief comment. Overall, this is highly readable, maintainable framework code.
Run 3
The code demonstrates excellent readability. Structure is logical with clear separation of fields, constructors, and methods. Nesting is minimal—only simple conditional checks are present, and they are flat. Intention is unambiguous, supported by concise Javadocs on all public APIs. The class is reasonably concise for an exception type with multiple constructor variants. Each action is consistently one per line, and reading flow follows a natural top-to-bottom pattern. Minor deductions are for slight duplication across similar constructors, but this is common and acceptable in exception classes.
Run 1
Code Structure: Fields, grouped constructor overloads, and accessors are logically organized. Nesting: Methods are flat, with only one simple conditional. 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: Implementations are concise, although repeated constructor documentation and message construction add some redundancy. Action granularity: Each assignment and return performs a single clear action; multiline constructor calls remain easy to follow. Reading flow: Consistent formatting and predictable ordering support natural reading, with minor interruptions from lengthy signatures and repeated 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 available metadata; storing either a Class or String in an Object field slightly obscures the representation. Code length: Appropriate for the supported overloads, though repeated constructor documentation and message construction add some verbosity. Action granularity: Each statement performs a single clear action; multiline constructor calls remain easy to follow. Reading flow: Consistent formatting and a natural progression from state to initialization to accessors make the class easy to scan. Long message expressions and similar overloads introduce minor reading 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 communicate the exception's purpose and API behavior; storing either a Class or String in an Object field slightly obscures its representation. Code length: Appropriate for the supported overloads, though repeated documentation and message construction add some verbosity. Action granularity: Each assignment and return performs one clear action; multiline constructor calls remain easy to follow. Reading flow: Consistent formatting and a natural progression from initialization to retrieval make the class easy to scan, with minor friction from long constructor signatures and message expressions.