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. It follows a logical single-class structure with clear field declarations and well-organized constructor overloads. Nesting is minimal, limited to concise getter methods. Each constructor's purpose is well-documented with Javadoc, making intent unambiguous. Code length is appropriate given the multiple constructor variants, and each action is typically on its own line. Reading flow is natural: fields, constructors, then getters. Minor minor deductions for slight repetition in constructor patterns and the moderately verbose Javadoc, but overall this is clean, maintainable exception code.
Run 2
The code is highly readable. It has a clear, logical class structure with well-defined constructors and getter methods. Nesting is minimal, limited to simple conditional checks. Intent is explicit through meaningful method names and thorough Javadoc. Code length is appropriate for an exception class with multiple construction scenarios. Each action is on its own line, improving clarity. Reading flow is natural, progressing from constructors to accessors. Minor deductions: the constructor chaining and message concatenation add slight verbosity, but they remain clear and justified within the domain context.
Run 3
The code is highly readable with a clear, logical structure. It follows standard Java exception class conventions with a clean class hierarchy and well-organized constructor overloads. Nesting is minimal, and each method performs a single, focused action. Javadoc comments thoroughly explain each constructor and method's purpose, enhancing clarity of intent. The use of @Nullable annotations and modern Java pattern matching improves readability and type safety. The class is appropriately concise for its purpose, though the multiple constructor overloads create some unavoidable repetition. Methods like getPersistentClassName() have clear logic flow despite using ternary conditional expressions. The code maintains consistent formatting, proper line breaks for long constructor parameters, and follows Spring framework coding standards. It could be slightly improved by reducing constructor overloads through a builder pattern, but for an exception class, this approach is conventional and appropriate.
Run 1
Code Structure: Fields, related constructor overloads, and getters are logically grouped. 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: Implementation is 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: Consistent formatting and constructor delegation support natural top-to-bottom reading, with minor repetition across overloads.
Run 2
Code Structure: Fields, constructors, and accessors are logically grouped, with constructor delegation reducing duplication. Nesting: Almost entirely 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: Appropriate for the supported overloads, though repeated constructor documentation and message construction add some verbosity. Action granularity: Each statement performs a single clear action; wrapped constructor calls remain understandable. Reading flow: Consistent formatting and a natural progression from initialization to retrieval make the code easy to follow. Minor drawbacks are long message expressions and repeated overload patterns.
Run 3
Code Structure: Fields, constructors, and getters are logically grouped, with consistent formatting and useful documentation. Nesting: Almost entirely flat; the only conditional block is simple and shallow. 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 its representation. Code length: Reasonably concise, although parallel constructor overloads and repeated documentation add some redundancy. Action granularity: Each statement performs one clear action; constructor delegation avoids unnecessary repetition. Reading flow: Natural progression from state to initialization to accessors. Long constructor signatures and concatenated message expressions introduce minor reading friction.