读《研磨设计模式》-代码笔记-解释器模式-Interpret
声明：
本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/
本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/
package design.pattern;
/*
* 解释器（Interpreter）模式的意图是可以按照自己定义的组合规则集合来组合可执行对象
*
* 代码示例实现XML里面1.读取单个元素的值 2.读取单个属性的值
* 多个元素或者多个属性的示例书上也有，但稍显复杂，就不做这方面的笔记了
*/
import java.util.ArrayList;
import java.util.Collection;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
abstract class Expression {
//可能返回一个String也可能返回多个。String书上说为了兼容，返回值定义为String数组
public abstract String[] interpret(Context context);
}
/**
* Context持有两个Field:
* 1.整个XML对象（Document document）
* 2.上一个被处理的元素（Element preElement）
* 当Expression执行interpret方法时，不断改变Context里的preElement，直到表达式终止为止
*/
class Context {
//上一个被处理的元素
private Element preElement;
private Document document;
public Context(String filePath) throws Exception {
this.document = XMLUtil.getRoot(filePath);
}
public void redoInit() {
this.preElement = null;
}
/**
* 根据父元素和子元素的名字来获取子元素
* @param preElement 父元素
* @param elementName 要找的元素的名字
* @return 找到的元素
*/
public Element getCurElement(Element preElement, String elementName) {
Element result = null;
NodeList nodeList = preElement.getChildNodes();
//遍历所有直接子元素（孙子元素不算）
for (int i = 0, len = nodeList.getLength(); i < len ;i ++) {
Node node = nodeList.item(i);
if (node instanceof Element) {
Element element = (Element)node;
if (element.getNodeName().equals(elementName)) {
result = element;
break;
}
}
}
return result;
}
public Element getPreElement() {
return preElement;
}
public void setPreElement(Element preElement) {
this.preElement = preElement;
}
public Document getDocument() {
return document;
}
}
/**
* 读取XML文件的帮助类。提供一个方法根据文件名返回XML Document对象
*/
class XMLUtil {
public static Document getRoot(String filePath) throws Exception {
Document doc = null;
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
doc = builder.parse(filePath);
doc.normalize();
return doc;
}
}
//非终结元素的解释器
class ElementExpression extends Expression {
//在下面的测试，Expression的childExpressions只有一个。childExpressions.size() = 1
private Collection<Expression> childExpressions = new ArrayList<Expression>();
private String elementName;
public ElementExpression(String elementName) {
this.elementName = elementName;
}
public void add(Expression expression) {
this.childExpressions.add(expression);
}
public void remove(Expression expression) {
this.childExpressions.remove(expression);
}
public String[] interpret(Context context) {
Element parent = context.getPreElement();
Element curElement = null;
if (parent == null) { //说明是根元素
Document dom = context.getDocument();
curElement = dom.getDocumentElement(); //Document.getDocumentElement，取得根元素
} else {
curElement = context.getCurElement(parent, elementName);
}
context.setPreElement(curElement);
String[] ss = null;
for (Expression expression : childExpressions) {
//这里写得有歧义。如果childExpressions.size > 1，那ss只能获取到最后一个childExpression的返回值
//不过由于测试过程中，childExpressions.size = 1，也就问题不大
ss = expression.interpret(context);
}
return ss;
}
public String toString() {
return "elementName = " + elementName + ", childExpressions = " + childExpressions;
}
}
//元素作为终结符的解释器
class ElementTerminatorExpression extends Expression {
private String elementName;
public ElementTerminatorExpression(String elementName) {
this.elementName = elementName;
}
public String[] interpret(Context context) {
Element parent = context.getPreElement();
Element curElement = null;
if (parent == null) { //说明是根元素
curElement = context.getDocument().getDocumentElement(); //返回根元素
} else {
curElement = context.getCurElement(parent, elementName);
}
context.setPreElement(curElement);
//获取元素的值
String finalValue = curElement.getFirstChild().getNodeValue();
return new String[]{finalValue};
}
}
//属性作为终结符的解释器
class PropertyTerminatorExpression extends Expression {
private String propertyName;
public PropertyTerminatorExpression(String propertyName) {
this.propertyName = propertyName;
}
public String[] interpret(Context context) {
//直接获取元素的属性的值
String finalValue = context.getPreElement().getAttribute(this.propertyName);
return new String[]{finalValue};
}
}
//这个类是用来测试的
public class InterpreterPattern {
public static void main(String[] args) throws Exception {
/*
<?xml version="1.0" encoding="UTF-8"?>
<root id="rootId">
<a>
<b>
<c name="testC">12345</c>
<d id="1">d1</d>
<d id="2">d2</d>
<d id="3">d3</d>
<d id="4">d4</d>
</b>
</a>
</root>
*/
Context context = new Context("d:/interpretPattern.xml");
//构建要查找的表达式的语法树，例如我们要查看元素c的值，表达式是root/a/b/c
//元素作为终结符
ElementExpression root = new ElementExpression("root");
ElementExpression a = new ElementExpression("a");
ElementExpression b = new ElementExpression("b");
ElementTerminatorExpression c = new ElementTerminatorExpression("c");
root.add(a);
a.add(b);
b.add(c);
String[] ss = root.interpret(context);
System.out.println("c = " + ss[0]);
//元素属性作为终结符，例如root/a/b/c.name
context.redoInit();
ElementExpression roott = new ElementExpression("root");
ElementExpression aa = new ElementExpression("a");
ElementExpression bb = new ElementExpression("b");
ElementExpression cc= new ElementExpression("c");
PropertyTerminatorExpression prop = new PropertyTerminatorExpression("name");
roott.add(aa);
aa.add(bb);
bb.add(cc);
cc.add(prop);
ss = roott.interpret(context);
System.out.println("c name = " + ss[0]);
context.redoInit();
ss = roott.interpret(context);
System.out.println("c name = " + ss[0]);
}
}