设计模式之解释器模式

时间:2022-04-03 17:11:32
模式定义:
        给定一个语言的文法,即规则,并且定义一个解释器用来解释语言中的句子。该模式描述了
        在怎么样给定一个简单的文法之后,使用该模式来解释这些句子。在解释器模式中定义了一
        个代表语言文法命令的类层次结构,在这个结构中可以存在任何的组合规则,每一个具体的
        解释器都有相同的解释操作,然而,每个解释器都以不同的方式实现公共的解释操作。再解
        释器模式中使用组合的方式将一些类组成一个集合,然后定义出一种语法规则,解释器根据
        已经定义的语法规则执行,生成可执行对象。
        
        mydia语言规则:
        区分大小写、以PROGRAM开始END结尾、PRINTLN表示打印一行并换行、使用FOR...FROM...TO...END
        表示循环
        PROGRAM PRINTLN start.... FOR i FROM 10 TO 20 PRINTLN i PRINTLN end.... END   预生成:
        start....
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        end....
        
遵循原则:
        开闭原则;
        封装变化部分;
适用场合:
        
知识扩展:

        JDK中java.text.Format就是解释器模式。

/**
 * 该类主要用来保存待执行的语句、当前节点、动态参数内容,以及操作这些数据的公共方法。
 * @author xsy
 *
 */
public class Context {
    //待解析的内容
    private final StringTokenizer stringTokenizer;
    //当前命令
    private String currentToken;
    //动态信息
    private Map<String, Object> map = new HashMap<String, Object>();
    
    public Context(String string) {
        super();
        //使用空格表示分隔符
        this.stringTokenizer = new StringTokenizer(string);
    }
    /**
     * 解析文本
     * @return
     */
    public String next(){
        if(this.stringTokenizer.hasMoreTokens()){
            currentToken = this.stringTokenizer.nextToken();
        }else {
            currentToken = null;
        }
        return currentToken;
    }
    /**
     * 判断命令是否正确
     * @param command
     * @return
     */
    public boolean equalsWithCommand(String command){
        if(null == command || !command.equals(currentToken)){
            return false;
        }return true;
    }
    /**
     * 获取当前内容
     * @return
     */
    public String getCurrentToken(){
        return this.currentToken;
    }
    
    public String getTokenContent(String text){
        String string = text;
        if(string != null){
            Iterator<String> itr = this.map.keySet().iterator();
            while (itr.hasNext()) {
                String key = itr.next();
                Object object = map.get(key);
                string = string.replaceAll(key, object.toString());
            }
        }
        return string;
    }
    public void put(String key,Object object ){
        this.map.put(key,object);
    }
    public void clear(String key){
        this.map.remove(key);
    }
}

public interface IExpression {
    /**
     * 解释
     * @param context
     */
    public void parse(Context context);
    /**
     * 执行
     */
    public void execute();
}

public class PrimitiveExpression implements IExpression {
    private Context context;
    private String tokenName;
    private String text;
    public PrimitiveExpression(Context context) {
        this.parse(this.context);
    }

    @Override
    public void execute() {
        if("PRINTLN".equals(this.tokenName))
        System.out.println(this.context.getTokenContent(text));
    }

    @Override
    public void parse(Context context) {
        this.context = context;
        this.tokenName = this.context.getCurrentToken();
        this.context.next();
        if("PRINTLN".equals(this.tokenName)){
            this.text = this.context.getCurrentToken();
            this.context.next();
        }
    }

}

public class ListExpression implements IExpression {

    private Context context;
    private final List<IExpression> list = new ArrayList<IExpression>();
    @Override
    public void execute() {
        Iterator<IExpression> itr = list.iterator();
        while (itr.hasNext()) {
            itr.next().execute();
            
        }
    }

    @Override
    public void parse(Context context) {
        this.context = context;
        while (true) {
            if(this.context.getCurrentToken() == null){
                System.out.println("error!! END is excepted");
                break;
            }else if(this.context.equalsWithCommand("END")){
                this.context.next();
                break;
            }else {
                IExpression expression = new CommandExpression(this.context);
                list.add(expression);
            }
            
        }
    }

}

public class ForExpression implements IExpression {
    private final Context context;
    private IExpression expression;
    private String var;
    private int start;
    private int end;
    public ForExpression(Context context) {
        this.context = context;
        this.parse(this.context);
    }

    @Override
    public void execute() {
        for (int i = start; i <= end; i++) {
            this.context.put(""+this.var, i);
            this.expression.execute();
        }
        this.context.clear(""+this.var);
    }
    

    @Override
    public void parse(Context context) {
        this.context.next();
        while (true) {
            if(this.context.equalsWithCommand("FROM")){
                String nextString = this.context.next();
                start = Integer.parseInt(nextString);
                this.context.next();
            }else if(this.context.equalsWithCommand("TO")){
                String nextString = this.context.next();
                end = Integer.parseInt(nextString);
                this.context.next();
                break;
            }else {
                if(this.var == null){
                    this.var = this.context.getCurrentToken();
                }
                this.context.next();
            }
        }
        this.expression = new ListExpression();
        this.expression.parse(this.context);
    }

}

public class ProgramExpression implements IExpression {

    private final Context context;
    /**
     * 当前命令
     */
    private final static String COMMAND = "PROGRAM";
    /**
     * 下一个表达式
     */
    private IExpression expression;
    
    
    public ProgramExpression(String text) {
        this.context = new Context(text);
        this.parse(this.context);
    }

    @Override
    public void execute() {
        if(!this.context.equalsWithCommand(COMMAND)){
            System.out.println("error!! PROGRAM is excepted");
        }else {
            this.context.next();
            this.expression = new ListExpression();
            this.expression.parse(this.context);
            this.expression.execute();
        }
    }

    @Override
    public void parse(Context context) {
        this.context.next();
    }

}

public class CommandExpression implements IExpression {

    private final Context context;
    private IExpression expression;
    
    public CommandExpression(Context context) {
        this.context = context;
        this.parse(this.context);
    }

    @Override
    public void execute() {
        this.expression.execute();
    }

    @Override
    public void parse(Context context) {
        if(this.context.equalsWithCommand("FOR")){
            expression = new ForExpression(this.context);
        }else{
            expression = new PrimitiveExpression(this.context);
        }
    }

}

测试

public class Client {
    public static void main(String[] args) {
        String str = "PROGRAM PRINTLN start.... FOR i FROM 10 TO 20 PRINTLN i END";
        IExpression expression = new ProgramExpression(str);
        expression.execute();
    }

}