前言：对于服务器后端开发，接口返回的数据格式一般要求都是json，但是也有使用xml格式
RequestBody注解
对于SpringMVC，很多人会认为接口方法使用@Controller搭配@ResponseBody和@RequestMapping注解后，java对象会转换成json格式返回。
但实际上配合@ResponseBody注解后，接口返回的数据类型是根据HTTP Request Header中的Accept属性来确定的，可以是XML或者JSON数据
通过适当的HttpMessageConverter对java对象进行格式转换，常用的有:
ByteArrayHttpMessageConverter
负责读取二进制格式的数据和写出二进制格式的数据；
StringHttpMessageConverter
负责读取字符串格式的数据和写出二进制格式的数据；
ResourceHttpMessageConverter
负责读取资源文件和写出资源文件数据；
FormHttpMessageConverter
负责读取form提交的数据；
MappingJacksonHttpMessageConverter
负责读取和写入json格式的数据；
SouceHttpMessageConverter
负责读取和写入 xml 中javax.xml.transform.Source定义的数据；
Jaxb2RootElementHttpMessageConverter
负责读取和写入xml 标签格式的数据；
AtomFeedHttpMessageConverter
负责读取和写入Atom格式的数据；
RssChannelHttpMessageConverter
负责读取和写入RSS格式的数据
具体使用哪个怎么判断这里就不细讲了，我们关心的是Jaxb2RootElementHttpMessageConverter这个方法，后面会讲为啥会提
java对象与xml之间互相转换
使用Java自带注解的方式实现(@XmlRootElement，@XmlAccessorType，@XmlElement，@XmlAttribute)，具体使用方法网上有很多
这里直接代码举例
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
@XmlRootElement(name = "city")
@XmlType(propOrder = { "name","province"})
public class City {
private String name;
private String province;
public City() {
}
public City(String name, String province) {
this.name = name;
this.province = province;
}
public String getName() {
return name;
}
@XmlElement
public void setName(String name) {
this.name = name;
}
public String getProvince() {
return province;
}
@XmlElement
public void setProvince(String province) {
this.province = province;
}
}
controller
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
public class IndexController {
@RequestMapping(path = "/get")
@ResponseBody
public City getXml(){
City city= new City("太原","山西");
return city;
}
}请求http://localhost:8080/get 返回结果如下
是不很容易就实现接口返回xml格式
使用
对象属性中有可能存在计算逻辑'',而在xml文件中这两个符号是不合法的,会转换为<和>,这样数据就'坏'了,所以的加入是非常有必要的!
一般实现：使用XmlAdapter定义一个CDataAdapter类，网上也有很多代码
大概的实现如下
public class CDataAdapter extends XmlAdapter {
@Override
public String unmarshal(String v) throws Exception {
// 我们这里没有xml转java对象，这里就不具体实现了
return v;
}
@Override
public String marshal(String v) throws Exception {
return new StringBuilder("").toString();
}
}
然后使用注解XmlJavaTypeAdapter作用于属性变量上
@XmlJavaTypeAdapter(value=CDataAdapter.class)
@XmlElement
public void setProvince(String province) {
this.province = province;
}结果
但是实际上看源码
这个不是我们希望的，产生原因是Jaxb默认会把字符''进行转义, 下面解决这个问题
我们使用org.eclipse.persistence.oxm.annotations.XmlCDATA注解来解决
使用EclipseLink JAXB (MOXy)
pom文件增加
org.eclipse.persistence
org.eclipse.persistence.moxy
xx版本
上一节中的属性使用注解
...
import org.eclipse.persistence.oxm.annotations.XmlCDATA;
...
...
@XmlCDATA
@XmlElement
public void setProvince(String province) {
this.province = province;
}注意：一定要设置jaxb.properties文件，并且要放在要转换成xml的java对象所在目录，并且要编译到target中，不然XmlCDATA注解不生效
jaxb.properties文件内容，就是指定创建JAXBContext对象的工长
javax.xml.bind.context.factory=org.eclipse.persistence.jaxb.JAXBContextFactory
到这里配置完成！
补充知识：Java Document生成和解析XML
一)Document介绍
API来源：在JDK中javax.xml.*包下
使用场景：
1、需要知道XML文档所有结构
2、需要把文档一些元素排序
3、文档中的信息被多次使用的情况
优势：由于Document是java中自带的解析器，兼容性强
缺点：由于Document是一次性加载文档信息，如果文档太大，加载耗时长，不太适用
二)Document生成XML
实现步骤：
第一步：初始化一个XML解析工厂
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
第二步：创建一个DocumentBuilder实例
DocumentBuilder builder = factory.newDocumentBuilder();
第三步：构建一个Document实例
Document doc = builder.newDocument();
doc.setXmlStandalone(true);
standalone用来表示该文件是否呼叫其它外部的文件。若值是 ”yes” 表示没有呼叫外部文件
第四步：创建一个根节点，名称为root，并设置一些基本属性
Element element = doc.createElement("root");
element.setAttribute("attr", "root");//设置节点属性
childTwoTwo.setTextContent("root attr");//设置标签之间的内容
第五步：把节点添加到Document中，再创建一些子节点加入
doc.appendChild(element);
第六步：把构造的XML结构，写入到具体的文件中
实现源码：
package com.oysept.xml;
import java.io.File;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
/**
* Document生成XML
* @author ouyangjun
*/
public class CreateDocument {
public static void main(String[] args) {
// 执行Document生成XML方法
createDocument(new File("E:\\person.xml"));
}
public static void createDocument(File file) {
try {
// 初始化一个XML解析工厂
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
// 创建一个DocumentBuilder实例
DocumentBuilder builder = factory.newDocumentBuilder();
// 构建一个Document实例
Document doc = builder.newDocument();
doc.setXmlStandalone(true);
// standalone用来表示该文件是否呼叫其它外部的文件。若值是 ”yes” 表示没有呼叫外部文件
// 创建一个根节点
// 说明: doc.createElement("元素名")、element.setAttribute("属性名","属性值")、element.setTextContent("标签间内容")
Element element = doc.createElement("root");
element.setAttribute("attr", "root");
// 创建根节点第一个子节点
Element elementChildOne = doc.createElement("person");
elementChildOne.setAttribute("attr", "personOne");
element.appendChild(elementChildOne);
// 第一个子节点的第一个子节点
Element childOneOne = doc.createElement("people");
childOneOne.setAttribute("attr", "peopleOne");
childOneOne.setTextContent("attr peopleOne");
elementChildOne.appendChild(childOneOne);
// 第一个子节点的第二个子节点
Element childOneTwo = doc.createElement("people");
childOneTwo.setAttribute("attr", "peopleTwo");
childOneTwo.setTextContent("attr peopleTwo");
elementChildOne.appendChild(childOneTwo);
// 创建根节点第二个子节点
Element elementChildTwo = doc.createElement("person");
elementChildTwo.setAttribute("attr", "personTwo");
element.appendChild(elementChildTwo);
// 第二个子节点的第一个子节点
Element childTwoOne = doc.createElement("people");
childTwoOne.setAttribute("attr", "peopleOne");
childTwoOne.setTextContent("attr peopleOne");
elementChildTwo.appendChild(childTwoOne);
// 第二个子节点的第二个子节点
Element childTwoTwo = doc.createElement("people");
childTwoTwo.setAttribute("attr", "peopleTwo");
childTwoTwo.setTextContent("attr peopleTwo");
elementChildTwo.appendChild(childTwoTwo);
// 添加根节点
doc.appendChild(element);
// 把构造的XML结构，写入到具体的文件中
TransformerFactory formerFactory=TransformerFactory.newInstance();
Transformer transformer=formerFactory.newTransformer();
// 换行
transformer.setOutputProperty(OutputKeys.INDENT, "YES");
// 文档字符编码
transformer.setOutputProperty(OutputKeys.ENCODING, "utf-8");
// 可随意指定文件的后缀,效果一样,但xml比较好解析,比如: E:\\person.txt等
transformer.transform(new DOMSource(doc),new StreamResult(file));
System.out.println("XML CreateDocument success!");
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (TransformerConfigurationException e) {
e.printStackTrace();
} catch (TransformerException e) {
e.printStackTrace();
}
}
}XML文件效果图：
三)Document解析XML
实现步骤：
第一步：先获取需要解析的文件，判断文件是否已经存在或有效
第二步：初始化一个XML解析工厂
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
第三步：创建一个DocumentBuilder实例
DocumentBuilder builder = factory.newDocumentBuilder();
第四步：创建一个解析XML的Document实例
Document doc = builder.parse(file);
第五步：先获取根节点的信息，然后根据根节点递归一层层解析XML
实现源码：
package com.oysept.xml;
import java.io.File;
import java.io.IOException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Attr;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
/**
* Document解析XML
* @author ouyangjun
*/
public class ParseDocument {
public static void main(String[] args){
File file = new File("E:\\person.xml");
if (!file.exists()) {
System.out.println("xml文件不存在,请确认!");
} else {
parseDocument(file);
}
}
public static void parseDocument(File file) {
try{
// 初始化一个XML解析工厂
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
// 创建一个DocumentBuilder实例
DocumentBuilder builder = factory.newDocumentBuilder();
// 创建一个解析XML的Document实例
Document doc = builder.parse(file);
// 获取根节点名称
String rootName = doc.getDocumentElement().getTagName();
System.out.println("根节点: " + rootName);
System.out.println("递归解析--------------begin------------------");
// 递归解析Element
Element element = doc.getDocumentElement();
parseElement(element);
System.out.println("递归解析--------------end------------------");
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
// 递归方法
public static void parseElement(Element element) {
System.out.print("
NamedNodeMap attris = element.getAttributes();
for (int i = 0; i < attris.getLength(); i++) {
Attr attr = (Attr) attris.item(i);
System.out.print(" " + attr.getName() + "=\"" + attr.getValue() + "\"");
}
System.out.println(">");
NodeList nodeList = element.getChildNodes();
Node childNode;
for (int temp = 0; temp < nodeList.getLength(); temp++) {
childNode = nodeList.item(temp);
// 判断是否属于节点
if (childNode.getNodeType() == Node.ELEMENT_NODE) {
// 判断是否还有子节点
if(childNode.hasChildNodes()){
parseElement((Element) childNode);
} else if (childNode.getNodeType() != Node.COMMENT_NODE) {
System.out.print(childNode.getTextContent());
}
}
}
System.out.println("" + element.getTagName() + ">");
}
}XML解析效果图：
