Java設計模式之java解釋器模式詳解
更新時間：2021年09月15日 10:19:27 作者：大忽悠愛忽悠
這篇文章主要介紹了Java設計模式之解釋器模式定義與用法,結合具體實例形式詳細分析了Java解釋器模式的概念、原理、定義及相關操作技巧,需要的朋友可以參考下
介紹
解釋器模式(Interpreter Pattern)：定義一個語言的文法，并且建立一個解釋器來解釋該語言中的句子，這里的 “語言” 是指使用規(guī)定格式和語法的代碼。解釋器模式是一種類行為型模式。
角色
AbstractExpression（抽象解釋器）：在抽象表達式中聲明了抽象的解釋操作,具體的解釋任務由各個實現(xiàn)類完成,它是所有終結符表達式和非終結符表達式的公共父類。
TerminalExpression（終結符表達式）：實現(xiàn)與文法中的元素相關聯(lián)的解釋操作，通常一個解釋器模式中只有一個終結表達式，但有多個實例，對應不同的終結符。
NonterminalExpression（非終結符表達式）：文法中的每條規(guī)則對應于一個非終結表達式，非終結符表達式根據(jù)邏輯的復雜程度而增加，原則上每個文法規(guī)則都對應一個非終結符表達式
Context（環(huán)境類）：環(huán)境類又稱為上下文類，它用于存儲解釋器之外的一些全局信息，通常它臨時存儲了需要解釋的語句。
客戶類（Test）: 客戶端,解析表達式,構建抽象語法樹,執(zhí)行具體的解釋操作等.
計算器案例
環(huán)境類，存儲解釋器之外的一些全局信息，通常它臨時存儲了需要解釋的語句
public class Context
{
private Map<Expression, Integer> map = new HashMap<>();
//定義變量
public void add(Expression s, Integer value)
{
map.put(s, value);
}
//將變量轉換成數(shù)字
public int lookup(Expression s){
return map.get(s);
}
}
解釋器接口
public interface Expression
{
int interpreter(Context context);//一定會有解釋方法
}
抽象非終結符表達式
public abstract class NonTerminalExpression implements Expression{
Expression e1,e2;
public NonTerminalExpression(Expression e1, Expression e2){
this.e1 = e1;
this.e2 = e2;
}
}
減法表達式實現(xiàn)類
public class MinusOperation extends NonTerminalExpression {
public MinusOperation(Expression e1, Expression e2) {
super(e1, e2);
}
//將兩個表達式相減
@Override
public int interpreter(Context context) {
return this.e1.interpreter(context) - this.e2.interpreter(context);
}
}
加法表達式實現(xiàn)類
public class PlusOperation extends NonTerminalExpression {
public PlusOperation(Expression e1, Expression e2) {
super(e1, e2);
}
//將兩個表達式相加
@Override
public int interpreter(Context context) {
return this.e1.interpreter(context) + this.e2.interpreter(context);
}
}
終結符表達式（在這個例子，用來存放數(shù)字，或者代表數(shù)字的字符）
public class TerminalExpression implements Expression{
String variable;
public TerminalExpression(String variable){
this.variable = variable;
}
//獲得該變量的值
@Override
public int interpreter(Context context) {
return context.lookup(this);
}
}
測試:
public class Test {
public static void main(String[] args) {
Context context = new Context();
TerminalExpression a = new TerminalExpression("a");
TerminalExpression b = new TerminalExpression("b");
TerminalExpression c = new TerminalExpression("c");
context.add(a, 4);
context.add(b, 8);
context.add(c, 2);
//new PlusOperation(a,b).interpreter(context)--->返回12
// c.interpreter(context)--->2
//MinusOperation(12,2)..interpreter(context)--->10
System.out.println(new MinusOperation(new PlusOperation(a,b), c).interpreter(context));
}
}
UML圖
深入挖掘
非終結符表達式（相當于樹的樹杈）：在這個例子中就是相加，相減的表達式，稱為非終結符，這是非常形象的，因為當運算遇到這類的表達式的時候，必須先把非終結符的結果計算出來，猶如剝繭一般，一層一層的調用，就比如上面的
new MinusOperation(new PlusOperation(a,b), c).interpreter(context)
這個MinusOperation左邊參數(shù)是new PlusOperation(a,b)，是非終結符表達式，所以要調用PlusOperation，因為PlusOperation的左右兩邊都是TerminalExpression，是終結符表達式，所以計算然后返回，到最外面的MinusOperation函數(shù)，發(fā)現(xiàn)右邊c是終結符表達式，所以可以計算。
終結符表達式（相當于樹的葉子）：遇到這個表達式interpreter執(zhí)行能直接返回結果，不會向下繼續(xù)調用。
構建的語法樹
葉子節(jié)點即為終結符，樹杈即為非終結符，遇到非終結符要繼續(xù)往下解析，遇到終結符則返回。a+b-c(4+8-2)
上面的語法樹是手動建的（new MinusOperation(new PlusOperation(a,b), c).interpreter(context)），實際情況，客戶輸入的都是(4+8-2)這樣的式子，所以，接下來寫的就是解析的輸入式子然后自動構建語法樹，然后計算結果.
public class Context {
private Map<Expression, Integer> map = new HashMap<>();
public void add(Expression s, Integer value){
map.put(s, value);
}
public Integer lookup(Expression s){
return map.get(s);
}
//構建語法樹的主要方法
public static Expression build(String str) {
//主要利用棧來實現(xiàn)
Stack<Expression> objects = new Stack<>();
for (int i = 0; i < str.length(); i++){
char c = str.charAt(i);
//遇到運算符號+號時候
if (c == '+'){
//先出棧
Expression pop = objects.pop();
//將運算結果入棧
objects.push(new PlusOperation(pop, new TerminalExpression(String.valueOf(str.charAt(++i)))));
} else if (c == '-'){
//遇到減號類似加號
Expression pop = objects.pop();
objects.push(new MinusOperation(pop, new TerminalExpression(String.valueOf(str.charAt(++i)))));
} else {
//遇到非終結符直接入棧（基本就是第一個數(shù)字的情況）
objects.push(new TerminalExpression(String.valueOf(str.charAt(i))));
}
}
//把最后的棧頂元素返回
return objects.pop();
}
}
public class TerminalExpression implements Expression {
String variable;
public TerminalExpression(String variable){
this.variable = variable;
}
@Override
public int interpreter(Context context) {
//因為要兼容之前的版本
Integer lookup = context.lookup(this);
if (lookup == null)
//若在map中能找到對應的數(shù)則返回
return Integer.valueOf(variable);
//找不到則直接返回（認為輸入的就是數(shù)字）
return lookup;
}
}
public class Test {
public static void main(String[] args) {
Context context = new Context();
TerminalExpression a = new TerminalExpression("a");
TerminalExpression b = new TerminalExpression("b");
TerminalExpression c = new TerminalExpression("c");
String str = "4+8-2+9+9-8";
Expression build = Context.build(str);
System.out.println("4+8-2+9+9-8=" + build.interpreter(context));
context.add(a, 4);
context.add(b, 8);
context.add(c, 2);
System.out.println(new MinusOperation(new PlusOperation(a,b), c).interpreter(context));
}
}
解釋器模式總結
解釋器模式為自定義語言的設計和實現(xiàn)提供了一種解決方案，它用于定義一組文法規(guī)則并通過這組文法規(guī)則來解釋語言中的句子。雖然解釋器模式的使用頻率不是特別高，但是它在正則表達式、XML文檔解釋等領域還是得到了廣泛使用。
主要優(yōu)點
- 易于改變和擴展文法。由于在解釋器模式中使用類來表示語言的文法規(guī)則，因此可以通過繼承等機制來改變或擴展文法。
- 每一條文法規(guī)則都可以表示為一個類，因此可以方便地實現(xiàn)一個簡單的語言。
- 實現(xiàn)文法較為容易。在抽象語法樹中每一個表達式節(jié)點類的實現(xiàn)方式都是相似的，這些類的代碼編寫都不會特別復雜，還可以通過一些工具自動生成節(jié)點類代碼。
- 增加新的解釋表達式較為方便。如果用戶需要增加新的解釋表達式只需要對應增加一個新的終結符表達式或非終結符表達式類，原有表達式類代碼無須修改，符合"開閉原則"。
主要缺點
- 對于復雜文法難以維護。在解釋器模式中，每一條規(guī)則至少需要定義一個類，因此如果一個語言包含太多文法規(guī)則，類的個數(shù)將會急劇增加，導致系統(tǒng)難以管理和維護，此時可以考慮使用語法分析程序等方式來取代解釋器模式。
- 執(zhí)行效率較低。由于在解釋器模式中使用了大量的循環(huán)和遞歸調用，因此在解釋較為復雜的句子時其速度很慢，而且代碼的調試過程也比較麻煩。
適用場景
- 可以將一個需要解釋執(zhí)行的語言中的句子表示為一個抽象語法樹。
- 一些重復出現(xiàn)的問題可以用一種簡單的語言來進行表達。
- 一個語言的文法較為簡單。
- 對執(zhí)行效率要求不高。
解釋器模式的典型應用
Spring EL表達式中的解釋器模式
在下面的類圖中，Expression是一個接口，相當于我們解釋器模式中的非終結符表達式，而ExpressionParser相當于終結符表達式。根據(jù)不同的Parser對象，返回不同的Expression對象
Expression接口：
//抽象的非終結符表達式
public interface Expression {
Object getValue() throws EvaluationException;
Object getValue(Object rootObject) throws EvaluationException;
}
SpelExpression類：
//具體的非終結符表達式
public class SpelExpression implements Expression {
@Override
public Object getValue() throws EvaluationException {
Object result;
if (this.compiledAst != null) {
try {
TypedValue contextRoot = evaluationContext == null ? null : evaluationContext.getRootObject();
return this.compiledAst.getValue(contextRoot == null ? null : contextRoot.getValue(), evaluationContext);
}
catch (Throwable ex) {
// If running in mixed mode, revert to interpreted
if (this.configuration.getCompilerMode() == SpelCompilerMode.MIXED) {
this.interpretedCount = 0;
this.compiledAst = null;
}
else {
// Running in SpelCompilerMode.immediate mode - propagate exception to caller
throw new SpelEvaluationException(ex, SpelMessage.EXCEPTION_RUNNING_COMPILED_EXPRESSION);
}
}
}
ExpressionState expressionState = new ExpressionState(getEvaluationContext(), this.configuration);
result = this.ast.getValue(expressionState);
checkCompile(expressionState);
return result;
}
}
CompositeStringExpression:
//具體的非終結符表達式
public class CompositeStringExpression implements Expression {
@Override
public String getValue() throws EvaluationException {
StringBuilder sb = new StringBuilder();
for (Expression expression : this.expressions) {
String value = expression.getValue(String.class);
if (value != null) {
sb.append(value);
}
}
return sb.toString();
}
}
ExpressionParser接口:
public interface ExpressionParser {
//解析表達式
Expression parseExpression(String expressionString) throws ParseException;
Expression parseExpression(String expressionString, ParserContext context) throws ParseException;
}
TemplateAwareExpressionParser類：
public abstract class TemplateAwareExpressionParser implements ExpressionParser {
@Override
public Expression parseExpression(String expressionString) throws ParseException {
return parseExpression(expressionString, NON_TEMPLATE_PARSER_CONTEXT);
}
//根據(jù)不同的parser返回不同的Expression對象
@Override
public Expression parseExpression(String expressionString, ParserContext context)
throws ParseException {
if (context == null) {
context = NON_TEMPLATE_PARSER_CONTEXT;
}
if (context.isTemplate()) {
return parseTemplate(expressionString, context);
}
else {
return doParseExpression(expressionString, context);
}
}
private Expression parseTemplate(String expressionString, ParserContext context)
throws ParseException {
if (expressionString.length() == 0) {
return new LiteralExpression("");
}
Expression[] expressions = parseExpressions(expressionString, context);
if (expressions.length == 1) {
return expressions[0];
}
else {
return new CompositeStringExpression(expressionString, expressions);
}
}
//抽象的，由子類去實現(xiàn)
protected abstract Expression doParseExpression(String expressionString,
ParserContext context) throws ParseException;
}
SpelExpressionParser類：
public class SpelExpressionParser extends TemplateAwareExpressionParser {
@Override
protected SpelExpression doParseExpression(String expressionString, ParserContext context) throws ParseException {
//這里返回了一個InternalSpelExpressionParser，
return new InternalSpelExpressionParser(this.configuration).doParseExpression(expressionString, context);
}
}
InternalSpelExpressionParser類：
class InternalSpelExpressionParser extends TemplateAwareExpressionParser {
@Override
protected SpelExpression doParseExpression(String expressionString, ParserContext context) throws ParseException {
try {
this.expressionString = expressionString;
Tokenizer tokenizer = new Tokenizer(expressionString);
tokenizer.process();
this.tokenStream = tokenizer.getTokens();
this.tokenStreamLength = this.tokenStream.size();
this.tokenStreamPointer = 0;
this.constructedNodes.clear();
SpelNodeImpl ast = eatExpression();
if (moreTokens()) {
throw new SpelParseException(peekToken().startPos, SpelMessage.MORE_INPUT, toString(nextToken()));
}
Assert.isTrue(this.constructedNodes.isEmpty());
return new SpelExpression(expressionString, ast, this.configuration);
}
catch (InternalParseException ex) {
throw ex.getCause();
}
}
}
參考文章
總結
本篇文章就到這里了，希望能夠給你帶來幫助，也希望您能夠多多關注腳本之家的更多內(nèi)容！
相關文章
這篇文章主要介紹了詳解spring 配置的兩種方式：JAVA配置和注解配置,具有一定的參考價值，感興趣的小伙伴們可以參考一下2017-06-06
Actor模型是一種常見的并發(fā)模型，與最常見的并發(fā)模型—共享內(nèi)存（同步鎖）不同，它將程序分為許多獨立的計算單元—Actor，文中有詳細的代碼示例，感興趣的同學可以參考閱讀2023-05-05
這篇文章主要介紹了Java通過Callable實現(xiàn)多線程,Callable的任務執(zhí)行后可返回值,運行Callable任務可以拿到一個Future對象,Future表示異步計算的結果,它提供了檢查計算是否完成的方法,以等待計算的完成,并檢查計算的結果,需要的朋友可以參考下2023-10-10
Java lambda表達式實現(xiàn)Flink WordCount過程解析
這篇文章主要介紹了Java lambda表達式實現(xiàn)Flink WordCount過程解析,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2020-02-02
這篇文章主要來為大家詳細介紹Java實現(xiàn)開發(fā)圖片驗證碼的具體方法，文中的示例代碼講解詳細，具有一定的借鑒價值，需要的可以參考一下2023-02-02
這篇文章主要介紹了Java數(shù)據(jù)結構之順序表詳解，線性表在邏輯上是線性結構，也就說是連續(xù)的一條直線。但是在物理結構上并不一定是連續(xù)的，線性表在物理上存儲時，通常以數(shù)組和鏈式結構的形式存儲,需要的朋友可以參考下2023-07-07
SpringBoost是基于Spring框架開發(fā)出來的功能更強大的Java程序開發(fā)框架,本文將以廣角視覺來剖析SpringBoot自動配置的原理，涉及部分Spring、SpringBoot源碼，需要的可以參考下2023-11-11
下面小編就為大家?guī)硪黄猻truts2框架的登錄制作圖文教程。小編覺得挺不錯的，現(xiàn)在就分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2017-11-11
這篇文章主要為大家詳細介紹了java打印日歷的實現(xiàn)代碼，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2021-01-01
這篇文章主要介紹了java 異常詳解及應用實例的相關資料,需要的朋友可以參考下2017-01-01