1、需要解析的xml格式文件

<Response>
<MessageHead>
<MessageID>5DF751F7-96AD-D68E-6B72-C9DEEC6182E3</MessageID>
<MessageSender>XmlList</MessageSender>
<MessageResultValue>1</MessageResultValue>
<MessageReusltInfo>服务请求成功！</MessageReusltInfo>
</MessageHead>
<MessageBody>
<MaterialItem>
<MaterialCode>1204-3-2</MaterialCode>
<ItemQty>3</ItemQty>
</MaterialItem>
<MaterialItem>
<MaterialCode>1204-3-1</MaterialCode>
<ItemQty>1</ItemQty>
</MaterialItem>
<HisItem>
<HisCode>CGJY.000297</HisCode>
<MaterialCode>1204-3-2</MaterialCode>
</HisItem>
<HisItem>
<HisCode>CGJY.000388</HisCode>
<MaterialCode>1204-3-1</MaterialCode>
</HisItem>
<HisItem>
<HisCode>CGJY.000295</HisCode>
<MaterialCode>1204-3-2</MaterialCode>
</HisItem>
<HisItem>
<HisCode>CGJY.000226</HisCode>
<MaterialCode>1204-3-2</MaterialCode>
</HisItem>
<HisItem>
<HisCode>CGJY.000227</HisCode>
<MaterialCode>1204-3-2</MaterialCode>
</HisItem>
</MessageBody>
</Response>

2、解析xml至list集合的代码：

