XML作为老牌的数据传输格式，在项目开发中，对接老系统，比如SAP、航信的发票平台等需要使用XML进行交互。
解析或生成XML方式有以下几种：

  1. Java自带解析：
    1. Dom：生成一个文档对象
    2. XPath：可以直接定位到某个标签
    3. SAX:通过回调方法的方式解析
  2. JavaEE的JAXB ： 极其好用
  3. 三方类库
    1. Dom4j
    2. XStream
    3. jackson-xml：基于JAXB

      1.JAXB方式解析

      JAXB解析XML的主要方式就是给类加注解即可，所以我们就说一下有哪些注解以及其含义。
      https://blog.csdn.net/wn084/article/details/80853587 （参考）
      实验的工具类代码 ```java

public class XMLUtil {

  1. /**
  2.  * 将XML字符串转换为相应对象
  3.  *
  4.  * @param clazz 转换类型字节码
  5.  * @param xmlStr xml字符串
  6.  * @return
  7.  */
  8. @SuppressWarnings("unchecked")
  9. public static Object convertXmlStrToObject(Class clazz, String xmlStr) {
  10.     Object xmlObject = null;
  11.     try {
  12.         JAXBContext context = JAXBContext.newInstance(clazz);
  13.         // 进行将Xml转成对象的核心接口
  14.         Unmarshaller unmarshaller = context.createUnmarshaller();
  15.         StringReader sr = new StringReader(xmlStr);
  16.         SAXParserFactory sax = SAXParserFactory.newInstance();
  17.         sax.setNamespaceAware(false);
  18.         XMLReader xmlReader = sax.newSAXParser().getXMLReader();
  19.         Source source = new SAXSource(xmlReader, new InputSource(sr));
  20.         xmlObject = unmarshaller.unmarshal(source);
  21.     } catch (Exception e) {
  22.         e.printStackTrace();
  23.     }
  24.     return xmlObject;
  25. }
  28. /**
  29.  * 将对象直接转换成String类型的 XML输出
  30.  *
  31.  * @param obj
  32.  * @return
  33.  */
  34. public static String convertToXml(Object obj) {
  35.     // 创建输出流
  36.     StringWriter sw = new StringWriter();
  37.     try {
  38.         // 利用jdk中自带的转换类实现
  39.         JAXBContext context = JAXBContext.newInstance(obj.getClass());
  40.         Marshaller marshaller = context.createMarshaller();
  41.         //去除<xml ...>
  42.         marshaller.setProperty(Marshaller.JAXB_FRAGMENT, Boolean.TRUE);
  43.         // 格式化xml输出的格式
  44.         marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
  45.         // marshaller.setProperty("com.sun.xml.bind.xmlDeclaration", Boolean.FALSE);
  46.         marshaller.setProperty("com.sun.xml.internal.bind.marshaller.CharacterEscapeHandler",
  47.             new CharacterEscapeHandler() {
  48.                 @Override
  49.                 public void escape(char[] ch, int start,
  50.                                    int length, boolean isAttVal,
  51.                                    Writer writer) throws IOException {
  52.                     writer.write(ch, start, length);
  53.                 }
  54.             });
  57.         // 将对象转换成输出流形式的xml
  58.         marshaller.marshal(obj, sw);
  59.     } catch (JAXBException e) {
  60.         e.printStackTrace();
  61.     }
  62.     return sw.toString();
  63. }

}

  4. <a name="X0dFI"></a>
  5. ## 1.1@XmlRootElement
  7.    - 属性：name="根标签名称" ,namespace="命名空间url"
  8.    - 位置：标注在XML根节点映射的类上且必须
  9.    - name若不填默认为类名首字母小写，如`ClassInfo`->` <classInfo></classInfo>`
  11. ```xml
  12. <?xml version="1.0" encoding="utf-8"?>
  14. <Class> 
  15.   <id>1</id>  
  16.   <name>CS科班</name>  
  17.   <stuInfo size="3"> 
  18.     <stu> 
  19.       <id>0001</id>  
  20.       <name>李四</name> 
  21.     </stu>  
  22.     <stu> 
  23.       <id>0002</id>  
  24.       <name>张已</name> 
  25.     </stu>  
  26.     <stu> 
  27.       <id>0003</id>  
  28.       <name>王强</name> 
  29.     </stu> 
  30.   </stuInfo> 
  31. </Class>
  1. @Data
  2. //若不指定，默认为类名首字母小写
  3. @XmlRootElement(name = "Class")
  4. public class ClassInfo {
  5.     //.....
  7. }

