首页 > 编程笔记 > Java笔记

解释器模式在JDK和Spring源码中的应用

本节我们介绍解释器模式在 JDK 和 Spring 源码中的应用。

解释器模式在JDK源码中的应用

正则表达式是解释器模式一个很好的体现，因为正则表达式本身就是一个语法的封装。

下面先看 JDK 源码中 Pattern 类对正则表达式的编译和解析，源码如下。 
  1. package java.util.regex;
  2.  
  3. public final class Pattern
  4.     implements java.io.Serializable
  5. {
  6. ...
  7. private Pattern(String p, int f) {
  8.         pattern = p;
  9.         flags = f;
  10.  
  11.         // to use UNICODE_CASE if UNICODE_CHARACTER_CLASS present
  12.         if ((flags & UNICODE_CHARACTER_CLASS) != 0)
  13.             flags |= UNICODE_CASE;
  14.  
  15.         // Reset group index count
  16.         capturingGroupCount = 1;
  17.         localCount = 0;
  18.  
  19.         if (pattern.length() > 0) {
  20.             try {
  21.                 compile();
  22.             } catch (StackOverflowError soe) {
  23.                 throw error("Stack overflow during pattern compilation");
  24.             }
  25.         } else {
  26.             root = new Start(lastAccept);
  27.             matchRoot = lastAccept;
  28.         }
  29.     }
  30.     ...
  31.     public static Pattern compile(String regex) {
  32.         return new Pattern(regex, 0);
  33.     }
  34.     public static Pattern compile(String regex, int flags) {
  35.         return new Pattern(regex, flags);
  36.     }
  37.     ...
  38. }

解释器模式在Spring源码中的应用

在 Spring 中，ExpressionParser 接口内部采用的也是解释器模式，它封装了字符串表达式的语法，源码如下。
  1. package org.springframework.expression;
  2.  
  3. public interface ExpressionParser {
  4.  
  5.     Expression parseExpression(String expressionString) throws ParseException;
  6.  
  7.     Expression parseExpression(String expressionString, ParserContext context) throws ParseException;
  8. }
ExpressionParser 不知道大家有没有用过，这里面也可以进行加减乘除运算。这里我们不深入讲解源码，通过《解释器模式》一节编写的案例大致就能够清楚其原理。如下是一个简单的应用示例：
  1. package net.biancheng.c.interpreter;
  2.  
  3. import org.springframework.expression.Expression;
  4. import org.springframework.expression.ExpressionParser;
  5. import org.springframework.expression.spel.standard.SpelExpressionParser;
  6.  
  7. public class Test {
  8.     public static void main(String[] args) {
  9.         ExpressionParser parser = new SpelExpressionParser();
  10.         Expression expression = parser.parseExpression("100*2+400*1+66");
  11.         int result = (Integer) expression.getValue();
  12.         System.out.println("计算结果是：" + result);
  13.     }
  14. }
运行结果如下。

计算结果是：666

由运行结果可以看到，运行结果与预期结果是一致的。

解释器模式一般在业务开发中用的相对较少，常用的表达式都有人解析好了，直接用就可以了，除非我们从事底层开发需要自己去定义较为复杂的表达式。

所有教程

优秀文章