android 自带sax解析

public class AtomParser extends DefaultHandler {
// br节点高度，如果有连续的br节点，则存在br节点高度值，且该值项目组可通过brHeight配置具体大小
private int brHeight_;
// 判断br节点是否连续
private int brIndex_;
// 脚本文件,该内容应该在解析完页面后执行,
private Stack scriptStack_;
// 节点样式display属性列表，存储每个节点样式display的属性值。由于在节点尾需要读取对应的display属性，所以创建该堆栈
private Stack displayStack_;
// 标志控件在Br节点之后
static boolean ISAFTERBR;
// 是否已插入界面中部结构
boolean isInsertLLV_;
Activity activity_;
// 节点队列，方便添加子节点
Stack stack_;
// 节点名堆栈
Stack nodeNameStack_;
final int START_DOCUMENT = 0;
final int END_DOCUMENT = 1;
final int START_TAG = 2;
final int END_TAG = 3;
final int TEXT = 4;
// 触发的事件类型
int eventType_;
// 读取中间节点值的次数
int readTextIndex_;
// 存储节点值
StringBuffer buf_ = new StringBuffer(10);
private LPPieChart pieChart_;
private LPSelect select_;
// 解析类型，是全部解析或者局部解析
private int parseType_;
// 解析出来是整个界面结构标志
public static final int ENTIRE = 0;
// 解析出来是局部控件标志
public static final int PARTLY = 1;
// 存储整个界面的样式,且里面内容只为当前界面样式一个元素,该界面指整个手机界面
// 并非弹出框的显示的部分界面,与PARTLY相对应
private static Stack ENTIRESTACK;
// 报文是否含样式节点标记
private boolean haveStyle_;


/**
*
* @param activity
* @param type
* 解析类型 0 整个界面结构解析 1 局部控件解析
*/
public AtomParser(Activity activity, int type) {
activity_ = activity;
parseType_ = type;
}


// XML开始解析时调用此方法
public void startDocument() throws SAXException {
eventType_ = START_DOCUMENT;
stack_ = new Stack();
nodeNameStack_ = new Stack();
displayStack_ = new Stack();
scriptStack_ = new Stack();
if (parseType_ == ENTIRE) {
Component.VWIDGETARRAY = new ArrayList(2);
ENTIRESTACK = new Stack();
Component.radioList_ = null;
}
ComponentCopy.CC = null;
}


// 解析到Element的开头时调用此方法
public void startElement(String namespaceURI, String localName, String qName, Attributes atts) throws SAXException {
eventType_ = START_TAG;
// 将读取节点值次数标记复位
readTextIndex_ = 0;
nodeNameStack_.add(localName);
if (localName.equalsIgnoreCase("script")) {
Component.LUASTATE.gc(LuaState.LUA_GCCOLLECT, 0);
String src = getAttrString(atts, "src");
if (null != src) {
if (src.startsWith("/")) {
downloadLuaFromServer(src);
} else {
Component.LUASTATE.LdoString(Utils.getStringFormAsset(activity_, src));
}
}
} else if (((nodeNameStack_.indexOf("body") != -1) && (parseType_ == ENTIRE)) || (parseType_ == PARTLY)) {
if (localName.equalsIgnoreCase("style") || localName.equalsIgnoreCase("head")
|| localName.equalsIgnoreCase("content"))
return;
ComponentCopy ccCopy = new ComponentCopy();
ccCopy.setName(localName);
final int size = atts.getLength();
for (int i = 0; i < size; i++) {
// 循环读取节点中的属性，存入结构
ccCopy.addAttrs(atts.getLocalName(i), Utils.insteadOfSpecillCharacter(atts.getValue(i).trim(), false));
}


if (!stack_.isEmpty()) {
String temp = null;
if (null != ccCopy.nodeAttrsMap_ && !ccCopy.nodeAttrsMap_.isEmpty()) {
// 取当前节点的属性值,如果存在的话
temp = (String) ccCopy.nodeAttrsMap_.get("class");
}
if (null != temp && null != CssStyle.STYLEHASH) {
CssStyle cs = (CssStyle) CssStyle.STYLEHASH.get(temp.trim());
if (isInsertLLV_ && null != cs && null != cs.position_) {
// 如果已经插入llv节点,且当前节点存在positon属性,表示该节点占据的应是界面下方位置
// ，所以它不应该在llv节点内，此时应将llv节点从栈中移除。
// 暂时只支持上中下三结构的position的定位
stack_.pop();
}
}
}


String className = atts.getValue("class");
String display = null;
if (null != className) {
if (null != CssStyle.STYLEHASH) {
CssStyle cs = (CssStyle) CssStyle.STYLEHASH.get(className.trim());
if (null != cs) {
display = (String) cs.getProperty(CssStyle.DISPLAY);
}
}
}
displayStack_.add(display);
if (!localName.equalsIgnoreCase("body") && (!stack_.isEmpty())) {
// 此节点不是第一个节点，将该节点加入前面节点的子元素队列
((ComponentCopy) stack_.peek()).addChilds(ccCopy);
}
stack_.add(ccCopy);


}


}


/**
* 根据src中的url去服务器download指定的lua代码并加载到lua引擎中
*
* @param src
* eg: "/ebank/lua/ebank_request.lua"
*/
private void downloadLuaFromServer(String src) {
final String uri = Utils.getConfigStringFormAsset(activity_, "SERVER_URI").concat(src);
Utils.printOutToConsole("downloadLuaFromServer()------" + uri);
HttpManager hm = new HttpManager(activity_);
String luastr = (String) hm.sendPostRequest(uri, null, null, null);
if (luastr != null && !luastr.trim().equals("")) {
// 不要太频繁调gc.
// Component.LUASTATE.gc(LuaState.LUA_GCCOLLECT, 0);
Component.LUASTATE.LdoString(luastr);
}
}


// XML解析结束时调用此方法
public void endDocument() throws SAXException {
eventType_ = END_DOCUMENT;
activity_.runOnUiThread(new Runnable() {


@Override
public void run() {
// TODO Auto-generated method stub
// 当xml元素转为view的时候，防止view在创建过程中其他线程对view进行操作导致的异常
if (null != ComponentCopy.CC) {
xmlToView(ComponentCopy.CC, null);
if (parseType_ == ENTIRE) {
ComponentCopy.COMPONENT.mouldAndLayout();
} else {
ComponentCopy.COMPONENTPARTLY.mouldAndLayout();
}
}
if (null != scriptStack_ && scriptStack_.size() > 0) {
final int size = scriptStack_.size();
String scriptText = "";
int index;
synchronized (this) {
for (int i = 0; i < size; i++) {
scriptText = scriptStack_.get(i).toString();
index = Component.LUASTATE.LdoString(scriptText);


if (index > 0) {
Utils.printOutToConsole("Lua Text has some errors:");
Utils.printOutToConsole(Component.LUASTATE.LcheckString(-1));
}
}
}
}
// 清空该类用到的相关资源
stack_ = null;
nodeNameStack_ = null;
displayStack_ = null;
pieChart_ = null;
select_ = null;
activity_ = null;
buf_ = null;
if (null != scriptStack_)
scriptStack_.removeAllElements();
scriptStack_ = null;


}
});


}


/**
* 该方法将控件从树状结构ComponentCopy中解析出来,并将他们逐个加到上一级的childrenList_队列中
*
* @param cc
* 为控件自己
* @param component
* 为控件父控件
*/
private void xmlToView(ComponentCopy cc, Component component) {
// TODO Auto-generated method stub
try {
// 遍历cc中的所有元素，如果是样式报文，则将样式报文分解成样式序列
final String name = cc.nodeName_;
String nameType = (String) cc.getAttr("type");
if (null == nameType)
nameType = "";
// 如果cc是其他元素则查看它是不是控件
// 先将cc在控件列表ParseWidgets.WIDGETSLIST中对应的控件查找出来


Object o = ParseWidgets.initWidget(cc.nodeName_.concat("-").concat(nameType));
if (o instanceof LPWrap) {
ISAFTERBR = true;
brIndex_++;
// br节点连续，则需要计算控件前面br的累加高度和框架内控件间距，
// br高度值在Config配置文件中通过brHeight设置
if (brIndex_ > 1) {
int h = 0;
if (component instanceof LPLayout)
h = ((LPLayout) component).getVG();
brHeight_ += Utils.getBrHeight() + h;
}
return;
} else {
brIndex_ = 0;
}


if (null != o) {
Component comp = (Component) o;
// 如果元素o不为空，说明是系统控件此时要做以下几点事情:
// 1、将对应的cssstyle样式赋给该控件
// 如果当前报文没有style样式节点，且解析类型为局部解析
// 表示当前报文做的操作为局部刷新，控件样式需要对应到最近的全局报文中去
if (!haveStyle_ && parseType_ == PARTLY && null != ENTIRESTACK && !ENTIRESTACK.isEmpty())
CssStyle.STYLEHASH = (HashMap) ENTIRESTACK.get(0);
comp.setCssStyle((CssStyle) CssStyle.STYLEHASH.get(cc.nodeAttrsMap_.get("class")));
// 2、将对应的属性集合赋给该控件
comp.setProperty((HashMap) cc.getAttrs());
if (ISAFTERBR) {
// 赋值换行标记
comp.isAfterBr_ = ISAFTERBR;
ISAFTERBR = false;
}


comp.setBrHeight(brHeight_);
// br节点不连续，即使将br节点高度值清零
brHeight_ = 0;
// 所有控件的显示值存储在节点值中
comp.property_.put("text", cc.nodeValue_);
comp.initRealView(activity_, cc.nodeValue_);
comp.childrenList_ = new ArrayList<Component>(2);
comp.setTag(cc.nodeName_);
// 将控件加入控件集合
Component.VWIDGETARRAY.add(comp);
if (null != component) {
component.childrenList_.add(comp);
comp.setParent(component);
} else {
if (parseType_ == ENTIRE) {
ComponentCopy.COMPONENT = comp;
} else {
ComponentCopy.COMPONENTPARTLY = comp;
}
}


// 4、检查该控件是否存在子元素，如果是则遍历其子元素
int size = cc.getChildren().size();
for (int i = 0; i < size; i++) {
xmlToView(cc.getChild(i), comp);
}


}
} catch (Exception e) {
Utils.printException(e);
}
}


private void setClassField(Class c, String name, Object value) {
// TODO Auto-generated method stub
try {
Field field = null;
field = c.getDeclaredField(name);
field.set(field, value);
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
Utils.printException(e);
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
Utils.printException(e);
} catch (SecurityException e) {
// TODO Auto-generated catch block
Utils.printException(e);
} catch (NoSuchFieldException e) {
// TODO Auto-generated catch block
Utils.printException(e);
}
}


// 解析到Element的结尾时调用此方法
public void endElement(String namespaceURI, String localName, String qName) throws SAXException {
eventType_ = END_TAG;
String content = "";
if (null != buf_) {
content = buf_.toString().trim();
content = Utils.insteadOfSpecillCharacter(content, false);
}
if (localName.equalsIgnoreCase("style")) {
haveStyle_ = true;
// 读取界面的样式值，并赋给stylehash变量
CssStyle.STYLEHASH = CssStyle.parseStyle(content);
// 存储全局界面的样式，该栈元素始终唯一，保存当前全界面的样式
if (parseType_ == ENTIRE)
ENTIRESTACK.add(CssStyle.STYLEHASH);
// 清空节点值
buf_ = null;
return;
} else if (localName.equalsIgnoreCase("script")) {
if (null != content || !content.equals("")) {
// Component.LUASTATE.LdoString(content);
scriptStack_.add(content);
}
// 清空节点值
buf_ = null;
return;
}
if ((nodeNameStack_.indexOf("body") != -1) && (parseType_ == ENTIRE)) {
// 将该元素赋给静态变量，以备程序调用
if (!stack_.isEmpty() && null == ComponentCopy.CC)
ComponentCopy.CC = (ComponentCopy) stack_.get(0);
ComponentCopy cc = (ComponentCopy) stack_.peek();
cc.setValue(content);
displayStack_.pop();
// 将该节点出栈，使栈顶元素为其上层节点，方便其上层节点添加新的子元素
stack_.pop();
if (null != CssStyle.STYLEHASH) {
CssStyle cs = (CssStyle) CssStyle.STYLEHASH.get(cc.nodeAttrsMap_.get("class"));
insertLLVCode(cs);
}
} else if (parseType_ == PARTLY) {
if (localName.equalsIgnoreCase("head") || localName.equalsIgnoreCase("content"))
return;
if (!stack_.isEmpty()) {
ComponentCopy cc = (ComponentCopy) stack_.peek();
cc.setValue(content);
if (null == ComponentCopy.CC)
ComponentCopy.CC = (ComponentCopy) stack_.get(0);
}


displayStack_.pop();
// 将该节点出栈，使栈顶元素为其上层节点，方便其上层节点添加新的子元素
stack_.pop();
}
nodeNameStack_.pop();
// 清空节点值
buf_ = null;
}


/**
* 插入llV节点,该节点是android界面结构需要,手动加入,在服务端提供的xml报文中不会有体现
*
* @param cs
*/
private void insertLLVCode(CssStyle cs) {
// TODO Auto-generated method stub
// 取得控件样式position对应的值,决定是否插入llv节点,该控件纯粹是为了管理界面结构,没有任何表现形式.
if (null != cs && null != cs.position_) {
// 获取控件的position样式
if (!isInsertLLV_) {
// 更改标记，表示已执行插入操作
isInsertLLV_ = true;


// 在llv节点之前插入br节点，模拟换行效果
ComponentCopy tempBr = new ComponentCopy();
tempBr.setName("br");
((ComponentCopy) stack_.peek()).addChilds(tempBr);


// 尚未插入界面中部总管理器节点，在此执行插入操作
ComponentCopy temp = new ComponentCopy();
temp.setName("llv");
((ComponentCopy) stack_.peek()).addChilds(temp);
stack_.add(temp);
}
}
}


// 取得Element的中间夹的字符串
public void characters(char ch[], int start, int length) {
if (eventType_ == END_TAG && length > 1) {
// 如果紧接着end_tag后面有需要获取出来的数据则执行
readTextIndex_ = 0;
}
try {
eventType_ = TEXT;
if (readTextIndex_ == 0) {
// 节点计数器为零表示是第一次读取该节点值。应将以前读取的值全部清空。该处执行赋空操作，如果执行delete操作数据量大的话会引起内存溢出问题。
buf_ = null;
buf_ = new StringBuffer(10);
}
// 读取节点值
if (null != buf_)
buf_.append(ch, start, length);
// 节点值计数器累加
readTextIndex_++;


} catch (Exception e) {
// TODO Auto-generated catch block
Utils.printException(e);
}
}


/**
* @param atts
* @param attrName
* @return
*/
private final String getAttrString(Attributes atts, String attrName) {
String attr = null;
try {
attr = Utils.insteadOfSpecillCharacter(atts.getValue(attrName), false);
} catch (Exception e) {
Utils.printException(e);
}
return attr;
}

}

============================================================分割===============================

/**
* 读取本地文件main.xml，根据该文件显示界面内容，并决定程序的下一步动作
*/
private void readMainXml() {
// TODO Auto-generated method stub
String mainXml = Utils.getStringFormAsset(this, "main.xml");
initLuaScript();

//解析的具体实现，handler
AtomParser apc = new AtomParser(this, AtomParser.ENTIRE);
try {
//触发解析
android.util.Xml.parse(mainXml, apc);
setContentView(ComponentCopy.COMPONENT.getLPView());
} catch (SAXException e) {
// TODO Auto-generated catch block
Utils.printException(e);
}
}