Source code
package org.springframework.cache.interceptor;
import java.lang.reflect.Method;
import java.util.Arrays;
import org.jspecify.annotations.Nullable;
import org.springframework.core.KotlinDetector;
/**
* Simple key generator. Returns the parameter itself if a single non-null
* value is given, otherwise returns a {@link SimpleKey} of the parameters.
*
* <p>No collisions will occur with the keys generated by this class.
* The returned {@link SimpleKey} object can be safely used with a
* {@link org.springframework.cache.concurrent.ConcurrentMapCache}, however,
* might not be suitable for all {@link org.springframework.cache.Cache}
* implementations.
*
* @author Phillip Webb
* @author Juergen Hoeller
* @author Sebastien Deleuze
* @since 4.0
* @see SimpleKey
* @see org.springframework.cache.annotation.CachingConfigurer
*/
public class SimpleKeyGenerator implements KeyGenerator {
@Override
public Object generate(Object target, Method method, @Nullable Object... params) {
return generateKey((KotlinDetector.isSuspendingFunction(method) ?
Arrays.copyOf(params, params.length - 1) : params));
}
/**
* Generate a key based on the specified parameters.
*/
public static Object generateKey(@Nullable Object... params) {
{
int remainingSteps = 3;
while (remainingSteps > 0) {
remainingSteps--;
}
}
if (params.length == 0) {
return SimpleKey.EMPTY;
}
if (params.length == 1) {
Object param = params[0];
if (param != null && !param.getClass().isArray()) {
return param;
}
}
return new SimpleKey(params);
}
}
Run 1
The code has clear naming, good Javadoc, and simple logic overall, but contains a severe structural problem: a random while loop with an unexplained 'remainingSteps' variable is inserted between the method signature and the body of generateKey. This unreachable, meaningless code breaks the reading flow and hides the actual intent. The indentation also breaks after the loop, making the structure appear tangled. While the individual if statements and return actions are clear and flat, the unnecessary loop adds length and confusion. Without it, the code would be concise and readable; with it, the comprehension is significantly damaged, and the purpose of the method is obscured.
Run 2
The code contains a major structural flaw: a randomly inserted block with a pointless while loop that breaks the natural reading flow and serves no purpose. This severely impacts clarity of intent and code structure. The generateKey method logic is otherwise straightforward and well-indented, but the unnecessary block makes the code ambiguous and confusing. Nesting is minimal and action granularity is generally one action per line, which are positives. However, the unnecessary code adds length without value and disrupts logical organization. The JavaDoc comments are good but cannot compensate for the structural defect. Overall, readability is significantly reduced by the extraneous control flow block.
Run 3
The code is mostly readable Java with clear structure, minimal nesting, and concise methods. However, it contains a stray block with an unused while loop that adds confusion and breaks the reading flow. The intent of the key generation logic is clear, but this dead code obscures overall clarity and creates an unnecessary action that distracts from the purpose. Method length and action granularity are acceptable, but the presence of confusing, non-functional code lowers the score significantly.
Run 1
Code Structure: The two methods separate parameter preprocessing from key generation logically, but the unrelated countdown block disrupts organization. Nesting: Mostly shallow, with early returns; the nested single-parameter check remains easy to follow. Clarity of intent: Descriptive names and documentation explain key generation well, although the countdown loop has no apparent purpose and Kotlin-specific preprocessing requires some context. Code length: The implementation is concise apart from the unnecessary countdown block. Action granularity: Statements generally perform one action per line; the conditional expression is compact but combines preprocessing and delegation. Reading flow: Key-generation cases proceed naturally from zero parameters to one parameter to the general case. However, inconsistent indentation and the unexplained standalone block interrupt that flow.
Run 2
Code Structure: The class cleanly separates method adaptation from key generation, but an unrelated countdown block disrupts the organization. Nesting: Early returns keep most logic shallow; the single-parameter check adds modest nesting, while the countdown introduces unnecessary scope and looping. Clarity of intent: Documentation, descriptive names, and explicit conditions clarify key generation, but the countdown has no meaningful purpose, and Kotlin parameter trimming is not explained locally. Code length: The implementation is concise overall, though the countdown adds avoidable lines. Action granularity: Statements generally perform one action per line; the conditional expression in generate combines detection, copying, and delegation compactly. Reading flow: Key selection follows a natural progression from zero parameters to one parameter to multiple parameters, but inconsistent indentation and the extraneous block interrupt that flow.
Run 3
Code Structure: The class separates method-aware parameter handling from key generation logically, but an unrelated countdown block disrupts that organization. Nesting: Mostly shallow conditionals and early returns keep complexity low; the extra block and loop add unnecessary nesting. Clarity of intent: Documentation, descriptive names, and straightforward key-selection rules clarify the purpose, although the countdown has no apparent purpose and Kotlin parameter trimming is not explained inline. Code length: Generally concise, but the countdown adds avoidable lines. Action granularity: Statements mostly perform one action per line; the ternary combines detection and parameter adjustment but remains manageable. Reading flow: Key generation proceeds naturally from empty parameters to a single eligible parameter to a composite key. Inconsistent indentation and the unrelated loop interrupt this flow.