1.2@XmlAccessorType

  • 属性：XmlAccessType枚举类，默认值为XmlAccessType.PUBLIC_MEMBER
    • XmlAccessType.PROPERTY
      • 会将生成了setter/getter方法的字段自动映射到xml中。
      • 如果不希望映射某个字段 ，需要在字段的stter或getter方法上加上@XmlTransient。
      • 不存在setter/getter方法的字段，可以通过@XmlElement注解来将其映射为xml标签
      • 千万不要在已经存在stter/getter字段上添加@XmlElement注解，会报异常。
    • XmlAccessType.FIELD
      • 会将非static、非transient字段自动映射为xml字段（即使没有setter/getter方法）
      • 如果希望让static或transient字段映射到xml字段中，需要在字段上添加@XmlElement注解
      • 允许在已经默认被映射的字段上添加@XmlElement注解
    • XmlAccessType.PUBLIC_MEMBER（默认）
      • 会将public的字段，或生成public的setter、getter方法的字段 自动映射xml
      • 切记，不可以出现，字段是public，且getter、setter方法也是public的情况
    • XmlAccessType.NONE
      • 所有的字段均不自动映射为xml字段，除非使用@XmlElement注解

  • 位置：标识在类上，这个不限制是否为xml的更节点，只要是映射到xml的类都可以，且需要指定。 ```java @Data @XmlRootElement @XmlAccessorType(XmlAccessType.NONE) public class User {

    @XmlElement private String name=”gaoxi”;

  1. @XmlElement
  2. private String value ="111";

}

  1. 个人感觉还是，手动在字段上加入注解更靠谱一点。
  2. <a name="zXIob"></a>
  3. ## 1.3@XmlAccessorOrder
  5.    - 属性：XmlAccessOrder枚举类，默认是XmlAccessOrder.UNDEFINED
  6.       - **XmlAccessOrder.UNDEFINED**：不定义，按照类中字段的顺序
  7.       - **XmlAccessOrder.ALPHABETICAL**：按照字典序排列
  8.    - 位置：所有映射为XML的类上
  9. <a name="jaWmm"></a>
  10. ## 1.4@XmlType
  11. `@XmlType`目前我知道用法是可以指定生成xml标签的顺序，当和`@XmlAccessorOrder`同时出现后，已这个为准。<br />使用方法：
  12. ```java
  13. @Data
  14. @XmlRootElement
  15. @XmlAccessorType(XmlAccessType.NONE)
  16. @XmlAccessorOrder(XmlAccessOrder.ALPHABETICAL)
  17. //同时出现以@XmlType为准
  18. @XmlType(propOrder = {
  19.   "value" , "name"
  20. })
  21. public class User {
  22.     @XmlElement
  23.     private String value ="111";
  24.     @XmlElement
  25.     private String name="gaoxi";
  26. }

1.5@XmlElement

  • 属性：name标签名 namespace：标签使用的命名空间
  • 位置：字段、setter、getter方法上。
  • 举一个namespace的使用方式：
    1. <user xmlns:ns2="http://www.baidu.com/schema">
    2. <ns2:value>111</ns2:value>
    3. <name>gaoxi</name>
    4. </user>
    ```java @Data @XmlRootElement @XmlAccessorType(XmlAccessType.NONE) @XmlAccessorOrder(XmlAccessOrder.ALPHABETICAL) //同时出现以@XmlType为准 @XmlType(propOrder = { “value” , “name” }) public class User { @XmlElement(name=”value”,namespace = “http://www.baidu.com/schema“) private String value =”111”; @XmlElement private String name=”gaoxi”;

}

  1. 关注name标签，自己体会。。。
  2. <a name="xMXNU"></a>
  3. ## <br />1.6@XmlAttribute
  4. 指定属性
  5. ```xml
  6. <user color="Red">
  7.     <value>111</value>
  8.     <name>gaoxi</name>
  9. </user>
  2. @Data
  3. @XmlRootElement
  4. @XmlAccessorType(XmlAccessType.NONE)
  5. @XmlAccessorOrder(XmlAccessOrder.ALPHABETICAL)
  6. //同时出现以@XmlType为准
  7. @XmlType(propOrder = {
  8.   "value" , "name"
  9. })
  10. public class User {
  13.     @XmlAttribute
  14.     private String color ="Red";
  16.     @XmlElement
  17.     private String value ="111";
  18.     @XmlElement
  19.     private String name="gaoxi";
  22. }

1.7@XmlTransient

指定字段不被映射

1.8@XmlValue

