【小家Spring】SpEL你感兴趣的实现原理浅析spring-expression~(SpelExpressionParser、EvaluationContext、rootObject)(上)

    public static void main(String[] args) {
        String expressionStr = "1 + 2";
        ExpressionParser parpser = new SpelExpressionParser(); //SpelExpressionParser是Spring内部对ExpressionParser的唯一最终实现类
        Expression exp = parpser.parseExpression(expressionStr); //把该表达式，解析成一个Expression对象：SpelExpression
        // 方式一：直接计算
        Object value = exp.getValue();
        System.out.println(value.toString()); //3
        // 若你在@Value中或者xml使用此表达式，请使用#{}包裹~~~~~~~~~~~~~~~~~
        System.out.println(parpser.parseExpression("T(System).getProperty('user.dir')").getValue()); //E:\work\remotegitcheckoutproject\myprojects\java\demo-war
        System.out.println(parpser.parseExpression("T(java.lang.Math).random() * 100.0").getValue()); //27.38227555400853
        // 方式二：定义环境变量，在环境内计算拿值
        // 环境变量可设置多个值：比如BeanFactoryResolver、PropertyAccessor、TypeLocator等~~~
        // 有环境变量，就有能力处理里面的占位符 ${}
        EvaluationContext context = new StandardEvaluationContext();
        System.out.println(exp.getValue(context)); //3
    }

// @since 3.0
public interface ExpressionParser {
  // 他俩都是把字符串解析成一个Expression对象~~~~  备注expressionString都是可以被repeated evaluation的
  Expression parseExpression(String expressionString) throws ParseException;
  Expression parseExpression(String expressionString, ParserContext context) throws ParseException;
}

public interface ParserContext {
  // 是否是模版表达式。  比如：#{3 + 4}
  boolean isTemplate();
  // 模版的前缀、后缀  子类是可以定制化的~~~
  String getExpressionPrefix();
  String getExpressionSuffix();
  // 默认提供的实例支持：#{} 的形式   显然我们可以改变它但我们一般并不需要这么去做~
  ParserContext TEMPLATE_EXPRESSION = new ParserContext() {
    @Override
    public boolean isTemplate() {
      return true;
    }
    @Override
    public String getExpressionPrefix() {
      return "#{";
    }
    @Override
    public String getExpressionSuffix() {
      return "}";
    }
  };
}

public class TemplateParserContext implements ParserContext {
  private final String expressionPrefix;
  private final String expressionSuffix;
  // 默认就是它了~~~
  public TemplateParserContext() {
    this("#{", "}");
  }
  @Override
  public final boolean isTemplate() {
    return true;
  }
  @Override
  public final String getExpressionPrefix() {
    return this.expressionPrefix;
  }
  @Override
  public final String getExpressionSuffix() {
    return this.expressionSuffix;
  }
}

// @since 3.0  它是一个抽象类
public abstract class TemplateAwareExpressionParser implements ExpressionParser {
  @Override
  public Expression parseExpression(String expressionString) throws ParseException {
    return parseExpression(expressionString, null);
  }
  @Override
  public Expression parseExpression(String expressionString, @Nullable ParserContext context) throws ParseException {
    // 若指定了上下文，并且是模版 就走parseTemplate
    if (context != null && context.isTemplate()) {
      return parseTemplate(expressionString, context);
    } else {
      // 抽象方法 子类去实现~~~
      return doParseExpression(expressionString, context);
    }
  }
  private Expression parseTemplate(String expressionString, ParserContext context) throws ParseException {
    // 若解析字符串是空串~~~~~
    if (expressionString.isEmpty()) {
      return new LiteralExpression("");
    }
    // 若只有一个模版表达式，直接返回。否则会返回一个CompositeStringExpression，聚合起来的表达式~
    Expression[] expressions = parseExpressions(expressionString, context);
    if (expressions.length == 1) {
      return expressions[0];
    } else {
      return new CompositeStringExpression(expressionString, expressions);
    }
  }
  // ... parseExpressions的实现逻辑  还是稍显复杂的~ 因为支持的case太多了~~~
}

