在spring中@Value实现原理解析(一)——获取环境变量文章中阐述了@Value的方式注入环境变量的值，这篇文章我们将主要介绍spring如何通过@Value注解实现表达式的计算，以及实现类型转换的。
首先我们在开始源码解读之前，还是首先看一下具体Demo了解一下@Value的另一种使用方式。
DEMO
@Slf4j
@Service
public class ValueAnnotationCollectionService {
@Value("#{'${annotation.strings}'.split(',')}")
private List<String> items;
@PostConstruct
public void init() {
log.info("转换后的集合结果为: {}", Arrays.toString(items.toArray(new String[0])));
}
}
在这个是例子中，我们主要使用@Value实现了两个功能:
- 从环境变量中读取变量:
annotation.strings的值 - 将获取到的值，按照
","分割，并将最终结果转换为List集合
在spring中@Value实现原理解析(一)——获取环境变量中我们介绍了spring是通过什么样的方式从环境变量中获取需要的值, 因此在这里我们就不再赘述，有兴趣的小伙伴可以先查看之前文章。
SpEL表达式解析
在spring中，配合@Value的方式使用SpEL表达式时，固定的使用方式需要"#{}"来表达，当我们在使用"#{}"时，就意味着spring在解析时，需要通过SpEL表达式来解析我们的操作意图。因此我们来看看，在Spring中是通过什么样的方式来实现SpEL表达式的。
DefaultListableBeanFactory
在之前的章节中，介绍了最终的@Value解析是放在了DefaultListableBeanFactory#doResolveDependency()方法中实现的，因此我们查看一下相关的代码:
doResolveDependency()
Class<?> type = descriptor.getDependencyType();
Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
if (value != null) {
if (value instanceof String) {
// 从环境变量中获取变量的具体值，也是解析${}语法的地方
String strVal = resolveEmbeddedValue((String) value);
BeanDefinition bd = (beanName != null && containsBean(beanName) ? getMergedBeanDefinition(beanName) : null);
// 解析SpEL表达式
value = evaluateBeanDefinitionString(strVal, bd);
}
// 获取类型转换器
TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
try {
// 判断是否需要类型转换器，如果需要，则执行类型转换，并返回
return converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor());
}
catch (UnsupportedOperationException ex) {
// A custom TypeConverter which does not support TypeDescriptor resolution...
return (descriptor.getField() != null ?
converter.convertIfNecessary(value, type, descriptor.getField()) :
converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
}
}
因此在上面方法中，我们可以看到，所有SpEL表达式的解析都是在"${}"语法解析完成后进行的。
evaluateBeanDefinitionString()
protected Object evaluateBeanDefinitionString(@Nullable String value, @Nullable BeanDefinition beanDefinition) {
// 判断是否包含了BeanExpressionResolver, 如果不包含，则放弃解析
if (this.beanExpressionResolver == null) {
return value;
}
Scope scope = null;
if (beanDefinition != null) {
String scopeName = beanDefinition.getScope();
if (scopeName != null) {
scope = getRegisteredScope(scopeName);
}
}
// 执行SpEL表达式解析
return this.beanExpressionResolver.evaluate(value, new BeanExpressionContext(this, scope));
}
真正执行解析实现的，则是通过BeanExpressionResolver来实现的，通过查看代码，在Spring中只有一个该接口的实现，则是StandardBeanExpressionResolver类型，因此我们只需要关注该类即可。
StandardBeanExpressionResolver
evalute()
public Object evaluate(@Nullable String value, BeanExpressionContext evalContext) throws BeansException {
// 判断解析的值，是否为空，为空则直接返回
if (!StringUtils.hasLength(value)) {
return value;
}
try {
// 从缓存中获取，判断当前值是否已经缓存，如果缓存，则跳过解析步骤
Expression expr = this.expressionCache.get(value);
if (expr == null) {
// 通过表达式解析器将值解析为表达式
expr = this.expressionParser.parseExpression(value, this.beanExpressionParserContext);
// 缓存表达式结果值
this.expressionCache.put(value, expr);
}
// 根据绑定上下文获取标准计算上下文
// 这个地方的缓存是生效的，虽然BeanExpressionContext每次通过new的方式创建
// 但是该类的hashCode()都是获取的BeanFactory的hashCode()值，因此在同一个容器中，该hashCode()的值是不会变化的
// 通过equals方法也是判断scope与beanFactory是否相等，因此这里的缓存是针对整个容器实现的。
StandardEvaluationContext sec = this.evaluationCache.get(evalContext);
if (sec == null) {
// 创建标准计算上下文
sec = new StandardEvaluationContext(evalContext);
sec.addPropertyAccessor(new BeanExpressionContextAccessor());
sec.addPropertyAccessor(new BeanFactoryAccessor());
sec.addPropertyAccessor(new MapAccessor());
sec.addPropertyAccessor(new EnvironmentAccessor());
sec.setBeanResolver(new BeanFactoryResolver(evalContext.getBeanFactory()));
sec.setTypeLocator(new StandardTypeLocator(evalContext.getBeanFactory().getBeanClassLoader()));
ConversionService conversionService = evalContext.getBeanFactory().getConversionService();
if (conversionService != null) {
sec.setTypeConverter(new StandardTypeConverter(conversionService));
}
customizeEvaluationContext(sec);
this.evaluationCache.put(evalContext, sec);
}
// 从expression中获取计算结果
return expr.getValue(sec);
}
catch (Throwable ex) {
throw new BeanExpressionException("Expression parsing failed", ex);
}
}
SpelExpressionParser
该类的作用，则是将value的值解析成为Expression表达式。为了更好的了解ExpressionParser的设计，下图为类结构:
parseExpression()
该方法是将value的值解析为Expression的入口，具体源码如下：
public Expression parseExpression(String expressionString, @Nullable ParserContext context) throws ParseException {
// 当context不为空并且isTemplate为true时，按照模板的方式解析
if (context != null && context.isTemplate()) {
return parseTemplate(expressionString, context);
}
else {
// 否则按照InternalSpelExpressionParser解析
return doParseExpression(expressionString, context);
}
}
parseTemplate
在上面的实现中，因为Context申明方法为匿名内部类的声明方式，具体代码如下：
private final ParserContext beanExpressionParserContext = new ParserContext() {
@Override
public boolean isTemplate() {
return true;
}
@Override
public String getExpressionPrefix() {
return expressionPrefix;
}
@Override
public String getExpressionSuffix() {
return expressionSuffix;
}
};
因此在这里isTemplate始终为true。因此我们查看parseTemplate方法源码如下：
private Expression parseTemplate(String expressionString, ParserContext context) throws ParseException {
// 当value为空时，使用LiteralExpression表达式
if (expressionString.isEmpty()) {
return new LiteralExpression("");
}
// 解析Expression
Expression[] expressions = parseExpressions(expressionString, context);
if (expressions.length == 1) {
return expressions[0];
}
else {
return new CompositeStringExpression(expressionString, expressions);
}
}
parseExpressions()
该方法会对value中的表达式进行解析，并返回多个Expression列表，具体源码如下：
/**
* Helper that parses given expression string using the configured parser. The
* expression string can contain any number of expressions all contained in "${...}"
* markers. For instance: "foo${expr0}bar${expr1}". The static pieces of text will
* also be returned as Expressions that just return that static piece of text. As a
* result, evaluating all returned expressions and concatenating the results produces
* the complete evaluated string. Unwrapping is only done of the outermost delimiters
* found, so the string 'hello ${foo${abc}}' would break into the pieces 'hello ' and
* 'foo${abc}'. This means that expression languages that used ${..} as part of their
* functionality are supported without any problem. The parsing is aware of the
* structure of an embedded expression. It assumes that parentheses '(', square
* brackets '[' and curly brackets '}' must be in pairs within the expression unless
* they are within a string literal and a string literal starts and terminates with a
* single quote '.
* @param expressionString the expression string
* @return the parsed expressions
* @throws ParseException when the expressions cannot be parsed
*/
private Expression[] parseExpressions(String expressionString, ParserContext context) throws ParseException {
// 解析完成表达式列表
List<Expression> expressions = new ArrayList<>();
// 表达式前缀, 默认为"#{"
String prefix = context.getExpressionPrefix();
// 表达式后缀, 默认为"}"
String suffix = context.getExpressionSuffix();
int startIdx = 0;
while (startIdx < expressionString.length()) {
// 从startIdx位置开始，判断value中是否包含了前缀"#{"
int prefixIndex = expressionString.indexOf(prefix, startIdx);
// 找到前缀"#{"
if (prefixIndex >= startIdx) {
// an inner expression was found - this is a composite
// 这里需要生成一个LiteralExpression，因为在找到"#{"之前的所有字符，其实都不需要解析
// 应该作为常量原样的输出
if (prefixIndex > startIdx) {
expressions.add(new LiteralExpression(expressionString.substring(startIdx, prefixIndex)));
}
int afterPrefixIndex = prefixIndex + prefix.length();
// 找到第一个匹配后缀"}"位置，并返回对应索引
int suffixIndex = skipToCorrectEndSuffix(suffix, expressionString, afterPrefixIndex);
// 当后缀位置定位失败时，则抛出异常
if (suffixIndex == -1) {
throw new ParseException(expressionString, prefixIndex,
"No ending suffix '" + suffix + "' for expression starting at character " +
prefixIndex + ": " + expressionString.substring(prefixIndex));
}
// 如果后缀位置与开始查找位置相同，则说明表达式中没有值
if (suffixIndex == afterPrefixIndex) {
throw new ParseException(expressionString, prefixIndex,
"No expression defined within delimiter '" + prefix + suffix +
"' at character " + prefixIndex);
}
// 获取开始"#{"与结束"}"中的表达式字符串
String expr = expressionString.substring(prefixIndex + prefix.length(), suffixIndex);
expr = expr.trim();
if (expr.isEmpty()) {
throw new ParseException(expressionString, prefixIndex,
"No expression defined within delimiter '" + prefix + suffix +
"' at character " + prefixIndex);
}
// 对表达式进行解析
expressions.add(doParseExpression(expr, context));
// 冲虚查找下一个表达式
startIdx = suffixIndex + suffix.length();
}
else {
// no more ${expressions} found in string, add rest as static text
// 没有更多的表达式信息, 则返回原样输出即可
expressions.add(new LiteralExpression(expressionString.substring(startIdx)));
startIdx = expressionString.length();
}
}
return expressions.toArray(new Expression[0]);
}
doParseExpression()
还记得最开始判断parseContext与isTemplate代码入口吗？如果不满足条件时，就直接调用这个方法。而通过查看源码我们可以得知，这个放在在父类中为抽象方法，需要子类来实现，定义如下：
@Override
protected SpelExpression doParseExpression(String expressionString, @Nullable ParserContext context) throws ParseException {
return new InternalSpelExpressionParser(this.configuration).doParseExpression(expressionString, context);
}
这里可以看出，当value中存在需要处理的表达式时，最终都是通过InternalSpelExpressionParser类进行处理，因此最终还是需要关注另外一个类.
InternalSpelExpressionParser
doParseExpression()
protected SpelExpression doParseExpression(String expressionString, @Nullable ParserContext context)
throws ParseException {
try {
// 表达式字符串
this.expressionString = expressionString;
// 生成tokenizer
Tokenizer tokenizer = new Tokenizer(expressionString);
// 处理表达式字符串信息, 会根据匹配规则生成Token列表,具体可以看下代码
this.tokenStream = tokenizer.process();
// token长度
this.tokenStreamLength = this.tokenStream.size();
this.tokenStreamPointer = 0;
this.constructedNodes.clear();
// 处理token信息
SpelNodeImpl ast = eatExpression();
Assert.state(ast != null, "No node");
Token t = peekToken();
if (t != null) {
throw new SpelParseException(t.startPos, SpelMessage.MORE_INPUT, toString(nextToken()));
}
Assert.isTrue(this.constructedNodes.isEmpty(), "At least one node expected");
// 返回SpelExpression对象
return new SpelExpression(expressionString, ast, this.configuration);
}
catch (InternalParseException ex) {
throw ex.getCause();
}
}
eatExpression()
在该方法中能够明确的感知到对于expression分了不同的层次进行处理，这里我的理解是， 在SpEL表达式中，本身运算要遵循计算优先级，因此在处理上有很多差异。
// expression
// : logicalOrExpression
// ( (ASSIGN^ logicalOrExpression)
// | (DEFAULT^ logicalOrExpression)
// | (QMARK^ expression COLON! expression)
// | (ELVIS^ expression))?;
@Nullable
private SpelNodeImpl eatExpression() {
SpelNodeImpl expr = eatLogicalOrExpression();
// 当还包含了后续节点时，则继续判断
Token t = peekToken();
if (t != null) {
if (t.kind == TokenKind.ASSIGN) { // a=b
if (expr == null) {
expr = new NullLiteral(toPos(t.startPos - 1, t.endPos - 1));
}
nextToken();
SpelNodeImpl assignedValue = eatLogicalOrExpression();
return new Assign(toPos(t), expr, assignedValue);
}
if (t.kind == TokenKind.ELVIS) { // a?:b (a if it isn't null, otherwise b)
if (expr == null) {
expr = new NullLiteral(toPos(t.startPos - 1, t.endPos - 2));
}
nextToken(); // elvis has left the building
SpelNodeImpl valueIfNull = eatExpression();
if (valueIfNull == null) {
valueIfNull = new NullLiteral(toPos(t.startPos + 1, t.endPos + 1));
}
return new Elvis(toPos(t), expr, valueIfNull);
}
if (t.kind == TokenKind.QMARK) { // a?b:c
if (expr == null) {
expr = new NullLiteral(toPos(t.startPos - 1, t.endPos - 1));
}
nextToken();
SpelNodeImpl ifTrueExprValue = eatExpression();
eatToken(TokenKind.COLON);
SpelNodeImpl ifFalseExprValue = eatExpression();
return new Ternary(toPos(t), expr, ifTrueExprValue, ifFalseExprValue);
}
}
return expr;
}
eatLogicalOrExpression()
private SpelNodeImpl eatLogicalOrExpression() {
SpelNodeImpl expr = eatLogicalAndExpression();
// 该处用于逻辑运算，包含了 or 与 ||
while (peekIdentifierToken("or") || peekToken(TokenKind.SYMBOLIC_OR)) {
Token t = takeToken(); //consume OR
SpelNodeImpl rhExpr = eatLogicalAndExpression();
checkOperands(t, expr, rhExpr);
expr = new OpOr(toPos(t), expr, rhExpr);
}
return expr;
}
eatLogicalAndExpression()
private SpelNodeImpl eatLogicalAndExpression() {
SpelNodeImpl expr = eatRelationalExpression();
// 该处用于解析逻辑运算，包含了 and 与 &&
while (peekIdentifierToken("and") || peekToken(TokenKind.SYMBOLIC_AND)) {
Token t = takeToken(); // consume 'AND'
SpelNodeImpl rhExpr = eatRelationalExpression();
checkOperands(t, expr, rhExpr);
expr = new OpAnd(toPos(t), expr, rhExpr);
}
return expr;
}
eatRelationalExpression()
private SpelNodeImpl eatRelationalExpression() {
SpelNodeImpl expr = eatSumExpression();
// 判断关系运算，主要包含以下几种关系:
// relationalOperator
// : EQUAL | NOT_EQUAL | LESS_THAN | LESS_THAN_OR_EQUAL | GREATER_THAN
// | GREATER_THAN_OR_EQUAL | INSTANCEOF | BETWEEN | MATCHES
Token relationalOperatorToken = maybeEatRelationalOperator();
if (relationalOperatorToken != null) {
Token t = takeToken(); // consume relational operator token
SpelNodeImpl rhExpr = eatSumExpression();
checkOperands(t, expr, rhExpr);
TokenKind tk = relationalOperatorToken.kind;
if (relationalOperatorToken.isNumericRelationalOperator()) {
int pos = toPos(t);
if (tk == TokenKind.GT) {
return new OpGT(pos, expr, rhExpr);
}
if (tk == TokenKind.LT) {
return new OpLT(pos, expr, rhExpr);
}
if (tk == TokenKind.LE) {
return new OpLE(pos, expr, rhExpr);
}
if (tk == TokenKind.GE) {
return new OpGE(pos, expr, rhExpr);
}
if (tk == TokenKind.EQ) {
return new OpEQ(pos, expr, rhExpr);
}
Assert.isTrue(tk == TokenKind.NE, "Not-equals token expected");
return new OpNE(pos, expr, rhExpr);
}
if (tk == TokenKind.INSTANCEOF) {
return new OperatorInstanceof(toPos(t), expr, rhExpr);
}
if (tk == TokenKind.MATCHES) {
return new OperatorMatches(toPos(t), expr, rhExpr);
}
Assert.isTrue(tk == TokenKind.BETWEEN, "Between token expected");
return new OperatorBetween(toPos(t), expr, rhExpr);
}
return expr;
}
eatSumExpression()
private SpelNodeImpl eatSumExpression() {
SpelNodeImpl expr = eatProductExpression();
// 判断是否为 +、-、++运算
while (peekToken(TokenKind.PLUS, TokenKind.MINUS, TokenKind.INC)) {
Token t = takeToken(); //consume PLUS or MINUS or INC
SpelNodeImpl rhExpr = eatProductExpression();
checkRightOperand(t, rhExpr);
if (t.kind == TokenKind.PLUS) {
expr = new OpPlus(toPos(t), expr, rhExpr);
}
else if (t.kind == TokenKind.MINUS) {
expr = new OpMinus(toPos(t), expr, rhExpr);
}
}
return expr;
}
eatProductExpression()
private SpelNodeImpl eatProductExpression() {
SpelNodeImpl expr = eatPowerIncDecExpression();
//判断是否为*、/、%运算, 并返回对应的Node节点信息
while (peekToken(TokenKind.STAR, TokenKind.DIV, TokenKind.MOD)) {
Token t = takeToken(); // consume STAR/DIV/MOD
SpelNodeImpl rhExpr = eatPowerIncDecExpression();
checkOperands(t, expr, rhExpr);
if (t.kind == TokenKind.STAR) {
expr = new OpMultiply(toPos(t), expr, rhExpr);
}
else if (t.kind == TokenKind.DIV) {
expr = new OpDivide(toPos(t), expr, rhExpr);
}
else {
Assert.isTrue(t.kind == TokenKind.MOD, "Mod token expected");
expr = new OpModulus(toPos(t), expr, rhExpr);
}
}
return expr;
}
eatPowerIncDecExpression()
private SpelNodeImpl eatPowerIncDecExpression() {
// 调用一元操作
SpelNodeImpl expr = eatUnaryExpression();
// 判断是否为平方计算，是则返回OperatorPower操作
if (peekToken(TokenKind.POWER)) {
Token t = takeToken(); //consume POWER
SpelNodeImpl rhExpr = eatUnaryExpression();
checkRightOperand(t, rhExpr);
return new OperatorPower(toPos(t), expr, rhExpr);
}
// 判断是否为++或者--运算
if (expr != null && peekToken(TokenKind.INC, TokenKind.DEC)) {
Token t = takeToken(); //consume INC/DEC
if (t.getKind() == TokenKind.INC) {
return new OpInc(toPos(t), true, expr);
}
return new OpDec(toPos(t), true, expr);
}
return expr;
}
eatUnaryExpression()
unaryExpression: (PLUS^ | MINUS^ | BANG^ | INC^ | DEC^) unaryExpression | primaryExpression ; 该方法主要计算一元表达式
private SpelNodeImpl eatUnaryExpression() {
// 判断单签token是否为PLUS, MINUX, NOT类型
if (peekToken(TokenKind.PLUS, TokenKind.MINUS, TokenKind.NOT)) {
// 获取token
Token t = takeToken();
// 继续获取一元表达式
SpelNodeImpl expr = eatUnaryExpression();
Assert.state(expr != null, "No node");
// 判断token的类型是否为: NOT(!)
if (t.kind == TokenKind.NOT) {
return new OperatorNot(toPos(t), expr);
}
// 判断Token的类型是否为：PLUS, 如果是，则返回OpPlus
if (t.kind == TokenKind.PLUS) {
return new OpPlus(toPos(t), expr);
}
// 否则返回OpMinus
Assert.isTrue(t.kind == TokenKind.MINUS, "Minus token expected");
return new OpMinus(toPos(t), expr);
}
// 判断token的类型是否为INC(++)或者DEC(--)
if (peekToken(TokenKind.INC, TokenKind.DEC)) {
// 获取当前token
Token t = takeToken();
// 获取一元节点
SpelNodeImpl expr = eatUnaryExpression();
// 如果token的类型为:INC, 则返回OpInc
if (t.getKind() == TokenKind.INC) {
return new OpInc(toPos(t), false, expr);
}
// 否则返回OpDec
return new OpDec(toPos(t), false, expr);
}
return eatPrimaryExpression();
}
eatPrimaryExpression()
private SpelNodeImpl eatPrimaryExpression() {
// 该处主要获取常量Node信息
SpelNodeImpl start = eatStartNode(); // always a start node
List<SpelNodeImpl> nodes = null;
// 当常量获取完成后，则需要判断后续是否有操作符，主要包括DOT(.)和SAVE_NAVI(?.)两类
SpelNodeImpl node = eatNode();
// 该处主要是为了将常量Node与操作符Node进行组装
while (node != null) {
if (nodes == null) {
nodes = new ArrayList<>(4);
nodes.add(start);
}
nodes.add(node);
node = eatNode();
}
if (start == null || nodes == null) {
return start;
}
// 生成CompoundExpression并返回
return new CompoundExpression(toPos(start.getStartPosition(),
nodes.get(nodes.size() - 1).getEndPosition()),
nodes.toArray(new SpelNodeImpl[0]));
}
eatStartNode()
该方法用于解析startNode信息，主要包含以下信息:
//startNode // : parenExpr | literal // | type // | methodOrProperty // | functionOrVar // | projection // | selection // | firstSelection // | lastSelection // | indexer // | constructor
private SpelNodeImpl eatStartNode() {
if (maybeEatLiteral()) {
return pop();
}
else if (maybeEatParenExpression()) {
return pop();
}
else if (maybeEatTypeReference() || maybeEatNullReference() || maybeEatConstructorReference() ||
maybeEatMethodOrProperty(false) || maybeEatFunctionOrVar()) {
return pop();
}
else if (maybeEatBeanReference()) {
return pop();
}
else if (maybeEatProjection(false) || maybeEatSelection(false) || maybeEatIndexer()) {
return pop();
}
else if (maybeEatInlineListOrMap()) {
return pop();
}
else {
return null;
}
}
maybeEatLiteral()
// literal
// : INTEGER_LITERAL
// | boolLiteral
// | STRING_LITERAL
// | HEXADECIMAL_INTEGER_LITERAL
// | REAL_LITERAL
// | DQ_STRING_LITERAL
// | NULL_LITERAL
private boolean maybeEatLiteral() {
// 获取当前token, 但是游标不会向后移动
Token t = peekToken();
if (t == null) {
return false;
}
// 类型为int时，将token中的值转化为int, 并放入队列中
if (t.kind == TokenKind.LITERAL_INT) {
push(Literal.getIntLiteral(t.stringValue(), toPos(t), 10));
}
// 类型为long时，将token中的值转化为long, 并放入队列中
else if (t.kind == TokenKind.LITERAL_LONG) {
push(Literal.getLongLiteral(t.stringValue(), toPos(t), 10));
}
// 类型为16进制整型时，将值转换为16进制，并放入队列中
else if (t.kind == TokenKind.LITERAL_HEXINT) {
push(Literal.getIntLiteral(t.stringValue(), toPos(t), 16));
}
// 类型为16进制整型时，将值转换为16进制，并放入队列中
else if (t.kind == TokenKind.LITERAL_HEXLONG) {
push(Literal.getLongLiteral(t.stringValue(), toPos(t), 16));
}
// 当类型为bool类型时，将token的值转换为bool值并放入队列
else if (t.kind == TokenKind.LITERAL_REAL) {
push(Literal.getRealLiteral(t.stringValue(), toPos(t), false));
}
// 当类型为bool类型时，将token的值转换为bool值并放入队列
else if (t.kind == TokenKind.LITERAL_REAL_FLOAT) {
push(Literal.getRealLiteral(t.stringValue(), toPos(t), true));
}
// 当类型为字符串true时，将token的值转换为bool值并放入队列
else if (peekIdentifierToken("true")) {
push(new BooleanLiteral(t.stringValue(), toPos(t), true));
}
// 当类型为字符串false时，将token的值转换为bool值并放入队列
else if (peekIdentifierToken("false")) {
push(new BooleanLiteral(t.stringValue(), toPos(t), false));
}
// 当类型为字符串类型时，将token的值转换字符串
else if (t.kind == TokenKind.LITERAL_STRING) {
push(new StringLiteral(t.stringValue(), toPos(t), t.stringValue()));
}
else {
return false;
}
// 向后移动游标
nextToken();
return true;
}
SpelExpression
public Object getValue(EvaluationContext context) throws EvaluationException {
Assert.notNull(context, "EvaluationContext is required");
// 判断当前是否已经包含了编译后的表达式
CompiledExpression compiledAst = this.compiledAst;
if (compiledAst != null) {
try {
// 当前表达式已经编译完成，则可以直接获取值
return compiledAst.getValue(context.getRootObject().getValue(), context);
}
catch (Throwable ex) {
// If running in mixed mode, revert to interpreted
if (this.configuration.getCompilerMode() == SpelCompilerMode.MIXED) {
this.compiledAst = null;
this.interpretedCount.set(0);
}
else {
// Running in SpelCompilerMode.immediate mode - propagate exception to caller
throw new SpelEvaluationException(ex, SpelMessage.EXCEPTION_RUNNING_COMPILED_EXPRESSION);
}
}
}
// 当前表达式没有被编译过，则创建ExpressionState对象
ExpressionState expressionState = new ExpressionState(context, this.configuration);
// 该处有一个ExpressionState, 该类主要是一个状态存储的类，并且该类会存储中间结果，同时
// 运算的执行也是通过栈的方式存储，因此这里跟我们平时的使用方式差异不大
Object result = this.ast.getValue(expressionState);
checkCompile(expressionState);
return result;
}
由上面Expression的表达式解析过程可以得知，其实最终获取到是SpelNodeImpl类型的具体实现类，因此大家感兴趣可以再去多研究一下。
其实在Spring中，使用SpEL表达式实现一个运算结果的实现是很复杂的，以上只是我学习的一个思路，如果有帮助到你，请你为文章评论，点赞，感谢！
文章评论