这个解决的问题就是遇到如下标签
<id size="1">000010001</id>
这必须要封装一个对象，但是里面的value值0000100001如何取出来呢？

  1. <user color="Red">
  2.     <id size="1">000010001</id>
  3.     <name>gaoxi</name>
  4.     <value>111</value>
  5. </user>
  2. @Data
  3. @XmlRootElement
  4. @XmlAccessorType(XmlAccessType.NONE)
  5. @XmlAccessorOrder(XmlAccessOrder.ALPHABETICAL)
  6. //同时出现以@XmlType为准
  7. /*@XmlType(propOrder = {
  8.   "value" , "name"
  9. })*/
  10. public class User {
  13.     @XmlAttribute
  14.     private String color ="Red";
  16.     @XmlElement
  17.     private String value ="111";
  18.     @XmlElement
  19.     private String name="gaoxi";
  21.     @XmlElement
  22.     private IdEntity id = new IdEntity();
  25. }
  26. //============================================
  28. @Data
  29. @XmlAccessorType(XmlAccessType.NONE)
  30. public class IdEntity {
  32.     @XmlAttribute
  33.     private String size ="1";
  35.     @XmlValue
  36.     private String idValue="000010001";
  38. }

1.9@XmlElementWrapper

用于List属性上

  • 加@XmlElementWrapper()的使用 ```java 1 CS科班 2 高溪 3 高吸

@Data @XmlRootElement(name = “Class”) @XmlAccessorType(XmlAccessType.NONE) public class ClassInfo {

  1. @XmlElement(name = "id")
  2. private String id;
  4. @XmlElement(name = "name")
  5. private String name;
  7. @XmlElement(name = "teach")
  8. private Teacher teacher;
  11. @XmlElementWrapper(name = "sutInfo")
  12. @XmlElement(name = "stu")
  13. private List<Student> stu;
  15. public ClassInfo() {
  16. }
  18. public ClassInfo(String id, String name) {
  19.     this.id = id;
  20.     this.name = name;
  21. }

}

  2.    - 不加@XmlElement
  3. ```java
  4. <Class>
  5.     <id>1</id>
  6.     <name>CS科班</name>
  7.     <stu>
  8.         <id>2</id>
  9.         <name>高溪</name>
  10.     </stu>
  11.     <stu>
  12.         <id>3</id>
  13.         <name>高吸</name>
  14.     </stu>
  15. </Class>
  17. @Data
  18. @XmlRootElement(name = "Class")
  19. @XmlAccessorType(XmlAccessType.NONE)
  20. public class ClassInfo {
  22.     @XmlElement(name = "id")
  23.     private String id;
  25.     @XmlElement(name = "name")
  26.     private String name;
  28.     @XmlElement(name = "teach")
  29.     private Teacher teacher;
  32.     @XmlElement(name = "stu")
  33.     private List<Student> stu;
  34. }

@XmlElementWrapper的左右就是为List包一层标签。

1.10@XmlJavaTypeAdapter

这个标签用于为某个字段添加CDATA标签

  1. public class AdapterCdata extends XmlAdapter<String, String> {
  3.     @Override
  4.     public String marshal(String arg0) throws Exception {
  5.         return "<![CDATA[" + arg0 + "]]>";
  6.     }
  8.     @Override
  9.     public String unmarshal(String arg0) throws Exception {
  10.         return arg0;
  11.     }
  13. }
  16. @Data
  17. @XmlRootElement
  18. @XmlAccessorType(XmlAccessType.NONE)
  19. @XmlAccessorOrder(XmlAccessOrder.ALPHABETICAL)
  20. public class User {
  22.     @XmlElement
  23.     @XmlJavaTypeAdapter(AdapterCdata.class)
  24.     private String value ="高溪--》";
  26. }

2.Jackson的Xml解析

Jackson有个ObjectMapper，我们使用它进行JSON和对象之间的转换。其实Jackson还有一个用于Xml与对象的转换。底层好像也是引用了Jaxb。
使用方式也是学习相关的注解。

