Spring缓存注解SpEL表达式解析缓存注解上 key、condition、unless 等 SpEL 表达式的解析
SpEl ⽀持的计算变量：
1）#ai、#pi、#命名参数【i 表⽰参数下标，从 0 开始】
2）#result：CachePut 操作和后处理 CacheEvict 操作都可使⽤
3）#root：CacheExpressionRootObject 对象
计算上下⽂根对象
/**
* 缓存注解 SpEL 表达式计算上下⽂根对象
*/
class CacheExpressionRootObject {
/**
* 有效的缓存集合
*/
private final Collection<? extends Cache> caches;
/**
* ⽬标⽅法
*/
private final Method method;
/**
* ⽅法参数
*/
private final Object[] args;
/
**
* ⽬标对象
*/
private final Object target;
/**
* ⽬标对象 Class 类型
*/
private final Class<?> targetClass;
}
缓存计算上下⽂【附加⽅法参数和返回结果作为计算变量】
/**
* 基于⽅法的表达式计算上下⽂
* @since 4.2
*/
public class MethodBasedEvaluationContext extends StandardEvaluationContext {
/**
* ⽬标⽅法
*/
private final Method method;
/**
* 参数数组
*/
private final Object[] arguments;
/**
* 参数名发现者
*/
private final ParameterNameDiscoverer parameterNameDiscoverer;
/**
* 参数变量是否已经加载
*/
private boolean argumentsLoaded = false;
public MethodBasedEvaluationContext(Object rootObject, Method method, Object[] arguments,
ParameterNameDiscoverer parameterNameDiscoverer) {
super(rootObject);
this.arguments = arguments;
this.parameterNameDiscoverer = parameterNameDiscoverer;
}
@Override
@Nullable
public Object lookupVariable(String name) {
// 1）尝试从变量映射中读取指定名称的对象
Object variable = super.lookupVariable(name);
if (variable != null) {
return variable;
}
// 2）未读到 && ⽅法参数未加载
if (!this.argumentsLoaded) {
// 加载⽅法参数
lazyLoadArguments();
this.argumentsLoaded = true;
// 再次读取
variable = super.lookupVariable(name);
}
return variable;
}
protected void lazyLoadArguments() {
// ⽆参数则直接退出
if (ObjectUtils.isEmpty(this.arguments)) {
return;
}
// 读取⽬标⽅法的所有参数名称
String[] paramNames = hod);
// 计算形参个数，以解析到的参数名优先【可能存在可变参数】
int paramCount = (paramNames != null ? paramNames.length : ParameterCount()); // 实际传⼊的参数个数
int argsCount = this.arguments.length;
for (int i = 0; i < paramCount; i++) {
Object value = null;
/**
* 实际传⼊的参数个数 > 形参个数
* && 将余下的所有⼊参都加⼊到数组中【⽬标⽅法最后⼀个参数是可变参数】
*/
if (argsCount > paramCount && i == paramCount - 1) {
value = pyOfRange(this.arguments, i, argsCount);
}
// 读取实际参数
else if (argsCount > i) {
/
/ Actual argument found - otherwise left as null
value = this.arguments[i];
}
/**
* 将 ai、pi、实际参数名称作为键，加⼊到计算变量映射中
* a0、p0 都表⽰第⼀个参数，依次类推
*/
setVariable("a" + i, value);
setVariable("p" + i, value);
if (paramNames != null) {
setVariable(paramNames[i], value);
}
}
}
}
/**
* 缓存计算上下⽂，⾃动将⽅法参数添加为计算变量。
*/
spring framework表达式assignclass CacheEvaluationContext extends MethodBasedEvaluationContext {
/**
* 不可⽅法的变量集合
*/
private final Set<String> unavailableVariables = new HashSet<>(1);
CacheEvaluationContext(Object rootObject, Method method, Object[] arguments,
ParameterNameDiscoverer parameterNameDiscoverer) {
super(rootObject, method, arguments, parameterNameDiscoverer);
}
/**
* 添加不可访问的变量名称
*/
public void addUnavailableVariable(String name) {
this.unavailableVariables.add(name);
}
/
**
* 读取变量的值
*/
@Override
@Nullable
public Object lookupVariable(String name) {
if (ains(name)) {
throw new VariableNotAvailableException(name);
}
return super.lookupVariable(name);
}
}
缓存注解上 SpEL 表达式计算器
/**
* ⽤于计算缓存注解上 SpEL 表达式值的⼯具类
*/
public abstract class CachedExpressionEvaluator {
/**
* 表达式解析器
*/
private final SpelExpressionParser parser;
/**
* 参数名称发现者
*/
private final ParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer(); protected CachedExpressionEvaluator(SpelExpressionParser parser) {
this.parser = parser;
}
protected CachedExpressionEvaluator() {
this(new SpelExpressionParser());
}
protected SpelExpressionParser getParser() {
return parser;
}
protected ParameterNameDiscoverer getParameterNameDiscoverer() {
return parameterNameDiscoverer;
}
/**
* 将缓存注解上的 SpEL 表达式字符串解析为 Expression
*/
protected Expression getExpression(Map<ExpressionKey, Expression> cache,
AnnotatedElementKey elementKey, String expression) {
// 创建缓存键
final ExpressionKey expressionKey = createKey(elementKey, expression);
// 如果已存在则直接返回
Expression expr = (expressionKey);
if (expr == null) {
// 使⽤ SpelExpressionParser 解析表达式字符串
expr = getParser().parseExpression(expression);
// 写⼊缓存
cache.put(expressionKey, expr);
}
return expr;
}
private ExpressionKey createKey(AnnotatedElementKey elementKey, String expression) {
return new ExpressionKey(elementKey, expression);
}
protected static class ExpressionKey implements Comparable<ExpressionKey> {
/**
* 注解元素+⽬标类型
*/
private final AnnotatedElementKey element;
/**
* SpEL 表达式字符串
*/
private final String expression;
protected ExpressionKey(AnnotatedElementKey element, String expression) {
this.element = element;
}
@Override
public boolean equals(Object other) {
if (this == other) {
return true;
}
if (!(other instanceof ExpressionKey)) {
return false;
}
final ExpressionKey otherKey = (ExpressionKey) other;
return element.equals(otherKey.element) &&
ObjectUtils.nullSafeEquals(expression, pression);
}
@Override
public int hashCode() {
return element.hashCode() * 29 + expression.hashCode();
}
@Override
public String toString() {
return element + " with expression \"" + expression + "\"";
}
@Override
public int compareTo(ExpressionKey other) {
int result = String()pareTo(String());
if (result == 0) {
result = pression);
}
return result;
}
}
}
/**
* 处理缓存 SpEL 表达式解析的⼯具类
*/
class CacheOperationExpressionEvaluator extends CachedExpressionEvaluator {
/**
* 指⽰没有结果变量
*/
public static final Object NO_RESULT = new Object();
/**
* 结果变量不可使⽤
*/
public static final Object RESULT_UNAVAILABLE = new Object();
/**
* 计算上下⽂中，保存结果对象的变量名称
*/
public static final String RESULT_VARIABLE = "result";
/**
* key 表达式缓存
*/
private final Map<ExpressionKey, Expression> keyCache = new ConcurrentHashMap<>(64);
/**
* condition 条件表达式缓存
*/
private final Map<ExpressionKey, Expression> conditionCache = new ConcurrentHashMap<>(64);
/**
* unless 条件表达式缓存
*/
private final Map<ExpressionKey, Expression> unlessCache = new ConcurrentHashMap<>(64);
public EvaluationContext createEvaluationContext(Collection<? extends Cache> caches,
Method method, Object[] args, Object target, Class<?> targetClass, Method targetMethod,
@Nullable Object result, @Nullable BeanFactory beanFactory) {
// 创建计算上下⽂的根对象
final CacheExpressionRootObject rootObject = new CacheExpressionRootObject(
caches, method, args, target, targetClass);
// 创建缓存计算上下⽂
final CacheEvaluationContext evaluationContext = new CacheEvaluationContext(
rootObject, targetMethod, args, getParameterNameDiscoverer());
// 1）⽅法返回值不可⽤
if (result == RESULT_UNAVAILABLE) {
evaluationContext.addUnavailableVariable(RESULT_VARIABLE);
}
// 2）⽅法返回值可⽤，则以 result 作为 key 将其加⼊到计算变量中
else if (result != NO_RESULT) {
evaluationContext.setVariable(RESULT_VARIABLE, result);
}
if (beanFactory != null) {
// 写⼊ BeanFactoryResolver
evaluationContext.setBeanResolver(new BeanFactoryResolver(beanFactory));
}
return evaluationContext;
}
/
**
* 计算键的值
*/
@Nullable
public Object key(String keyExpression, AnnotatedElementKey methodKey, EvaluationContext evalContext) {
return getExpression(keyCache, methodKey, keyExpression).getValue(evalContext);
}
/**
* 计算 condition 值
*/
public boolean condition(String conditionExpression, AnnotatedElementKey methodKey, EvaluationContext evalContext) {
return Boolean.TRUE.equals(getExpression(conditionCache, methodKey, conditionExpression).getValue(
evalContext, Boolean.class));
}
/**
* 计算 unless 值
*/
public boolean unless(String unlessExpression, AnnotatedElementKey methodKey, EvaluationContext evalContext) { return Boolean.TRUE.equals(getExpression(unlessCache, methodKey, unlessExpression).getValue(
evalContext, Boolean.class));
}
/**
* Clear all caches.
*/
void clear() {
keyCache.clear();
conditionCache.clear();
unlessCache.clear();
}
}
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论