简单结构的xml转换
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.ByteArrayInputStream;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class XmlUtil {
/**
* xml转换为map(只适用简单的xml(没有嵌套结构))
*
* @param xml xml的字符串
* @param charset 编码类型
* @return
* @throws UnsupportedEncodingException
* @throws DocumentException
*/
public static Map<String, String> xmlToMap(String xml, String charset) throws UnsupportedEncodingException, DocumentException, DocumentException {
Map<String, String> respMap = new HashMap();
SAXReader reader = new SAXReader();
Document doc = reader.read(new ByteArrayInputStream(xml.getBytes(charset)));
Element root = doc.getRootElement();
xmlToMap(root, respMap);
return respMap;
}
private static Map<String, String> xmlToMap(Element tmpElement, Map<String, String> respMap) {
if (tmpElement.isTextOnly()) {
respMap.put(tmpElement.getName(), tmpElement.getText());
return respMap;
}
@SuppressWarnings("unchecked")
Iterator<Element> eItor = tmpElement.elementIterator();
while (eItor.hasNext()) {
Element element = eItor.next();
xmlToMap(element, respMap);
}
return respMap;
}
/**
* map转换为xml
*
* @param data(只适用简单的map(没有嵌套结构))
* @return
* @throws Exception
*/
public static String mapToXml(Map<String, String> data) throws Exception {
org.w3c.dom.Document document = newDocumentBuilder().newDocument();
org.w3c.dom.Element root = document.createElement("xml");
document.appendChild(root);
Iterator var3 = data.keySet().iterator();
while (var3.hasNext()) {
String key = (String) var3.next();
String value = data.get(key);
if (value == null) {
value = "";
}
value = value.trim();
org.w3c.dom.Element filed = document.createElement(key);
filed.appendChild(document.createTextNode(value));
root.appendChild(filed);
}
TransformerFactory tf = TransformerFactory.newInstance();
Transformer transformer = tf.newTransformer();
DOMSource source = new DOMSource(document);
transformer.setOutputProperty("encoding", "UTF-8");
transformer.setOutputProperty("indent", "yes");
StringWriter writer = new StringWriter();
StreamResult result = new StreamResult(writer);
transformer.transform(source, result);
String output = writer.getBuffer().toString();
try {
writer.close();
} catch (Exception var10) {
}
return output;
}
private static DocumentBuilder newDocumentBuilder() throws ParserConfigurationException {
DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
documentBuilderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
documentBuilderFactory.setFeature("http://xml.org/sax/features/external-general-entities", false);
documentBuilderFactory.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
documentBuilderFactory.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
documentBuilderFactory.setFeature("http://javax.xml.XMLConstants/feature/secure-processing", true);
documentBuilderFactory.setXIncludeAware(false);
documentBuilderFactory.setExpandEntityReferences(false);
return documentBuilderFactory.newDocumentBuilder();
}
public static void main(String[] args) throws Exception {
String s = "<xml>\n" +
"<auth>\n" +
"<randomStr>suiji</randomStr>\n" +
"<token>3ed6b709d31e87af73216149dc510c6fc94975af</token>\n" +
"</auth>\n" +
"</xml>";
System.out.println("------------xmlToMap---------------");
Map<String, String> xmlToMap = xmlToMap(s, "UTF-8");
for (Map.Entry<String, String> entry : xmlToMap.entrySet()) {
String key = entry.getKey();
String value = entry.getValue();
System.out.println("key = " + key + ",value = " + value);
}
System.out.println("------------mapToXml---------------");
String mapToXml = mapToXml(xmlToMap);
System.out.println(mapToXml);
}
}
复杂结构的xml转换为map
public class XmlUtil {
//根节点
private static String rootName = "xml";
//节点没有值的情况下默认值
private static String defaultNullValue = "";
private static Map<String, AtomicInteger> map = new HashMap();
/**
* xml 转换为 map
*
* @param xml
* @return
*/
public static Map<String, Object> parse(String xml) {
Map<String, Object> map = new HashMap();
StringReader stringReader = null;
try {
stringReader = new StringReader(xml);
XMLStreamReader reader = XMLInputFactory.newInstance().createXMLStreamReader(stringReader);
map = doParse(reader);
} catch (Throwable t) {
throw new RuntimeException(t);
} finally {
if (null != stringReader) {
try {
stringReader.close();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
return map;
}
/**
* 真正开始解析转换
* @param reader
* @return
* @throws Throwable
*/
private static Map<String, Object> doParse(XMLStreamReader reader) throws Throwable {
Map<String, Object> map = new HashMap<String, Object>();
Map<String, Object> currentMap = map;
int event = reader.getEventType();
List<String> names = new ArrayList<String>();
int taglength = 0;
String tagName = null;
String tagValue = defaultNullValue;
while (true) {
switch (event) {
case XMLStreamConstants.START_DOCUMENT:
break;
case XMLStreamConstants.START_ELEMENT:
tagValue = defaultNullValue;
tagName = reader.getLocalName();
if (rootName.equals(tagName)) {
break;
}
names.add(tagName);
taglength++;
currentMap = map;
if (taglength > 1) {
for (int i = 0; i < taglength - 1; i++) {
Object object = currentMap.get(names.get(i));
if (null == object) {
object = new HashMap<String, Object>();
currentMap.put(names.get(i), object);
currentMap = (Map<String, Object>) object;
} else {
int currentTagNameSize = getSize(i + 1 + "" + names.get(i));
if (currentTagNameSize > 1) {
if (object instanceof Map) {
List parentList = new ArrayList();
parentList.add(object);
Map tempMap = new HashMap();
parentList.add(tempMap);
currentMap.put(names.get(i), parentList);
currentMap = tempMap;
} else if (object instanceof List) {
List parentList = (List) object;
int parentListSize = parentList.size();
if (parentListSize != currentTagNameSize) {
Map tempMap = new HashMap();
parentList.add(tempMap);
currentMap = tempMap;
} else {
Map tempMap = (Map) parentList.get(parentList.size() - 1);
currentMap = tempMap;
}
}
} else {
currentMap = (Map<String, Object>) object;
}
}
}
}
add(names.size() + tagName);
break;
case XMLStreamConstants.CHARACTERS:
tagValue = reader.getText();
break;
case XMLStreamConstants.END_ELEMENT:
tagName = reader.getLocalName();
if (rootName.equals(tagName)) {
break;
}
currentMap = map;
if (taglength > 1) {
for (int i = 0; i < taglength - 1; i++) {
Object object = currentMap.get(names.get(i));
if (null == object) {
//nothing to do
} else {
if (object instanceof List) {
List list = (List) object;
currentMap = (Map) list.get(list.size() - 1);
} else if (object instanceof Map) {
currentMap = (Map) object;
}
}
}
}
Object oldValue = currentMap.get(tagName);
if (!currentMap.containsKey(tagName)) {
currentMap.put(tagName, tagValue);
remove(names.size() + tagName);
} else {
if (oldValue instanceof List) {
List list = (List) oldValue;
if (list.size() > 0) {
Object obj = list.get(0);
if (obj instanceof String) {
((List) oldValue).add(tagValue);
remove(names.size() + tagName);
}
}
} else if (oldValue instanceof Map) {
} else {
List tmpList = new ArrayList();
currentMap.put(tagName, tmpList);
tmpList.add(oldValue);
tmpList.add(tagValue);
remove(names.size() + tagName);
}
}
tagValue = defaultNullValue;
names.remove(names.size() - 1);
taglength--;
break;
case XMLStreamConstants.END_DOCUMENT:
break;
}
if (!reader.hasNext()) {
break;
}
event = reader.next();
}
return map;
}
private static void add(String nodeName) {
AtomicInteger integer = map.get(nodeName);
if (null == integer) {
integer = new AtomicInteger(0);
map.put(nodeName, integer);
}
integer.incrementAndGet();
}
private static void remove(String nodeName) {
AtomicInteger integer = map.get(nodeName);
if (null != integer) {
integer.decrementAndGet();
}
}
private static int getSize(String nodeName) {
AtomicInteger integer = map.get(nodeName);
if (null == integer) {
integer = new AtomicInteger(0);
map.put(nodeName, integer);
}
return integer.intValue();
}
public static void main(String[] args) {
String str = "<xml>\n" +
"<auth>\n" +
"<randomStr>suiji</randomStr>\n" +
"<token>3ed6b709d31e87af73216149dc510c6fc94975af</token>\n" +
"</auth>\n" +
"<datas>\n" +
"<dataStatus>\n" +
"<errorCode>0</errorCode>\n" +
"<errormsg>发送成功</errormsg>\n" +
"<seqId>1</seqId>\n" +
"<lastModifyTime>2018-07-26 11:01:38</lastModifyTime>\n" +
"</dataStatus>\n" +
"<dataStatus>\n" +
"<errorCode>1</errorCode>\n" +
"<errormsg>发送失败,手机号为空</errormsg>\n" +
"<seqId>2</seqId>\n" +
"<lastModifyTime>2018-07-26 11:02:38</lastModifyTime>\n" +
"</dataStatus>\n" +
"</datas>\n" +
"</xml>";
Map<String, Object> parse = XMLParserStaxUtil.parse(str);
System.out.println(parse);
}
}
Spring中设置返回 xml格式
@RequestMapping(value = "/updateSmsStatus", produces = {"application/xml;charset=UTF-8"})
public SmsInfoVo getSMSInfo(String xmlParam) throws Exception {
//或者
@RequestMapping(value = "/updateSmsStatus", produces = MediaType.APPLICATION_XML_VALUE)
public SmsInfoVo getSMSInfo(String xmlParam) throws Exception {
//可配合使用该@XmlRootElement(name = "xml"),设置根节点名称,字节点无法使用
//这里是使用对象的属性名和xml的节点名称对象,比如 SmsVo result 对应 <result></result>
//第一层
@XmlRootElement(name = "xml")
public class SmsInfoVo {
private SmsVo result;
}
//第二层
public class SmsVo {
private Integer errorCode;
private String errorMsg;
private String constantIdent;
private SmsDataVos datalist;
}
//第三层
public class SmsDataVos {
private List<SmsDataVo> smsDatas;
}
//第四层
public class SmsDataVo {
private String seqId;
private String phoneNum;
private String msg;
}
//最终的结果为:
<xml>
<result>
<constantIdent>CLS01001</constantIdent>
<datalist>
<smsDatas>
<msg>3</msg>
<phoneNum>3</phoneNum>
<seqId>3</seqId>
</smsDatas>
<smsDatas>
<msg>4</msg>
<phoneNum>4</phoneNum>
<seqId>4</seqId>
</smsDatas>
</datalist>
<errorCode>0</errorCode>
<errorMsg>认证成功</errorMsg>
</result>
</xml>