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 due to its clear structure, consistent formatting, and well-documented constructors. It uses a flat class hierarchy with minimal nesting, and each constructor has a single, focused responsibility. Javadoc comments explain intent for each public API method. The use of pattern matching in getPersistentClass() and getPersistentClassName() improves clarity. Lines are kept concise, and the flow from constructors to getters is natural. Minor deductions include slight verbosity in repeated Javadoc and overloaded constructors, but overall readability is excellent.
Run 3
The code is highly readable. It follows a clear, logical structure with class-level documentation, fields, and well-organized constructors. Nesting is minimal, with only small conditional logic in getter methods. Each constructor and method has a clear, single purpose, and Javadoc comments explain intent effectively. The code is concise without being overly verbose; action granularity is appropriate, with one primary operation per line. Reading flow is natural, moving from construction to retrieval methods. Minor deductions stem from slight repetition in constructor overloads and the nullable type annotations creating minor visual noise, but overall clarity is excellent.
Run 1
Code Structure: Fields, constructors, and accessors are logically grouped, with consistent formatting and constructor delegation. Nesting: Almost entirely flat, with only one simple 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 weakens type clarity. Code length: Implementation is concise, though repeated constructor documentation and duplicated default-message construction add some verbosity. Action granularity: Each assignment and return occupies its own line; multiline constructor calls remain easy to follow. Reading flow: The progression from state through initialization to accessors is natural, with minor friction from similar constructor overloads and long message expressions.
Run 2
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 explain the exception and its metadata; storing either a Class or String in an Object field slightly obscures the representation. Code length: Implementation is concise, though repeated constructor documentation and parallel overloads add some verbosity. Action granularity: Each statement performs a single clear action; multiline constructor calls remain understandable. Reading flow: Consistent formatting and predictable ordering support natural reading, with minor friction from long message expressions and repeated overloads.
Run 3
Code Structure: Fields, constructors, and accessors are logically grouped, with consistent formatting and documentation. Nesting: Almost entirely flat; the single conditional is shallow and straightforward. Clarity of intent: Descriptive names, Javadoc, and nullability annotations clearly communicate purpose, although storing either a Class or String in an Object field introduces slight ambiguity. Code length: Reasonably concise for the supported constructor variants, but repeated documentation and message construction add minor verbosity. Action granularity: Statements perform one clear action each; constructor delegation and ternary expressions remain readable. Reading flow: The progression from state to initialization to retrieval is natural, with only long constructor signatures and message expressions slightly interrupting the flow.