public class SpelExpressionParser extends TemplateAwareExpressionParser {
  private final SpelParserConfiguration configuration;
  public SpelExpressionParser() {
    this.configuration = new SpelParserConfiguration();
  }
  public SpelExpressionParser(SpelParserConfiguration configuration) {
    Assert.notNull(configuration, "SpelParserConfiguration must not be null");
    this.configuration = configuration;
  }
  // 最终都是委托给了Spring的内部使用的类：InternalSpelExpressionParser--> 内部的SpEL表达式解析器~~~
  public SpelExpression parseRaw(String expressionString) throws ParseException {
    return doParseExpression(expressionString, null);
  }
  // 这里需要注意：因为是new的，所以每次都是一个新对象，所以它是线程安全的~
  @Override
  protected SpelExpression doParseExpression(String expressionString, @Nullable ParserContext context) throws ParseException {
    return new InternalSpelExpressionParser(this.configuration).doParseExpression(expressionString, context);
  }
}

// 它是个public类，因为`StandardBeanExpressionResolver`也使用到了它~~~
public class SpelParserConfiguration {
  // OFF IMMEDIATE（expressions are compiled as soon as possible） MIXED
  private static final SpelCompilerMode defaultCompilerMode; 
  static {
    // 它的值可由`spring.properties`里面的配置改变~~~~  所以你可以在你的类路径下放置一个文件，通过`spring.expression.compiler.mode=IMMEDIATE`来控制编译行为
    String compilerMode = SpringProperties.getProperty("spring.expression.compiler.mode");
    defaultCompilerMode = (compilerMode != null ?
        SpelCompilerMode.valueOf(compilerMode.toUpperCase()) : SpelCompilerMode.OFF);
  }
  // 调用者若没指定，会使用上面的默认的~
  private final SpelCompilerMode compilerMode;
  @Nullable
  private final ClassLoader compilerClassLoader;
  // 碰到为null的，是否给自动new一个对象，比如new String()，new ArrayList()等等~
  private final boolean autoGrowNullReferences;
  // 专门针对于集合是否new
  private final boolean autoGrowCollections;
  // 集合能够自动增长到的最大值~~~~
  private final int maximumAutoGrowSize;
  // 省略get/set方法~~~后面会给一个自定义配置的示例~~~
}

// 它是Spring内部使用的类~
class InternalSpelExpressionParser extends TemplateAwareExpressionParser {
  private static final Pattern VALID_QUALIFIED_ID_PATTERN = Pattern.compile("[\\p{L}\\p{N}_$]+");
  private final SpelParserConfiguration configuration; //SpEL的配置
  // 此处用一个双端队列  来保存表达式的每一个节点，每个节点都是一个SpelNode 该对象记录着位置、子节点、父节点等等~~~
  private final Deque<SpelNodeImpl> constructedNodes = new ArrayDeque<>();
  private String expressionString = ""; // 带解析的表达式字符串~
  // Token流：token保存着符号类型（如int(,]+=?>=等等各种符号 非常之多）  然后记录着它startPos和endPos
  private List<Token> tokenStream = Collections.emptyList();
  // length of a populated token stream
  private int tokenStreamLength;
  // Current location in the token stream when processing tokens
  private int tokenStreamPointer;
  // 唯一的一个构造函数~
  public InternalSpelExpressionParser(SpelParserConfiguration configuration) {
    this.configuration = configuration;
  }
  @Override
  protected SpelExpression doParseExpression(String expressionString, @Nullable ParserContext context) throws ParseException {
    try {
      this.expressionString = expressionString;
      // Tokenizer就是分词器。把待解析的表达式交给它分词~~~
      Tokenizer tokenizer = new Tokenizer(expressionString);
      // process处理，得到tokenStream  并且记录上它的总长度  并且标记当前处理点为0
      this.tokenStream = tokenizer.process();
      this.tokenStreamLength = this.tokenStream.size();
      this.tokenStreamPointer = 0;
      this.constructedNodes.clear(); // 显然把当前节点清空~~
      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");
      // 最终：每一个SpelNodeImpl  它就是一个SpelExpression表达式，但会出去。\
      // 此时：只是把我们的字符串解析成为一个SpelExpression，还没有参与赋值、计算哦~~~~
      return new SpelExpression(expressionString, ast, this.configuration);
    } catch (InternalParseException ex) {
      throw ex.getCause();
    }
  }
  ... // 解析表达式的逻辑非常的复杂，Spring团队老牛逼了，竟然支持到了这么多的功能~~~~
}

    public static void main(String[] args) {
        String greetingExp = "Hello, #{#user} ---> #{T(System).getProperty('user.home')}";
        ExpressionParser parser = new SpelExpressionParser();
        EvaluationContext context = new StandardEvaluationContext();
        context.setVariable("user", "fsx");
        Expression expression = parser.parseExpression(greetingExp, new TemplateParserContext());
        System.out.println(expression.getValue(context, String.class)); //Hello, fsx ---> C:\Users\fangshixiang
    }