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) {
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 is highly readable with clear structure and intent. The class follows a logical organization, starting with imports, class documentation, and method implementation. Nesting is minimal—only two levels in generateKey—and the flat structure aids comprehension. The purpose of each block is evident: generateKey handles zero, single, and multiple parameter cases distinctly. Code length is concise with no redundant logic. Action granularity is well-maintained, with each line performing a single logical operation. The reading flow is natural, progressing from simple cases to the default. The only minor complexity is the Kotlin detection logic, which slightly obscures the intent of generate(), but the overall design remains clean and maintainable.
Run 2
The code is well-structured with clear separation of concerns between the interface implementation and the static key generation logic. Nesting is minimal - only two levels deep in the conditional checks. Intent is clearly expressed through descriptive method names and Javadoc comments. The code is concise, with no unnecessary verbosity. Action granularity is appropriate with one logical action per line. Reading flow is natural from the public interface method to the static utility method. Minor deductions: the ternary operator in generate() adds slight complexity and the @Nullable annotation on varargs could be clearer for readers unfamiliar with Spring conventions. Overall, this is highly readable production-quality code.
Run 3
The code is highly readable with clear structure and intent. The class has a single responsibility (generating cache keys) and follows Spring conventions. The generate method uses a clean ternary for handling Kotlin suspending functions, though the inline expression could be slightly more readable if extracted. The generateKey method uses early returns to avoid nesting, making the logic flat and easy to follow. Variable names are descriptive, and the method length is appropriate. The Javadoc provides useful context about usage and limitations. Minor deductions: the ternary expression in generate() packs multiple actions into one line, and the condition checking for arrays in the single-parameter case could benefit from a helper method for clarity. Overall, the code demonstrates good readability with logical flow and minimal complexity.
Run 1
Code Structure: Two focused methods cleanly separate Kotlin parameter handling from key generation. Nesting: Mostly flat, with early returns and only one shallow nested condition. Clarity of intent: Descriptive names and documentation explain the key-generation rules; excluding the final parameter of a Kotlin suspending function could use a brief explanatory comment. Code length: Concise implementation with useful, slightly extensive documentation. Action granularity: Each statement performs one clear action, although the ternary combines parameter selection and copying within a method call. Reading flow: The progression from no parameters to a single eligible parameter and then the general fallback is natural. Minor formatting issues, such as tightly grouped imports and redundant parentheses around the ternary, slightly reduce readability.
Run 2
Code Structure: Two focused methods cleanly separate framework integration from key generation. Nesting: Early returns keep control flow mostly flat, with only a shallow nested check for a single parameter. Clarity of intent: Descriptive names and documentation explain the key-generation rules, although the Kotlin-specific removal of the final parameter lacks an explanatory comment. Code length: The implementation is concise, and the documentation provides useful context. Action granularity: Statements generally perform one action each; the conditional expression in generate combines parameter adjustment and delegation, slightly increasing cognitive load. Reading flow: The empty, single-value, and fallback cases follow a natural sequence. Minor formatting issues, such as tightly grouped imports and redundant parentheses around the conditional expression, slightly reduce polish.
Run 3
Code Structure: Two focused methods cleanly separate Kotlin-specific parameter handling from key generation. Nesting: Early returns keep control flow mostly flat, with only one modest nested condition. Clarity of intent: Descriptive names and documentation clearly explain key generation, though excluding the final parameter for Kotlin suspending functions requires background knowledge. Code length: The implementation is concise without unnecessary repetition; documentation adds useful context. Action granularity: Each statement performs a focused action, although the ternary expression combines detection, array copying, and delegation. Reading flow: Parameter handling followed by empty, single-value, and general cases reads naturally. The wrapped ternary and missing spacing between package and import declarations slightly reduce readability.