Source code
package org.springframework.cache.jcache.interceptor;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import javax.cache.annotation.CacheInvocationParameter;
import javax.cache.annotation.CacheKeyGenerator;
import javax.cache.annotation.CacheKeyInvocationContext;
import org.jspecify.annotations.Nullable;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.util.Assert;
import org.springframework.util.CollectionUtils;
class KeyGeneratorAdapter implements KeyGenerator {
private final JCacheOperationSource cacheOperationSource;
private @Nullable KeyGenerator keyGenerator;
private @Nullable CacheKeyGenerator cacheKeyGenerator;
public KeyGeneratorAdapter(JCacheOperationSource cacheOperationSource, KeyGenerator target) {
Assert.notNull(cacheOperationSource, "JCacheOperationSource must not be null");
Assert.notNull(target, "KeyGenerator must not be null");
this.cacheOperationSource = cacheOperationSource;
this.keyGenerator = target;
}
public KeyGeneratorAdapter(JCacheOperationSource cacheOperationSource, CacheKeyGenerator target) {
Assert.notNull(cacheOperationSource, "JCacheOperationSource must not be null");
Assert.notNull(target, "CacheKeyGenerator must not be null");
this.cacheOperationSource = cacheOperationSource;
this.cacheKeyGenerator = target;
}
public Object getTarget() {
if (this.cacheKeyGenerator != null) {
return this.cacheKeyGenerator;
}
Assert.state(this.keyGenerator != null, "No key generator");
return this.keyGenerator;
}
@Override
public Object generate(Object target, Method method, @Nullable Object... params) {
JCacheOperation<?> operation = this.cacheOperationSource.getCacheOperation(method, target.getClass());
if (!(operation instanceof AbstractJCacheKeyOperation)) {
throw new IllegalStateException("Invalid operation, should be a key-based operation " + operation);
}
CacheKeyInvocationContext<?> invocationContext = createCacheKeyInvocationContext(target, operation, params);
if (this.cacheKeyGenerator != null) {
return this.cacheKeyGenerator.generateCacheKey(invocationContext);
}
else {
Assert.state(this.keyGenerator != null, "No key generator");
return doGenerate(this.keyGenerator, invocationContext);
}
}
private static Object doGenerate(KeyGenerator keyGenerator, CacheKeyInvocationContext<?> context) {
List<Object> parameters = new ArrayList<>();
for (CacheInvocationParameter param : context.getKeyParameters()) {
Object value = param.getValue();
if (param.getParameterPosition() == context.getAllParameters().length - 1 &&
context.getMethod().isVarArgs()) {
parameters.addAll(CollectionUtils.arrayToList(value));
}
else {
parameters.add(value);
}
}
return keyGenerator.generate(context.getTarget(), context.getMethod(), parameters.toArray());
}
@SuppressWarnings("unchecked")
private CacheKeyInvocationContext<?> createCacheKeyInvocationContext(
Object target, JCacheOperation<?> operation, @Nullable Object[] params) {
AbstractJCacheKeyOperation<Annotation> keyCacheOperation = (AbstractJCacheKeyOperation<Annotation>) operation;
return new DefaultCacheKeyInvocationContext<>(keyCacheOperation, target, params);
}
}
Run 1
The code is generally well-structured with clear class and method responsibilities. It follows Spring conventions with useful assertions for validation, contributing to predictable error handling. However, readability is slightly reduced by excessive blank lines between methods and within the class body, making the file feel disjointed. The generate method's length is acceptable, but the varargs flattening logic within doGenerate makes for dense conditional branching — it might read better is isolated in a named helper method. The dual constructors and nullable target strategy are clearly handled, but the 'No key generator' assertion duplication adds minor clutter. Overall intent is clear, with reasonable method lengths and flat nesting.
Run 2
The code is generally well-structured and follows consistent patterns, but it has several readability issues. There are excessive blank lines between members, which disrupts visual flow. The class does not implement the interface it claims to adapt (missing 'implements' keyword in the class declaration), which is confusing. The generate() method has moderate nesting but could be simplified. Multiple null checks and Assert statements create some noise. The doGenerate() method mixes varargs handling logic inline, making it harder to follow. Variable naming is clear, and method purposes are mostly evident, but the overall organization could be tighter. Action granularity is reasonable, with one logical operation per line mostly maintained. The code would benefit from removing unnecessary blank lines, extracting the varargs logic, and perhaps using Optional or cleaner null handling.
Run 3
The code is well-structured with clear separation of concerns: constructors, accessor methods, and utility methods are logically organized. Nesting is minimal, with only one conditional branch in the generate method and a single if-else inside doGenerate, keeping the code flat and readable. Intent is clear—adapting two key generator interfaces—with descriptive method and variable names. Code length is appropriate for the functionality, though there are multiple blank lines that slightly disrupt flow. Action granularity is good; most lines perform a single, meaningful operation. Reading flow is natural, moving from construction to target access to key generation and finally helper methods. Minor readability improvements could include tightening the excessive blank lines and consistent field initialization, but overall the code is highly readable and maintainable.
Run 1
Code Structure: Well-organized adapter with constructors, public methods, and focused private helpers; excessive blank lines weaken presentation. Nesting: Shallow overall, with only a loop containing an if/else. Clarity of intent: Descriptive names and explicit validation make generator delegation clear; varargs flattening and the unchecked cast require some framework knowledge. Code length: Mostly concise, though constructor validation is duplicated and whitespace unnecessarily extends the listing. Action granularity: Statements generally perform one action per line, with readable intermediate variables. Reading flow: Methods progress naturally from initialization to delegation and context creation; the multiline condition and surplus spacing slightly interrupt scanning.
Run 2
Code Structure: Logically organized into constructors, delegation methods, and focused helpers, with minor constructor duplication. Nesting: Shallow overall; only the parameter-processing loop contains a nested conditional. Clarity of intent: Descriptive class, method, and variable names make the adapter purpose clear, though nullable alternative delegates and the unchecked cast require some interpretation. Code length: Implementation is reasonably concise, but excessive blank lines unnecessarily lengthen the presentation. Action granularity: Each statement performs a distinct action, with no crowded multi-statement lines. Reading flow: Validation, context creation, and delegation follow a natural sequence; inconsistent spacing and the compound varargs condition slightly interrupt readability.
Run 3
Code Structure: Well-organized adapter with constructors, public methods, and focused helpers; duplicated constructor validation is minor. Nesting: Shallow overall, with only a loop containing a conditional. Clarity of intent: Descriptive class, method, and variable names communicate delegation and key generation clearly, though the mutually exclusive nullable generators and unchecked cast require some inference. Code length: Functional code is reasonably concise, but excessive blank lines unnecessarily expand the listing. Action granularity: Statements generally perform one action per line; the final delegation expression combines several straightforward calls. Reading flow: Validation, context creation, and delegation follow a natural sequence, while irregular whitespace and the wrapped varargs condition slightly interrupt scanning.