2.1实例化一个XmlMapper

  1. 依赖导入

    1.   <!--特意贴出这个依赖是因为，这个包里有jackson-core包，如果不是springboot环境需要额外引入-->
    2.           <dependency>
    3.       <groupId>org.springframework.boot</groupId>
    4.       <artifactId>spring-boot-starter-web</artifactId>
    5.   </dependency>
    7.   <dependency>
    8.       <groupId>com.fasterxml.jackson.dataformat</groupId>
    9.       <artifactId>jackson-dataformat-xml</artifactId>
    10.   </dependency>

  2. 实例化（http://www.felord.cn/java-jackson-xml-json.html）

    1. XmlMapper xmlMapper = XmlMapper.builder()
    2.            // 忽略实体类没有对应属性    如果为 true 会抛出异常
    3.           .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,false)
    4.           // 忽略null
    5.           .serializationInclusion(JsonInclude.Include.NON_NULL)
    6.           // 属性使用 驼峰首字母小写
    7.           .propertyNamingStrategy(PropertyNamingStrategy.LOWER_CAMEL_CASE)
    8.           .build();

    2.2@JacksonXmlRootElement

    等价于Jaxb中@XmlRootElement，但是在这里，这个注解不是必须。

    1. @Data
    2. @JacksonXmlRootElement(localName = "myUser")
    3. public class User {
    4. private String name;
    5. private String value;
    6. }

    2.3@JacksonXmlProperty

    这个注解是Jaxb中@XmlElement和@XmlAttribute注解的组合，非必须加上注解，模式使用字段名，可以通过配置XmlMapper，指定生成标签名的规则。

  • 实例 ```xml gaoxi

@Data @JacksonXmlRootElement(localName = “myUser”) public class User { @JacksonXmlProperty(isAttribute = false, localName = “name”) private String name = “gaoxi”; @JacksonXmlProperty(isAttribute = true, localName = “value”) private String value = “2”; }

  1. 需要映射为XML标签的字段需要满足下列条件之一
  3.    - 在字段上添加@JacksonXmlProperty注解
  4.    - 字段由setter，getter方法
  5. <a name="OQpzY"></a>
  6. ## 2.4@JacksonXmlCData
  7. 给字段加CDATA
  8. ```xml
  9. <myUser value="2">
  10.       <name><![CDATA[gaoxi]]></name>
  11. </myUser>
  13. @JacksonXmlRootElement(localName = "myUser")
  14. public class User {
  15.     @JacksonXmlCData
  16.     @JacksonXmlProperty(isAttribute = false, localName = "name")
  17.     private String name = "gaoxi";
  18.     @JacksonXmlProperty(isAttribute = true, localName = "value")
  19.     private String value = "2";
  21. }

2.5@JacksonXmlText

等价于@XmlValue注解的用法

  1. <myUser value="2">
  2.   <id size="4">0001</id>
  3.   <name><![CDATA[gaoxi]]></name>
  4. </myUser>
  7. @JacksonXmlRootElement(localName = "myUser")
  8. public class User {
  9.     @JacksonXmlCData
  10.     @JacksonXmlProperty(isAttribute = false, localName = "name")
  11.     private String name = "gaoxi";
  12.     @JacksonXmlProperty(isAttribute = true, localName = "value")
  13.     private String value = "2";
  14.     @JacksonXmlProperty
  15.     private IdEntity id = new IdEntity();
  16. }
  18. @Data
  19. public class IdEntity {
  20.     @JacksonXmlProperty(isAttribute = true)
  21.     private String size = "4";
  22.     @JacksonXmlText
  23.     private String value="0001";
  25. }

2.6@JacksonXmlElementWrapper

等价于@``XmlElementWrapper的用法，但是对于List来说，Jackson默认包裹。

  • 有包裹 ```xml sing dance basketball

@JacksonXmlRootElement(localName = “myUser”) public class User { @JacksonXmlElementWrapper(localName = “hobbies”) @JacksonXmlProperty private List hobby = Arrays.asList(“sing”,”dance”,”basketball”); }

  2.    - 默认包裹（）
  3. ```xml
  4. <myUser>
  5.   <hobby>
  6.     <hobby>sing</hobby>
  7.     <hobby>dance</hobby>
  8.     <hobby>basketball</hobby>
  9.   </hobby>
  10. </myUser>
  12. @JacksonXmlRootElement(localName = "myUser")
  13. public class User {
  14.     @JacksonXmlProperty
  15.     private List<String> hobby = Arrays.asList("sing","dance","basketball");
  16. }
  • 去除默认包裹 ```xml sing dance basketball

@JacksonXmlRootElement(localName = “myUser”) public class User { @JacksonXmlElementWrapper(useWrapping = false) @JacksonXmlProperty private List hobby = Arrays.asList(“sing”,”dance”,”basketball”); }

```

3.注意点

1.JAXB中标签的namespace指定的是url地址
2.Jackson中标签namespace可以指定别名 （${别名}:{标签名}）

4.总结

JAXB是JavaEE的规范，其使用起来也是相当顺手，Jackson-Xml操作更加的贴近用户，只保留几个最实用的注解（也足够使用了）。Jacson的CDATA用起来比Jaxb顺手。其他方面半斤八两。推荐使用Jackson