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 a(Object a, Method b, @Nullable Object... c) {
return b((KotlinDetector.isSuspendingFunction(b) ?
Arrays.copyOf(c, c.length - 1) : c));
}
/**
* Generate a key based on the specified parameters.
*/
public static Object b(@Nullable Object... d) {
if (d.length == 0) {
return SimpleKey.EMPTY;
}
if (d.length == 1) {
Object e = d[0];
if (e != null && !e.getClass().isArray()) {
return e;
}
}
return new SimpleKey(d);
}
}
Run 1
The code structure is fragmented - two separate methods both named with dangerously vague single-letter identifiers ('a', 'b', 'c', 'd', 'e'), which destroys any clarity of intent. There is no obvious reason why the methods or parameters cannot have meaningful names. Method 'a' contains multiple actions packed onto one line (array copy, Kotlin detection, conditional logic) reducing action granularity. The nesting is moderate, but the one-liner conditional combined with an already ambiguous method name makes the flow jarring. The reading flow is unnatural and disorganized; the reader must decode the logic mentally rather than reading it naturally. While the code is concise, it is at the cost of transparency. Code length is good, but readability is severely damaged by the poor naming and compressed logic. Even though the snippet is short, it scores low because every line forces guesswork about the purpose and data flow.
Run 2
The code is severely obfuscated. Method names 'a' and 'b' and parameter names 'a', 'b', 'c', 'd', 'e' reveal no intent, making the logic ambiguous and unreadable. The single-letter identifiers force readers to trace data flow mentally without semantic anchors. Nesting is shallow, but the dense conditional in method 'b' combines multiple checks in one expression. Action granularity is poor — multiple operations occur in the return statement (Kotlin detection, array copy, ternary). Reading flow is disorganized because the core logic is split across two methods with no logical separation. The only readable elements are the Javadoc comments, which ironically describe functionality that the code obscures. Structure is technically present but meaningless due to naming. This appears deliberately renamed or decompiled code rather than maintainable Spring source.
Run 3
The code has some readability issues despite its simple logic. The structure is minimal but the one-letter variable names (a, b, c, d, e) obscure the intent and make the code harder to follow, especially in the overridden method where the logic is dense. Nesting is shallow, which is positive. Action granularity is mostly one action per line, but some lines combine multiple operations (e.g., the Kotlin detector check with array copying). The reading flow is natural in the helper method, but the overridden method's logic is cramped. The Javadoc is helpful but the method names and parameters betray the original Spring source, making the code look obfuscated. Descriptive names and slight refactoring would greatly improve clarity.
Run 1
Code Structure: Logically separates method-aware parameter handling from key generation. Nesting: Shallow overall, with only one nested conditional and clear early returns. Clarity of intent: Class documentation explains the purpose, but single-letter method and variable names obscure roles; the Kotlin-specific argument removal lacks explanation. Code length: Compact without significant redundancy, although documentation occupies much of the snippet. Action granularity: Generally one action per line; the first return combines detection, array copying, and delegation in one expression. Reading flow: Key generation proceeds naturally from empty parameters to a single value and then the general case, but cryptic identifiers and the wrapped ternary interrupt comprehension.
Run 2
Code Structure: Two small methods cleanly separate argument preprocessing from key generation. Nesting: Mostly flat, with early returns and only one nested conditional. Clarity of intent: Documentation explains the purpose, but single-letter method and variable names obscure roles, and the Kotlin-specific argument removal is unexplained. Code length: Concise without substantial redundancy. Action granularity: Most lines perform one action, although the first return combines suspension detection, argument copying, and key generation. Reading flow: The key-generation cases follow a natural progression from zero parameters to one parameter to multiple parameters; however, cryptic identifiers and the wrapped ternary interrupt readability.
Run 3
Code Structure: Two small methods cleanly separate argument preprocessing from key generation. Nesting: Early returns keep nesting shallow, with only one nested conditional. Clarity of intent: Documentation explains key generation well, but single-letter method and variable names obscure roles; the Kotlin-specific argument removal lacks explanation. Code length: The implementation is concise without substantial redundancy. Action granularity: Most statements perform one action, though the first method combines detection, array copying, and delegation in a ternary expression. Reading flow: The empty, single-value, and fallback cases follow a natural progression, but ambiguous names, the wrapped ternary, and extra parentheses interrupt readability.