public class xmlToList {

/**
* 主入口
*
* @param param
* @return
* @throws BizException
*/
public <T extends Base> Base[] exec(String param, Class<T> classInfo)
throws BizException {

// 1、基础校验
validation(param);

// 2、解析Xml
Base[] rtns = parseXml(param, classInfo);

return rtns;
}

/**
* 基础校验
*
* @param param
* @throws BizException
*/
private void validation(String param) throws BizException {
if (StringUtils.isEmptyWithTrim(param)) {
throw new BizException(“Xml转换为list对象，Xml参数空异常！”);
}
}

/**
* 解析Xml
*
* @param xmlStr
* @param classInfo
* @throws BizException
*/
private MaterialItem[] parseXml(String xmlStr, Class<?> classInfo)
throws BizException {

List<String> listAttr = new ArrayList<String>();
// SchInfoDTO dto = initRtn(classInfo, listAttr);

List<MaterialItem> reList = new ArrayList<MaterialItem>();
SAXReader reader = new SAXReader();
try {
//
Document document = reader.read(new ByteArrayInputStream(xmlStr
.getBytes(“UTF-8”)));
// Document document =
// DocumentHelper.parseText(xmlStr);//获取document对象
// getRootElement 获取到该节点的根节点
Element eleRoot = document.getRootElement();
// String bookName = eleRoot.getName();
//判断根节点是否为空
if (eleRoot != null) {
//获取到根节点 eleRoot 的iterator对象
Iterator it = eleRoot.elementIterator();
Element schinfo = null;
Element schinfos = null;
Element data = null;
Element hisItem = null;
Element table = null;
// Element element3;

List<String> rootList = new ArrayList<String>();
while (it.hasNext()) {
// System.out.println(“=====开始遍历=====”);
Element oneRoot = (Element) it.next();
// 获取book的属性名以及 属性值
List<Attribute> bookAttrs = oneRoot.attributes();

Iterator itt = oneRoot.elementIterator();
while (itt.hasNext()) {// 判断itt节点中是否有值 有着 就执行 itt.next
Element oneRootChild = (Element) itt.next();
String nodeName = oneRootChild.getName();// 获取到RequestMaterialResponse节点名称
String nodeValue = oneRootChild.getStringValue();// 获取到Response节点中的值
// 获取到Document对象
Document doc = reader.read(new ByteArrayInputStream(
nodeValue.getBytes(“UTF-8”)));
Element root = doc.getRootElement();// 获取到根节点 Response名称
if (root != null) {
data = root.element(“MessageBody”);// 获取到节点MessageBody;
if (data != null) {
schinfos = data.element(“MaterialItem”);// 获取到节点MaterialItem;

}
}
}
// System.out.println(“=====结束遍历=====”);

@SuppressWarnings(“unchecked”)
// .elements 表示遍历这个节点
List<Element> schinfoList = data.elements();// 遍历根节点
if (schinfoList == null || schinfoList.size() < 1) {
return null;
}

// 循环根节点中每一个节点
for (Element rootelement : schinfoList) {
//获取到循环的每个节点的名称
String rootelementName = rootelement.getName();
//判断 节点的名称为 MaterialItem 的值 进入
if (rootelementName.equals(“MaterialItem”)) {

MaterialItem sch = new MaterialItem();

// 获取到MaterialItem节点下的节点名称集合
List<Element> rootV = rootelement.elements();
// 获取到每一个MaterialItem节点下子节点名称
String rootName = rootelementName;
//获取到循环到的MaterialItem节点下子节点的值
String rootValue = rootelement.getStringValue();
// 循环遍历MaterialItem节点下子节点名称集合

// 获取到MaterialItemDTO集合中的所有字段名称
String[] item = sch.getAttrNames();
//循环MaterialItemDTO集合中的字段名称
for (String i : item) {
//判断当前循环到的 MaterialItem 节点下的子节点值 并给list集合对应的值 赋值
if (i.equals(“materialcode”)) {
String st = rootelement.elementText(“MaterialCode”);
sch.setMaterialCode(st);
}else if(i.equals(“itemqty”)){
String st = rootelement.elementText(“ItemQty”);
sch.setItemQty(st);
}
continue;
}
reList.add(sch);
}

}
// hisItem = data.element(“HisItem”);
List<Element> schinfoLists = data.elements();// 遍历根节点
if (schinfoLists == null || schinfoLists.size() < 1) {
return null;
}

// 循环根节点中每一个节点
for (Element rootelements : schinfoLists) {

String rootelementHisCodeName = rootelements.getName();
if (rootelementHisCodeName.equals(“HisItem”)) {
MaterialItemDTO schs = new MaterialItemDTO();

// 获取到Schinfo节点中的节点集合
List<Element> rootVs = rootelements.elements();
// 获取到每一个Schinfo节点中的值
String name = rootelements.getName();
String rootValues = rootelements.getStringValue();
// 循环遍历Schinfo节点集合
//for (Element rootVals : rootVs) {
// 获取到DTO中的所有字段名称
String[] items = schs.getAttrNames();
for (String i : items) {
//判断当前循环到的 MaterialItem 节点下的子节点值 并给list集合对应的值 赋值
if (i.equals(“materialcode”)) {
String st = rootelements.elementText(“MaterialCode”);
schs.setMaterialCode(st);
}else if(i.equals(“hiscode”)){
String st = rootelements.elementText(“HisCode”);
schs.setHisCode(st);;
}
continue;
}
//}
// 判断 使用耗材代码 是否为空 ，为空则不存
if (schs.getMaterialCode() != null
&& schs.getMaterialCode() != “”) {
reList.add(schs);
}

}
}

}
}

} catch (Exception e1) {
throw new BizException(“解析Xml异常！”);
}
return reList.toArray(new MaterialItem[reList.size()]);
}

}

3、解析完后 list格式数据

[{MaterialCode:(1204-3-2),ItemQty:(3),Status:(0),Dirty:(false)},
{MaterialCode:(1204-3-1),ItemQty:(1),Status:(0),Dirty:(false)},
{HisCode:(CGJY.000297),MaterialCode:(1204-3-2),Status:(0),Dirty:(false)},
{HisCode:(CGJY.000388),MaterialCode:(1204-3-1),Status:(0),Dirty:(false)},
{HisCode:(CGJY.000295),MaterialCode:(1204-3-2),Status:(0),Dirty:(false)},
{HisCode:(CGJY.000226),MaterialCode:(1204-3-2),Status:(0),Dirty:(false)},
{HisCode:(CGJY.000227),MaterialCode:(1204-3-2),Status:(0),Dirty:(false)}]