解释器模式
1.定义
给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
2.示例代码
以解析xml为例，说明解释器模式。
/*要解析的xml示例文件*/
<?xml version="1.0" encoding="UTF-8">
<root id="rootId">
<a>
<b>
<c name="testC">123456</c>
<d id="1">d1</d>
<d id="2">d2</d>
<d id="3">d3</d>
<d id="4">d4</d>
</b>
</a>
</root>
/*用于处理自定义xml取值表达式的接口*/
public abstract class ReadXmlExpression{
/*解释表达式*/
public abstract String[] interpret(Context c);
}
/*上下文，用来包含解释器需要的一些全局信息*/
public class Context {
/*Dom解析Xml的Document对象*/
private Document document = null;
/*上一次被处理的多个元素 */
private List<Element> preEles = new ArrayList<Element>();
/*构造方法 需要读取的xml的路径和名字*/
public Context(String filePathName) throws Exception{
//通过辅助的Xml工具类来获取被解析的xml对应的Document对象
this.document = XmlUtil.getRoot(filePathName);
}
/*重新初始化上下文*/
public void reInit(){
preEles = new ArrayList<Element>();
}
/*各个Expression公共使用的方法,根据父元素和当前元素的名称来获取当前的多个元素的集合*/
public List<Element> getNowEles(Element pEle,String eleName){
List<Element> elements = new ArrayList<Element>();
NodeList tempNodeList = pEle.getChildNodes();
for(int i=0;i<tempNodeList.getLength();i++){
if(tempNodeList.item(i) instanceof Element){
Element nowEle = (Element)tempNodeList.item(i);
if(nowEle.getTagName().equals(eleName)){
elements.add(nowEle);
}
}
}
return elements;
}
public Document getDocument() {
return document;
}
public List<Element> getPreEles() {
return preEles;
}
public void setPreEles(List<Element> nowEles) {
this.preEles = nowEles;
}
}
/*单个元素作为非终结符的解释器*/
public class ElementExpression extends ReadXmlExpression{
/*用来记录组合的ReadXmlExpression元素*/
private Collection<ReadXmlExpression> eles = new ArrayList<ReadXmlExpression>();
/* 元素的名称*/
private String eleName = "";
public ElementExpression(String eleName){
this.eleName = eleName;
}
public boolean addEle(ReadXmlExpression ele){
this.eles.add(ele);
return true;
}
public boolean removeEle(ReadXmlExpression ele){
this.eles.remove(ele);
return true;
}
public String[] interpret(Context c) {
//先取出上下文里的父级元素
List<Element> pEles = c.getPreEles();
Element ele = null;
//把当前获取的元素放到上下文里面
List<Element> nowEles = new ArrayList<Element>();
if(pEles.size()==0){
//说明现在获取的是根元素
ele = c.getDocument().getDocumentElement();
pEles.add(ele);
c.setPreEles(pEles);
}else{
for(Element tempEle : pEles){
nowEles.addAll(c.getNowEles(tempEle, eleName));
if(nowEles.size()>0){
//找到一个就停止
break;
}
}
List<Element> tempList = new ArrayList<Element>();
tempList.add(nowEles.get(0));
c.setPreEles(tempList);
}
//循环调用子元素的interpret方法
String [] ss = null;
for(ReadXmlExpression tempEle : eles){
ss = tempEle.interpret(c);
}
return ss;
}
}
/* 元素作为终结符对应的解释器*/
public class ElementTerminalExpression extends ReadXmlExpression{
/* 元素的名字*/
private String eleName = "";
public ElementTerminalExpression(String name){
this.eleName = name;
}
public String[] interpret(Context c) {
//先取出上下文里的当前元素作为父级元素
List<Element> pEles = c.getPreEles();
//查找到当前元素名称所对应的xml元素
Element ele = null;
if(pEles.size() == 0){
//说明现在获取的是根元素
ele = c.getDocument().getDocumentElement();
}else{
//获取当前的元素
ele = c.getNowEles(pEles.get(0), eleName).get(0);
}
//然后需要去获取这个元素的值
String[] ss = new String[1];
ss[0] = ele.getFirstChild().getNodeValue();
return ss;
}
}
/* 以多个元素的属性做为终结符的解释处理对象*/
public class PropertysTerminalExpression extends ReadXmlExpression{
/* 属性名字*/
private String propName;
public PropertysTerminalExpression(String propName){
this.propName = propName;
}
public String[] interpret(Context c) {
//获取最后的多个元素
List<Element> eles = c.getPreEles();
String[] ss = new String[eles.size()];
//循环多个元素，获取每个的属性的值
for(int i=0;i<ss.length;i++){
ss[i] = eles.get(i).getAttribute(this.propName);
}
return ss;
}
}
/* 以多个元素作为终结符的解释处理对象*/
public class ElementsTerminalExpression extends ReadXmlExpression{
/*元素的名称*/
private String eleName = "";
public ElementsTerminalExpression(String name){
this.eleName = name;
}
public String[] interpret(Context c) {
//先取出上下文里的父级元素
List<Element> pEles = c.getPreEles();
//获取当前的多个元素
List<Element> nowEles = new ArrayList<Element>();
for(Element ele : pEles){
nowEles.addAll(c.getNowEles(ele, eleName));
}
//然后需要去获取这些元素的值
String[] ss = new String[nowEles.size()];
for(int i=0;i<ss.length;i++){
ss[i] = nowEles.get(i).getFirstChild().getNodeValue();
}
return ss;
}
}
/*多个元素做为非终结符的解释处理对象*/
public class ElementsExpression extends ReadXmlExpression{
/* 用来记录组合的ReadXmlExpression元素*/
private Collection<ReadXmlExpression> eles = new ArrayList<ReadXmlExpression>();
/*元素名字*/
private String eleName = "";
public ElementsExpression(String eleName){
this.eleName = eleName;
}
public String[] interpret(Context c) {
//先取出上下文里的父级元素
List<Element> pEles = c.getPreEles();
//把当前获取的元素放到上下文里面，这次是获取多个元素
List<Element> nowEles = new ArrayList<Element>();
for(Element ele : pEles){
nowEles.addAll(c.getNowEles(ele, eleName));
}
c.setPreEles(nowEles);
//循环调用子元素的interpret方法
String [] ss = null;
for(ReadXmlExpression ele : eles){
ss = ele.interpret(c);
}
return ss;
}
public boolean addEle(ReadXmlExpression ele){
this.eles.add(ele);
return true;
}
public boolean removeEle(ReadXmlExpression ele){
this.eles.remove(ele);
return true;
}
}
/*测试获取多个元素的值的情况*/
public class Client {
public static void main(String[] args) throws Exception {
//准备上下文
Context c = new Context("InterpreterTest.xml");
//想要获取多个d元素的值，也就是如下表达式的值："root/a/b/d$"
//首先要构建解释器的抽象语法树
ElementExpression root = new ElementExpression("root");
ElementExpression aEle = new ElementExpression("a");
ElementExpression bEle = new ElementExpression("b");
ElementsTerminalExpression dEle = new ElementsTerminalExpression("d");
//组合起来
root.addEle(aEle);
aEle.addEle(bEle);
bEle.addEle(dEle);
//调用
String ss[] = root.interpret(c);
for(String s : ss){
System.out.println("d的值是="+s);
}
}
}
/*测试一下获取多个属性值的情况*/
public class Client {
public static void main(String[] args) throws Exception {
//准备上下文
Context c = new Context("InterpreterTest.xml");
//想要获取d元素的id属性，也就是如下表达式的值："a/b/d$.id$"
//首先要构建解释器的抽象语法树
ElementExpression root = new ElementExpression("root");
ElementExpression aEle = new ElementExpression("a");
ElementExpression bEle = new ElementExpression("b");
ElementsExpression dEle = new ElementsExpression("d");
PropertysTerminalExpression prop =
new PropertysTerminalExpression("id");
//组合
root.addEle(aEle);
aEle.addEle(bEle);
bEle.addEle(dEle);
dEle.addEle(prop);
//调用
String ss[] = root.interpret(c);
for (String s : ss) {
System.out.println("d的属性id值是=" + s);
}
}
}
/*用来封装每一个解析出来的元素对应的属性*/
public class ParserModel {
/* 是否单个值*/
private boolean singleVlaue;
/*是否属性，不是属性就是元素*/
private boolean propertyValue;
/*是否终结符*/
private boolean end;
public boolean isEnd() {
return end;
}
public void setEnd(boolean end) {
this.end = end;
}
public boolean isSingleVlaue() {
return singleVlaue;
}
public void setSingleVlaue(boolean oneVlaue) {
this.singleVlaue = oneVlaue;
}
public boolean isPropertyValue() {
return propertyValue;
}
public void setPropertyValue(boolean propertyValue) {
this.propertyValue = propertyValue;
}
}
/* 根据语法来解析表达式，转换成为相应的抽象语法树*/
public class Parser {
/*私有化构造器，避免外部无谓的创建对象实例*/
private Parser(){
}
//定义几个常量，内部使用
private final static String BACKLASH = "/";
private final static String DOT = ".";
private final static String DOLLAR = "$";
/*按照分解的先后记录需要解析的元素的名称*/
private static List<String> listEle = null;
/*传入一个字符串表达式，通过解析，组合成为一个抽象的语法树*/
public static ReadXmlExpression parse(String expr){
//先初始化记录需解析的元素的名称的集 会
listEle = new ArrayList<String>();
//第一步：分解表达式，得到需要解析的元素名称和该元素对应的解析模型
Map<String,ParserModel> mapPath = parseMapPath(expr);
//第二步：根据节点的属性转换成为相应的解释器对象
List<ReadXmlExpression> list = mapPath2Interpreter(mapPath);
//第三步：组合抽象语法树，一定要按照先后顺序来组合，
//否则对象的包含关系就乱了
ReadXmlExpression returnRe = buildTree(list);
return returnRe;
}
/*----------------------开始实现第一步-----------------------*/
/* 按照从左到右顺序来分解表达式，得到需要解析的元素名称，
* 还有该元素对应的解析模型
* @param expr 需要分解的表达式
* @return 得到需要解析的元素名称，还有该元素对应的解析模型
*/
private static Map<String,ParserModel> parseMapPath(String expr){
//先按照/分割字符串
StringTokenizer tokenizer = new StringTokenizer(expr, BACKLASH);
//初始化一个map用来存放分解出来的值
Map<String,ParserModel> mapPath = new HashMap<String,ParserModel>();
while (tokenizer.hasMoreTokens()) {
String onePath = tokenizer.nextToken();
if (tokenizer.hasMoreTokens()) {
//还有下一个值，说明这不是最后一个元素
//按照现在的语法，属性必然在最后，因此也不是属性
setParsePath(false,onePath,false,mapPath);
} else {
//说明到最后了
int dotIndex = onePath.indexOf(DOT);
if (dotIndex > 0) {
//说明是要获取属性的值，那就按照"."来分割，
//前面的就是元素名字，后面的是属性的名字
String eleName = onePath.substring(0, dotIndex);
String propName = onePath.substring(dotIndex + 1);
//设置属性前面的那个元素，自然不是最后一个，也不是属性
setParsePath(false,eleName,false,mapPath);
//设置属性，按照现在的语法定义，属性只能是最后一个
setParsePath(true,propName,true,mapPath);
} else {
//说明是取元素的值，而且是最后一个元素的值
setParsePath(true,onePath,false,mapPath);
}
break;
}
}
return mapPath;
}
/*按照分解出来的位置和名称来设置需要解析的元素名称，
* 还有该元素对应的解析模型
* @param end 是否是最后一个
* @param ele 元素名称
* @param propertyValue 是否是取属性
* @param mapPath 设置需要解析的元素名称，还有该元素对应的解析模型的Map
*/
private static void setParsePath(boolean end,String ele ,boolean propertyValue,Map<String,ParserModel> mapPath){
ParserModel pm = new ParserModel();
pm.setEnd(end);
//如果带有$符号就说明不是一个值
pm.setSingleVlaue(!(ele.indexOf(DOLLAR)>0));
pm.setPropertyValue(propertyValue);
//去掉$
ele = ele.replace(DOLLAR, "");
mapPath.put(ele,pm);
listEle.add(ele);
}
/*----------------------第一步实现结束-----------------------*/
/*----------------------开始实现第二步-----------------------*/
/* 把分解出来的元素名称，根据对应的解析模型转换成为相应的解释器对象
* @param mapPath 分解出来的需解析的元素名称，还有该元素对应的解析模型
* @return 把每个元素转换成为相应的解释器对象后的集合
*/
private static List<ReadXmlExpression> mapPath2Interpreter(Map<String,ParserModel> mapPath){
List<ReadXmlExpression> list = new ArrayList<ReadXmlExpression>();
//一定要按照分解的先后顺序来转换成解释器对象
for(String key : listEle){
ParserModel pm = mapPath.get(key);
ReadXmlExpression obj = null;
if(!pm.isEnd()){
if(pm.isSingleVlaue()){
//不是最后一个，是一个值，转化为
obj = new ElementExpression(key);
}else{
//不是最后一个，是多个值，转化为
obj = new ElementsExpression(key);
}
}else{
if(pm.isPropertyValue()){
if(pm.isSingleVlaue()){
//是最后一个，是一个值，取属性的值，转化为
obj = new PropertyTerminalExpression(key);
}else{
//是最后一个，是多个值，取属性的值，转化为
obj = new PropertysTerminalExpression(key);
}
}else{
if(pm.isSingleVlaue()){
//是最后一个，是一个值，取元素的值，转化为
obj = new ElementTerminalExpression(key);
}else{
//是最后一个，是多个值，取元素的值，转化为
obj = new ElementsTerminalExpression(key);
}
}
}
//把转换后的对象添加到集合中
list.add(obj);
}
return list;
}
/*----------------------第二步实现结束-----------------------*/
/*----------------------开始实现第三步-----------------------*/
private static ReadXmlExpression buildTree(List<ReadXmlExpression> list){
//第一个对象，也是返回去的对象，就是抽象语法树的根
ReadXmlExpression returnRe = null;
//定义上一个对象
ReadXmlExpression preRe = null;
for(ReadXmlExpression re : list){
if(preRe==null){
//说明是第一个元素
preRe = re;
returnRe = re;
}else{
//把元素添加到上一个对象下面，同时把本对象设置成为oldRe，
//作为下一个对象的父结点
if(preRe instanceof ElementExpression){
ElementExpression ele = (ElementExpression)preRe;
ele.addEle(re);
preRe = re;
}else if(preRe instanceof ElementsExpression){
ElementsExpression eles = (ElementsExpression)preRe;
eles.addEle(re);
preRe = re;
}
}
}
return returnRe;
}
/*----------------------第三步实现结束-----------------------*/
}
/* 使用解析器
*想要获取c元素的值，表达式为：“root/a/b/c”
*想要获取c元素的name属性值，表达式为：“root/a/b/c.name”
*想要获取d元素的值，表达式为：“root/a/b/d$”，获取d的属性测试
*/
public class Client {
public static void main(String[] args) throws Exception {
//准备上下文
Context c = new Context("InterpreterTest.xml");
//通过解析器获取抽象语法树
ReadXmlExpression re = Parser.parse("root/a/b/d$.id$");
//请求解析，获取返回值
String ss[] = re.interpret(c);
for (String s : ss) {
System.out.println("d的属性id值是=" + s);
}
//如果要使用同一个上下文，连续进行解析，需要重新初始化上下文对象
c.reInit();
ReadXmlExpression re2 = Parser.parse("root/a/b/d$");
//请求解析，获取返回值
String ss2[] = re2.interpret(c);
for (String s : ss2) {
System.out.println("d的值是=" + s);
}
}
}
3.实际应用
解释器模式通过一个解释器对象处理一个语法规则的方式，把复杂的功能分离开；然后选择需要被执行的功能，并把这些功能组合成为需要被解释执行的抽象语法树；然后再按照抽象语法树来解释执行，实现相应的功能。
解释器模式的本质：分离实现，解释执行