1.定义介绍
 
(1).XML定义
 
        扩展标记语言 (Extensible Markup Language, XML) ，用于标记电子文件使其具有结构性的标记语言，可以用来标记数据、定义数据类型，是一种允许用户对自己的标记语言进行定义的源语言。 XML使用DTD(document type definition)文档类型定义来组织数据;格式统一，跨平台和语言，早已成为业界公认的标准。
 
        XML是标准通用标记语言 (SGML) 的子集，非常适合 Web 传输。XML 提供统一的方法来描述和交换独立于应用程序或供应商的结构化数据。
 
(2).JSON定义
 
        JSON(JavaScript Object Notation)一种轻量级的数据交换格式，具有良好的可读和便于快速编写的特性。可在不同平台之间进行数据交换。JSON采用兼容性很高的、完全独立于语言文本格式，同时也具备类似于C语言的习惯(包括C, C++, C#, Java, JavaScript, Perl, Python等)体系的行为。这些特性使JSON成为理想的数据交换语言。
 
        JSON基于JavaScript Programming Language , Standard ECMA-262 3rd Edition - December 1999 的一个子集。
 
 
 
2.XML和JSON优缺点
 
(1).XML的优缺点
 
<1>.XML的优点
 
　　A.格式统一，符合标准；
 
　　B.容易与其他系统进行远程交互，数据共享比较方便。
 
<2>.XML的缺点
 
　　A.XML文件庞大，文件格式复杂，传输占带宽；
 
　　B.服务器端和客户端都需要花费大量代码来解析XML，导致服务器端和客户端代码变得异常复杂且不易维护；
 
　　C.客户端不同浏览器之间解析XML的方式不一致，需要重复编写很多代码；
 
　　D.服务器端和客户端解析XML花费较多的资源和时间。
 
(2).JSON的优缺点
 
<1>.JSON的优点：
 
　　A.数据格式比较简单，易于读写，格式都是压缩的，占用带宽小；
 
　　B.易于解析，客户端JavaScript可以简单的通过eval()进行JSON数据的读取；
 
　　C.支持多种语言，包括ActionScript, C, C#, ColdFusion, Java, JavaScript, Perl, PHP, Python, Ruby等服务器端语言，便于服务器端的解析；
 
　　D.在PHP世界，已经有PHP-JSON和JSON-PHP出现了，偏于PHP序列化后的程序直接调用，PHP服务器端的对象、数组等能直接生成JSON格式，便于客户端的访问提取；
 
　　E.因为JSON格式能直接为服务器端代码使用，大大简化了服务器端和客户端的代码开发量，且完成任务不变，并且易于维护。
 
<2>.JSON的缺点
 
　　A.没有XML格式这么推广的深入人心和喜用广泛，没有XML那么通用性；
 
　　B.JSON格式目前在Web Service中推广还属于初级阶段。
 
 
 
3.XML和JSON的优缺点对比
 
(1).可读性方面。
 
        JSON和XML的数据可读性基本相同，JSON和XML的可读性可谓不相上下，一边是建议的语法，一边是规范的标签形式，XML可读性较好些。
 
(2).可扩展性方面。
 
        XML天生有很好的扩展性，JSON当然也有，没有什么是XML能扩展，JSON不能的。
 
(3).编码难度方面。
 
        XML有丰富的编码工具，比如Dom4j、JDom等，JSON也有json.org提供的工具，但是JSON的编码明显比XML容易许多，即使不借助工具也能写出JSON的代码，可是要写好XML就不太容易了。
 
(4).解码难度方面。
 
        XML的解析得考虑子节点父节点，让人头昏眼花，而JSON的解析难度几乎为0。这一点XML输的真是没话说。
 
(5).流行度方面。
 
        XML已经被业界广泛的使用，而JSON才刚刚开始，但是在Ajax这个特定的领域，未来的发展一定是XML让位于JSON。到时Ajax应该变成Ajaj(Asynchronous Javascript and JSON)了。
 
(6).解析手段方面。
 
        JSON和XML同样拥有丰富的解析手段。
 
(7).数据体积方面。
 
        JSON相对于XML来讲，数据的体积小，传递的速度更快些。
 
(8).数据交互方面。
 
        JSON与JavaScript的交互更加方便，更容易解析处理，更好的数据交互。
 
(9).数据描述方面。
 
        JSON对数据的描述性比XML较差。
 
(10).传输速度方面。
 
        JSON的速度要远远快于XML。
 
 
 
4.XML与JSON数据格式比较
 
(1).关于轻量级和重量级
 
        轻量级和重量级是相对来说的，那么XML相对于JSON的重量级体现在哪呢?应该体现在解析上，XML目前设计了两种解析方式：DOM和 SAX。
 
<1>.DOM
 
        DOM是把一个数据交换格式XML看成一个DOM对象，需要把XML文件整个读入内存，这一点上JSON和XML的原理是一样的，但是XML要考虑父节点和子节点，这一点上JSON的解析难度要小很多，因为JSON构建于两种结构：key/value，键值对的集合;值的有序集合，可理解为数组；
 
<2>.SAX
 
        SAX不需要整个读入文档就可以对解析出的内容进行处理，是一种逐步解析的方法。程序也可以随时终止解析。这样，一个大的文档就可以逐步的、一点一点的展现出来，所以SAX适合于大规模的解析。这一点，JSON目前是做不到得。
 所以，JSON和XML的轻/重量级的区别在于：
 
       JSON只提供整体解析方案，而这种方法只在解析较少的数据时才能起到良好的效果；
 XML提供了对大规模数据的逐步解析方案，这种方案很适合于对大量数据的处理。
 
(2).关于数据格式编码及解析难度
 
<1>.在编码方面。
 
        虽然XML和JSON都有各自的编码工具，但是JSON的编码要比XML简单，即使不借助工具，也可以写出JSON代码，但要写出好的XML代码就有点困难;与XML一样，JSON也是基于文本的，且它们都使用Unicode编码，且其与数据交换格式XML一样具有可读性。
 
        主观上来看，JSON更为清晰且冗余更少些。JSON网站提供了对JSON语法的严格描述，只是描述较简短。从总体来看，XML比较适合于标记文档，而JSON却更适于进行数据交换处理。
 
<2>.在解析方面。
 
        在普通的web应用领域，开发者经常为XML的解析伤脑筋，无论是服务器端生成或处理XML，还是客户端用 JavaScript 解析XML，都常常导致复杂的代码，极低的开发效率。
 
        实际上，对于大多数Web应用来说，他们根本不需要复杂的XML来传输数据，XML宣称的扩展性在此就很少具有优势,许多Ajax应用甚至直接返回HTML片段来构建动态Web页面。和返回XML并解析它相比，返回HTML片段大大降低了系统的复杂性，但同时缺少了一定的灵活性。同XML或 HTML片段相比，数据交换格式JSON 提供了更好的简单性和灵活性。在Web Serivice应用中，至少就目前来说XML仍有不可动摇的地位。
 
(3).实例比较
 
        XML和JSON都使用结构化方法来标记数据，下面来做一个简单的比较。
 
<1>.用XML表示中国部分省市数据如下：
 
<?xml version="1.0" encoding="utf-8" ?>
<country>
  <name>中国</name>
  <province>
    <name>黑龙江</name>
    <citys>
      <city>哈尔滨</city>
      <city>大庆</city>
    </citys>  　　
  </province>
  <province>
    <name>广东</name>
    <citys>
      <city>广州</city>
      <city>深圳</city>
      <city>珠海</city>
    </citys> 　　
  </province>
  <province>
    <name>台湾</name>
    <citys>
      　<city>台北</city>
      　<city>高雄</city>
    </citys>　
  </province>
  <province>
    <name>新疆</name>
    <citys>
      <city>乌鲁木齐</city>
    </citys>
  </province>
</country>
 
<2>.用JSON表示中国部分省市数据如下：
 
{
    name: "中国",
    provinces: [
        { 
            name: "黑龙江", 
            citys: { 
                city: ["哈尔滨", "大庆"]
            }
        },
        { 
            name: "广东",
            citys: { 
                city: ["广州", "深圳", "珠海"]
            } 
        },
        { 
            name: "台湾",
            citys: { 
                city: ["台北", "高雄"]
            } 
        },
        { 
            name: "新疆", 
            citys: {
                city: ["乌鲁木齐"]
            }
        }
    ]
}
 
 
 
        编码的可读性来说，XML有明显的优势，毕竟人类的语言更贴近这样的说明结构。JSON读起来更像一个数据块，读起来就比较费解了。不过，我们读起来费解的语言，恰恰是适合机器阅读，所以通过JSON的索引country.provinces[0].name就能够读取“黑龙江”这个值。
 
        编码的手写难度来说，XML还是舒服一些，好读当然就好写。不过写出来的字符JSON就明显少很多。去掉空白制表以及换行的话，JSON就是密密麻麻的有用数据，而XML却包含很多重复的标记字符。

一、xml基础详解：
 
1、概述：
 
    xml:即可扩展标记语言，xml是互联网数据传输的重要工具，它可以跨越互联网任何的平台，不受编程语言和操作系统的限制，可以说它是一个拥有互联网最高级别通行证的数据携带者。xml是当前处理结构化文档信息中相当给力的技术，xml有助于在服务器之间穿梭结构化数据，这使得开发人员更加得心应手的控制数据的存储和传输。
 
Xml用于标记电子文件使其具有结构性的标记语言，可以用来标记数据、定义数据类型，是一种允许用户对自己的标记语言进行定义的源语言。Xml是标准通用标记语言（SGML）的子集，非常适合Web传输。XML提供统一的方法来描述和交换独立于应用程序或供应商的结构化数据。
 
2、xml的特点及作用:
 
特点：
 
v xml与操作系统、编程语言的开发平台都无关；
 
v 实现不同系统之间的数据交互。
 
作用：
 
v 配置应用程序和网站；
 
v 数据交互；
 
v Ajax基石。
 
在配置文件里边所有的配置文件都是以XMl的格式来编写的。
 
跨平台进行数据交互，它可以跨操作系统，也可以跨编程语言的平台。
 
Ajax是现在目前比较流行的一个网络交互的技术。Ajax里面最后一个x实际上就是xml的缩写。Xml（Extensible Markup Language）是可扩展标记语言
 
一个xml文档必须要有第一行的声明和它的文档元素的描述信息就可以了。
 
3、xml声明
 
例子：
 
注：xml声明一般是xml文档的第一行；xml声明由以下几个部分组成：
 
4、根元素
 
它是xml文档里面唯一的；它的开始是放在最前面，结束是放在最后面。
 
5、元素：
 
(1) 所有的xml元素都必须有结束标签；
 
(2) xml标签对大小写敏感；
 
(3)  xml必须正确地嵌套；
 
（4）元素的命名规则：
 
名称中可以包含字母、数字或者其他的字符；
 
名称不能以数字或者标点符号开始；
 
名称中不能包含空格。
 
（5）空元素
 
6、属性
 
（1）语法
 
<元素名 属性名=“属性值”/>
 
例：<Student ID=“S100”>
 
       <Name>Tom</Name>
 
</Student>
 
(2)注意：
 
属性值用双引号包裹；一个元素可以有多个属性，它的基本格式为：
 
<元素名 属性名=“属性值” 属性名=“属性值”>;
 
属性值中不能够直接包含<.”,&。
 
7、实体：
 
在xml中，一些字符拥有特殊的意义。如果把字符“<”放在xml元素中，会发生错误，这是因为解析器会把它当作新元素的开始，这样会产生xml错误：
 
为了避免这个错误，请用实体引用来代替“<”字符：
 
xml中5个预定义实体
 
8、注释
 
注:注释内容中不要出现”--”;不要把注释放在标签中间；注释不能嵌套。
 
9、总结：
 
（1）xml描述的是文档的内容与语义，而不是文档应当如何显示；
 
（2）格式正规（well formed）的xml文档
 
遵循如下规则的xml文档称为格式正规的xml文档：
 
v 必须有xml声明语句；
 
v 必须有且仅有一个根元素；
 
v 标签大小写敏感；
 
v 属性值用双引号；
 
v 标签成对；
 
v 空标签关闭；
 
v 元素正确嵌套。
 
(3)有效的（valid）xml文档。首先xml文档是个格式正规的xml文档，然后又需要满足DTD的要求，这样的xml文档称为有效的xml文档；
 
10、解析器
 
11、命名空间
 
11.1、xml命名空间（xml Namespaces）
 
（1）xml命名空间提供避免元素命名冲突的方法。
 
（2）在xml中，元素名称是由开发者定义的，当两个不同的文档使用相同的元素名时，就会发生命名冲突。
 
11.2、xml命名空间示例
 
（1）使用前缀示例
 
与仅仅使用前缀不同，我们为标签添加了一个xmlns属性，这样就为前缀赋予了一个与某个命名空间相关联的限定名称。
 
二、DTD技术——xml文件的验证机制
 
1、DTD概述：
 
文档类型定义——Document Type Definition
 
DTD用来描述xml文档的结构，一个DTD文档包含：  
 
元素的定义规则；元素之间的关系规则；属性的定义规则。
 
2、为什么要用DTD呀
 
v 有了DTD，每个xml文件可以携带一个自身格式的描述,所谓格式描述就是我的xml文档里面可以写哪些东西，比如元素、属性；
 
v 有了DTD，不同组织的人可以使用一个通用DTD用来交换数据，xml是随意定义的，有了DTD，我们可以限制多个公司之间按照这种DTD的规则来编写xml文档，由于DTD都是统一格式，所以不同的公司之间，不同的组织之间就可以用这种通用的xml文档格式进行交互数据了；
 
v 应用程序可以使用一个标准DTD校检从外部接收的xml数据是否有效。
 
3、如何编写一个DTD
 
DTD分成三大类，第一是内部DTD,第二是外部DTD,第三是内外结合的DTD。
 
（1）内部DTD文档(Students.xml)：
 
（2）就是说这个xml文档里面既包含xml定义，又包含DTD的定义。
 
这个[]里面是DTD的定义的内容，就是第一个叫内部DTD文档。
 
（3）外部DTD文档（Students.xml  Students.dtd）:
 
所谓外部就是DTD的定义和我们的xml文档是在不同的文件里面。
 
那么外部的DTD如何使用呢？那就需要在前面的xml文档的根元素的上面这个位置跟刚才内部的是一样的，要写上
 
这类年改革文档在同一个文件夹下面，就可以了。
 
有内部DTD了，为什么还要学习外部DTD呢？？
 
内部的DTD,它只能验证当前的这个xml文档。那假如说，我们有一个DTD需要验证多个xml文档的话，那就直接使用外部DTD就行。
 
（4）内外部DTD文档结合
 
4、DTD的具体定义——元素的定义
 
元素名称：是指xml文档里面的元素名称
 
元素类型：
 
（1）EMPTY
 
示例第一个是对的，第二个是错误的，因为它有内容了。
 
（2）#PCDATA
 
第一个是对的，第二个是错误的。
 
（3）纯元素类型的DTD语法
 
（4）ANY
 
5、定义属性的语法结构
 
xml文档携带数据的方式，不仅仅是xml的元素的内容，还可以是元素的属性。
 
所以说在DTD里面我们有必要对属性进行限制。
 
(1)编写属性验证的语法规则：
 
（2）属性类型——CDATA
 
CDATA是表示属性的值，可以是任何字符，这里包括数字和中文。
 
问题一：属性的CDATA与元素的CDATA节有何区别呢？？
 
属性的CDATA表示属性值是任何的字符，元素里的CDATA节是表示在CDATA节里面的内容不被xml文档进行解析。
 
问题二：#PCDATA与CDATA有何区别？？
 
#PCDATA是限制元素里面的内容是字符类型的，而这个CDATA是限制属性里面的内容是字符类型。
 
（3）属性类型——ID
 
表明该属性的取值必须是唯一的。
 
（4）属性类型——IDREF/IDREFS
 
v IDREF是指它的值要指向文档当中其它地方声明的ID。把IDREF当成数据库的外键，把ID当成主键理解就行；
 
v IDREFS同IDREF，但是可以具有由空格分开的多个引用；
 
（5）属性类型——Enumerated
 
预先定义了一些值，属性的值必须在所列出的值的范围内
 
（6）属性特点——#REQUIRED
 
它表示元素的所有的实例都必须有该属性的值（NOT NULL）
 
(7)属性特点——#IMPLIED
 
这就表示该属性的值是可以被忽略的。
 
（8)属性特点——#FIXED
 
元素中该属性的值必须为指定的固定值。
 
（9）属性特点——Default
 
为属性提供一个默认的值。
 
三、实体
 
1、实体概述
 
实体，简单理解就是C#中的常量，我们在DTD里面定义，在xml文档里面去使用。（实际上就是自定义实体，与前面的预定义实体差不多是一回事）。
 
2、实体的定义
 
四、xml之Schema技术
 
1、Schema概述：xml Schema是用一套预先规定的xml元素和属性创建的，这些元素和属性定义了xml文档的结构和内容模式。Xml Shema规定xml文档实例的结构和每个元素/属性的数据类型。
 
理解：对于Schema来讲，我们可以将shema比喻成为是表结构。在表结构里，定义一些数据的限制要求。然后我们xml文档呢就相当于是数据表将来要存储的数据u，也就是数据库里面的数据表数据了，所以整体来讲的话schema它就是用于验证xml文档的。
 
2、有了DTD，为什么要用Schema呢？
 
（1）DTD的局限性
 
DTD不遵守xml语法（写xml文档实例时用一种语法，写DTD的时候用另外一种语法）；DTD数据类型有限（与数据库数据类型不一致）；DTD不可扩展；DTD不支持命名空间（命名冲突）。
 
（2）Schema的新特性
 
Shema基于xml语法的；Shema可以用能处理xml文档的工具处理；Schema大大扩充了数据类型，可以自定义数据类型；Schema支持元素的继承——Object-Oriented;Shema支持属性组。
 
3、Shema（模式）：其作用与DTD一样，也是用于验证xml文档的有效性，只不过它提供了比DTD更强大的功能和更细粒度的数据类型，另外Schema还可以自定义数据类型。此外，Schema也是一个xml文件，而DTD则不是。
 
4、所有的Schema文档，其根元素必须为Schema。
 
5、Schema的文档结构
 
6、Schema的数据类型
 
6.1、Schema的数据类型概述
 
6.2、简单类型：
 
（1）内置的数据类型：
 
基本的数据类型；
 
扩展的数据类型；
 
（2）用户自定义简单类型（通过simpleType定义）。
 
6.3、复合类型（通过complexType定义）
 
6.4、数据类型的特征
 
7、Schema的元素类型
 
7.1、Schema根元素
 
作用：包含已经定义的Schema
 
用法：<xs:schema>
 
属性：xmlns/targetNamespace/elementFormDefault
 
例子：
 
7.2、element元素
 
作用：声明一个元素
 
属性：name/type/ref/minOccurs/maxOccurs
 
例子：
 
7.3、group元素
 
作用：把一组元素声明组合在一起
 
属性:name
 
例子：
 
7.4、attribute元素
 
作用：声明一个属性
 
属性：name/type/use/default/fixed
 
例子：
 
7.5、attributeGroup元素
 
作用：把一组属性声明组合在一起
 
属性：name/ref
 
例子：
 
7.6、simpleType元素
 
作用：定义一个简单类型，它决定了元素和属性值的约束和相关信息
 
属性：name
 
常用的两种方式：restriction——>一个约束；list——>从列表中选择。
 
（1）simpleType元素的子元素——>restriction
 
子元素为：<xs:restriction>——>定义一个约束条件
 
例子：
 
（2）simpleType元素的子元素——>list
 
子元素为：<xs:list>——>从一个特定数据类型的集合中选择定义一个简单类型元素。
 
例子：
 
7.7、complexType元素
 
作用：定义一个复合类型，它决定了一组元素和属性值的约束和相关信息。
 
属性：name
 
常用的两种方式：sequence——>一个序列；choice——>设置选择项。
 
（1）complexType元素——sequence
 
作用：给一组元素一个特定的序列
 
例子：
 
（2）complexType元素——choice
 
作用：把一组属性声明组合在一起，以便可以被复合类型应用
 
属性：name/ref
 
例子：
 
7.8、complexType与simpleType区别
 
simpleType类型的元素中不能包含元素或者属性；
 
当需要声明一个元素的子元素和或属性时，用complexType；
 
当需要基于内置的基本数据类型定义一个新的数据类型时，用simpleType。
 --------------------- 
 原文：https://blog.csdn.net/com_ma/article/details/73277535 

第一步：说明：
 
   JAXB（Java Architecture for XML Binding) 是一个业界的标准，是一项可以根据XML Schema产生Java类的技术。该过程中，JAXB也提供了将XML实例文档反向生成Java对象树的方法，并能将Java对象树的内容重新写到XML实例文档。从另一方面来讲，JAXB提供了快速而简便的方法将XML模式绑定到Java表示，从而使得Java开发者在Java应用程序中能方便地结合XML数据和处理函数。
  
 
第二步：相关的重要Class、Interface和Annotation
 
    A、JDK中JAXB相关的重要Class和Interface
 
JAXBContext类，是应用的入口，用于管理XML/Java绑定信息。
Marshaller接口，将Java对象序列化为XML数据。
Unmarshaller接口，将XML数据反序列化为Java对象。
   B、 JDK中JAXB相关的重要注解（Annotation）
 
  @XmlRootElement：根节点,将Java类或枚举类型映射到XML元素。
  @XmlAttribute：该属性作为xml的attribute,将Java类的一个属性映射到与属性同名的一个XML元素。
  @XmlElement：该属性作为xml的element，且可以增加属性(name="NewElementName")，那么生成的xml串的elment的标签是NewElementName
@XmlAccessorType(XmlAccessType.PROPERTY)：意思是 只有属性（有get和set方法才是属性，没有get和set方法的不是属性）才能被转换成 xml 中的标签。@XmlAccessorType(XmlAccessType.FIELD) ，控制字段或属性的序列化。FIELD表示JAXB将自动绑定Java类中的每个非静态的（static）、非瞬态的（由@XmlTransient标注）字段到XML。
@XmlAccessorOrder，控制JAXB 绑定类中属性和字段的排序。
@XmlJavaTypeAdapter，使用定制的适配器（即扩展抽象类XmlAdapter并覆盖marshal()和unmarshal()方法），以序列化Java类为XML。
@XmlElementWrapper ，对于数组或集合（即包含多个元素的成员变量），生成一个包装该数组或集合的XML元素（称为包装器）。
@XmlType注解标注xml生成顺序，默认情况下，Jaxb编组出来的xml中的字段顺序是随机的，你可以使用@XmlType的propOrder属性来指定序列化的顺序。
注：
 
1.对于@XmlElementWrapper标注的属性，不能出现在@XmlType的propOrder列表中。
 
2.对于所有@XmlElement标注过的属性，必须出现在@XmlType的propOrder列表中。
 
第三步：使用demo
 
目录结构：
 
 
定义一个User类：
 
package xmlUtil;

import java.io.Serializable;
import java.util.Date;
import java.util.List;

import javax.xml.bind.annotation.*;

/**
 * @Author:         轻狂书生FS
 * @Description:
 * @CreateDate:     2019/3/29 10:04
 * @Version:        1.0
*/
@XmlAccessorType(XmlAccessType.FIELD)
// XML文件中的根标识
@XmlRootElement(name = "User")
public class User implements Serializable {
    private static final long serialVersionUID = 1L;

    @XmlAttribute(name = "xmnl")
    private final String xmnl="www.baidu.com";

    // 用户Id
    @XmlElement(name = "UserId")
    private int userId;
    // 用户名
    @XmlElement(name = "UserName")
    private String userName;
    // 用户密码
    @XmlElement(name = "Password")
    private String password;
    // 用户生日
    @XmlElement(name = "Birthday")
    private Date birthday;
    // 用户钱包
    @XmlElement(name = "Money")
    private double money;
    //用户地址
    @XmlElementWrapper(name = "AddressList")
    @XmlElement(name = "Address")
    private List<Address> addressList;
    //用户电脑
    @XmlElement(name = "Computers")
    private List<Computer> computers;

    public List<Computer> getComputers() {
        return computers;
    }

    public void setComputers(List<Computer> computers) {
        this.computers = computers;
    }

    public List<Address> getAddressList() {
        return addressList;
    }

    public void setAddressList(List<Address> addressList) {
        this.addressList = addressList;
    }

    public User() {
        super();
    }

    public User(int userId, String userName, String password, Date birthday,
                double money) {
        super();
        this.userId = userId;
        this.userName = userName;
        this.password = password;
        this.birthday = birthday;
        this.money = money;
    }

    public int getUserId() {
        return userId;
    }

    public void setUserId(int userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "User{" +
                "xmnl='" + xmnl + '\'' +
                ", userId=" + userId +
                ", userName='" + userName + '\'' +
                ", password='" + password + '\'' +
                ", birthday=" + birthday +
                ", money=" + money +
                ", addressList=" + addressList +
                ", computers=" + computers +
                '}';
    }
}
 
定义一个Address类
 
package xmlUtil;

import javax.xml.bind.annotation.XmlType;
import java.io.Serializable;

/**
 * @Author:         轻狂书生FS
 * @Description:
 * @CreateDate:     2019/3/29 10:29
 * @Version:        1.0
*/
// 控制JAXB 绑定类中属性和字段的排序
@XmlType(propOrder = {
        "city",
        "province",
})
public class Address implements Serializable {

    private String province;

    private String city;

    public String getProvince() {
        return province;
    }

    public void setProvince(String province) {
        this.province = province;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public Address(String province, String city) {
        this.province = province;
        this.city = city;
    }

    public Address() {
    }
}
 
定义一个Computer类
 
package xmlUtil;

import java.io.Serializable;
import java.util.Date;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;

/**
 * @Author:         轻狂书生FS
 * @Description:
 * @CreateDate:     2019/3/29 10:44
 * @Version:        1.0
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlRootElement(name = "Computer")
@XmlType(propOrder = {  "brandName", "price" })
public class Computer implements Serializable {
    private static final long serialVersionUID = 1L;

    // 品牌名
    private String brandName;
    // 价格
    private double price;

    public Computer() {
        super();
    }

    public Computer( String brandName,double price) {
        super();
        this.brandName = brandName;
        this.price = price;
    }

    public String getBrandName() {
        return brandName;
    }

    public void setBrandName(String brandName) {
        this.brandName = brandName;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Computer{" +
                "brandName='" + brandName + '\'' +
                ", price=" + price +
                '}';
    }
}
 
 
 
此时给出最重要的进行Java对象和XML文件相互操作的核心代码XMLUtil.java，其中有着两种方式进行转换，一种是转换成对象和string类型的xml转换，一种是对象和xml文件进行转换。
 
package xmlUtil;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;

/**
 * 封装了XML转换成object，object转换成XML的代码
 *
 * @author Steven
 *
 */
public class XMLUtil {
    /**
     * 将对象直接转换成String类型的 XML输出
     *
     * @param obj
     * @return
     */
    public static String convertToXml(Object obj) {
        // 创建输出流
        StringWriter sw = new StringWriter();
        try {
            // 利用jdk中自带的转换类实现
            JAXBContext context = JAXBContext.newInstance(obj.getClass());

            Marshaller marshaller = context.createMarshaller();
            // 格式化xml输出的格式
            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT,
                    Boolean.TRUE);
            // 将对象转换成输出流形式的xml
            marshaller.marshal(obj, sw);
        } catch (JAXBException e) {
            e.printStackTrace();
        }
        return sw.toString();
    }

    /**
     * 将对象根据路径转换成xml文件
     *
     * @param obj
     * @param path
     * @return
     */
    public static void convertToXml(Object obj, String path) {
        try {
            // 利用jdk中自带的转换类实现
            JAXBContext context = JAXBContext.newInstance(obj.getClass());

            Marshaller marshaller = context.createMarshaller();
            // 格式化xml输出的格式
            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT,
                    Boolean.TRUE);
            // 将对象转换成输出流形式的xml
            // 创建输出流
            FileWriter fw = null;
            try {
                fw = new FileWriter(path);
            } catch (IOException e) {
                e.printStackTrace();
            }
            marshaller.marshal(obj, fw);
        } catch (JAXBException e) {
            e.printStackTrace();
        }
    }

    @SuppressWarnings("unchecked")
    /**
     * 将String类型的xml转换成对象
     */
    public static Object convertXmlStrToObject(Class clazz, String xmlStr) {
        Object xmlObject = null;
        try {
            JAXBContext context = JAXBContext.newInstance(clazz);
            // 进行将Xml转成对象的核心接口
            Unmarshaller unmarshaller = context.createUnmarshaller();
            StringReader sr = new StringReader(xmlStr);
            xmlObject = unmarshaller.unmarshal(sr);
        } catch (JAXBException e) {
            e.printStackTrace();
        }
        return xmlObject;
    }

    @SuppressWarnings("unchecked")
    /**
     * 将file类型的xml转换成对象
     */
    public static Object convertXmlFileToObject(Class clazz, String xmlPath) {
        Object xmlObject = null;
        try {
            JAXBContext context = JAXBContext.newInstance(clazz);
            Unmarshaller unmarshaller = context.createUnmarshaller();
            FileReader fr = null;
            try {
                fr = new FileReader(xmlPath);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
            xmlObject = unmarshaller.unmarshal(fr);
        } catch (JAXBException e) {
            e.printStackTrace();
        }
        return xmlObject;
    }
}
 
 测试类：
 
package xmlUtil;


import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * @Author:         轻狂书生FS
 * @Description:
 * @CreateDate:     2019/3/29 10:31
 * @Version:        1.0
*/
public class Test {
    public static void main(String[] args) {
        // 创建需要转换的对象
        User user = new User(1, "Steven", "@sun123", new Date(), 1000.0);

        List<Address> addressList = new ArrayList<>();
        Address address1 = new Address("山东省","菏泽市");
        Address address2 = new Address("上海市","浦东新区");
        Address address3 = new Address("浙江省","杭州");
        addressList.add(address1);
        addressList.add(address2);
        addressList.add(address3);
        user.setAddressList(addressList);

        System.out.println("---将对象转换成string类型的xml Start---");
        // 将对象转换成string类型的xml
        String str = XMLUtil.convertToXml(user);
        // 输出
        System.out.println(str);
        System.out.println("---将对象转换成string类型的xml End---");
        System.out.println();
    }
}
 
运行结果：
 
 
请仔细体会，xml和注解之间的关系。
 
本文参考：https://blog.csdn.net/songdeitao/article/details/17304395 

from：https://blog.csdn.net/gavin_john/article/details/51511180
 
1.XML历史
 
gml(1969)->sgml(1985)->html(1993)->xml(1998)
 
1969 gml(通用标记语言)，主要目的是要在不同的机器之间进行通信的数据规范
1985 sgml(标准通用标记语言)
1993 html(超文本标记语言，www网)
 
 
html语言本身是有一些缺陷的 
 （1）不能自定义标签 
 （2）html本身缺少含义 
 （3）html没有真正的国际化
 
 
有一个中间过渡语言,xhtml： 
 html->xhtml->xml
 
 
1998 xml extensiable markup language 可扩展标记语言
2.为什么需要XML
 
1.需求1 
 两个程序间进行数据通信？ 
 2.需求2 
 给一台服务器，做一个配置文件，当服务器程序启动时，去读取它应当监听的端口号，还有连接数据库的用户名和密码？
 
在XML语言中，它允许用户自定义标签。一个标签用于描述一段数据；一个标签可以分为开始标签和结束标签，在开始标签和结束标签之间，又可以使用其他标签描述其他数据，以此来实现数据关系的描述。
 
3.XML常见应用
 
1.XML的出现解决了程序间数据传输的问题： 
 比如QQ之间的数据传送，用XML格式来传送数据，具有良好的可读性，可维护性
 
2.XML可以做配置文件 
 XML文件做配置文件可以说非常普遍，比如我们的Tomcat服务器的server.xml，web.xml。再比如我们的structs中的structs-config.xml文件，和hibernate的hibernate.cfg.xml等等。
 
3.XML可以充当小型的数据库 
 XML文件可以做小型数据库，也是不错的选择，我们程序中可能用到一些经常要人工配置的数据，如果放在数据库中读取不合适（因为这会增加维护数据库的工作），则可以考虑直接用XML来做小型数据库。这种方式直接读取文件显然要比读数据库快。比如msn中保存用户聊天记录就是用XML文件。
 
入门案例：用XML来记录一个班级信息。
 
<?xml version="1.0" encoding="gb2312"?>

<class>
    <stu id="001">
        <name>杨过</name> 
        <sex>男</sex>
        <age>20</age>
    </stu>  
    <stu id="002">
        <name>小龙女</name>    
        <sex>女</sex>
        <age>21</age>
    </stu>
</class>
 
我们可以用浏览器打开：
 
 
那么我们的XML能不能像html那样显示在网页上呢？也是可以的，它也可以用css来修饰，但我们不用，我们只需要使用XML来存储数据。
 
在这个例子中，如果我们把第一行的编码改为utf-8，再用浏览器打开会报错，这是为什么呢？
 
 
 
因为xml文件的默认编码是ANSI，即美国国家标准协会制定的编码，它根据不同的国家和地区制定了不同的标准，那么在中国就是GB2312，所以我们用GB2312编码不会出错，而用UTF-8会报错。
 
 
解决办法就是将该XML文件更改为UTF-8的编码模式即可。
 
 
4.XML语法
 
一个XML文件分为如下几部分内容： 
 1.文档声明 
 2.元素 
 3.属性 
 4.注释 
 5.CDATA区、特殊字符 
 6.处理指令（processing instruction）
 
4.1.XML语法-文档声明
 
<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
 
XML声明放在XML文档的第一行 
XML声明由以下几个部分组成：
 
 
 
version –文档符合XML1.0规范，我们学习1.0 
 encoding –文档字符编码，比如”GB2312”或者”UTF-8” 
 standalone –文档定义是否独立使用 
 standalone=”no”为默认值。yes代表是独立使用，而no代表不是独立使用
 
 
4.2.XML语法-元素（或者叫标记、节点）
 
 
 
(1)每个XML文档必须有且只有一个根元素
 
 
根元素是一个完全包括文档中其他所有元素的元素
根元素的起始标记要放在所有其他元素的起始标记之前
跟元素的结束标记要放在所有其他元素的结束标记之后
 
 
(2)XML元素指的是XML文件中出现的标签，一个标签分为开始标签和结束标签，一个标签有如下几种书写方式，例如
 
 
包含标签体：
<a>www.sohu.com</a>
 
不含标签体的：
<a></a>,简写为:<a/>
 
(3)一个标签中也可以嵌套若干子标签。但所有标签必须合理地嵌套，绝对不允许交叉嵌套，例如
<a>welcome to <b> www.sohu.com </a></b>
 
这种情况肯定是要报错的。
 
 
(4)对于XML标签中出现的所有空格和换行，XML解析程序都会当做标签内容进行处理。例如下面两段内容的意义是不一样的。
 
 
<stu>xiaoming</stu>
 
和如下：
<stu>
    xiaoming
</stu>
 
 
 
(5)由于在XML中，空格和换行都作为原始内容被处理，所以，在编写XML文件时，要特别注意。
 
 
(6)命名规范：一个XML元素可以包含字母、数字以及其它一些可见字符，但必须遵守以下规范：
 
 
区分大小写，例如，元素P和元素p是两个不同的元素
不能以数字或下划线”_”开头
元素内不能包含空格
名称中间不能包含冒号（:）
可以使用中文，但一般不这么用
4.3.XML语法-属性
 
<student id="100">
    <name>Tom</name>
</student>
 
 
 
(1)属性值用双引号（”）或单引号（’）分隔，如果属性值中有单引号，则用双引号分隔；如果有双引号，则用单引号分隔。那么如果属性值中既有单引号还有双引号怎么办？这种要使用实体（转义字符，类似于html中的空格符），XML有5个预定义的实体字符，如下：
 
 
 
 
 
(2)一个元素可以有多个属性，它的基本格式为：
 
 
<元素名 属性名1="属性值1" 属性名2="属性值2">
 
(3)特定的属性名称在同一个元素标记中只能出现一次 
 
 
(4)属性值不能包括<,>,&，如果一定要包含，也要使用实体
 
 
4.4.XML语法-注释
 
XML的注释类似于HTML中的注释：
 
<!--这是一个注释-->
 
(1)注释内容不要出现-- 
 
 
(2)不要把注释放在标记中间； 
 (3)注释不能嵌套 
 (4)可以在除标记以外的任何地方放注释
 
 
4.5.XML语法-CDATA节
 
假如有这么一个需求，需要通过XML文件传递一幅图片，怎么做呢？其实我们看到的电脑上的所有文件，本质上都是字符串，不过它们都是特殊的二进制字符串。我们可以通过XML文件将一幅图片的二进制字符串传递过去，然后再解析成一幅图片。那么这个字符串就会包含大量的<,>,&或者“等一些特殊的不合法的字符。这时候解析引擎是会报错的。
 
所以，有些内容可能不想让解析引擎解析执行，而是当做原始内容处理，用于把整段文本解释为纯字符数据而不是标记。这就要用到CDATA节。
 
语法如下：
 
<![CDATA[
    ......
]]>
 
CDATA节中可以输入任意字符（除]]>外），但是不能嵌套！
 
如下例，这种情况它不会报错，而如果不包含在CDATA节中，就会报错：
 
<stu id="001">
    <name>杨过</name> 
    <sex>男</sex>
    <age>20</age>
    <intro><![CDATA[ad<<&$^#*k]]></intro>
</stu>
 
.6.XML语法-处理指令
 
处理指令，简称PI（processing instruction）。处理指令用来指示解析引擎如何解析XML文件，看下面一个例子：
 
比如我们也可以使用css样式表来修饰XML文件，编写my.css如下：
 
name{
    font-size:80px;
    font-weight:bold;
    color:red;
}

sex{
    font-size:60px;
    font-weight:bold;
    color:blue;
}

sex{
    font-size:40px;
    font-weight:bold;
    color:green;
}
 
我们在xml文件中使用处理指令引入这个css文件，如下：
 
<?xml version="1.0" encoding="gb2312"?>
<?xml-stylesheet href="my.css" type="text/css"?>
<class>
    <stu id="001">
        <name>杨过</name> 
        <sex>男</sex>
        <age>20</age>
    </stu>  
    <stu id="002">
        <name>小龙女</name>    
        <sex>女</sex>
        <age>21</age>
    </stu>
</class>
 
这时候我们再用浏览器打开这个xml文件，会发现浏览器解析出一个带样式的视图，而不再是单纯的目录树了：
 
 
但是XML的处理指令不要求掌握，因为用到的很少。
 
5.格式正规的XML文档-小结
 
语法规范：
 
1.XML声明语句 
 2.必须有一个根元素 
 3.标记大小写敏感 
 4.属性值用引号 
 5.标记成对 
 6.空标记关闭 
 7.元素正确嵌套
 
from：https://blog.csdn.net/qq_38254978/article/details/77870598
 
什么是xml文件格式
 
我们要给对方传输一段数据，数据内容是“too young,too simple,sometimes naive”，要将这段话按照属性拆分为三个数据的话，就是，年龄too young，阅历too simple，结果sometimes naive。我们都知道程序不像人，可以体会字面意思，并自动拆分出数据，因此，我们需要帮助程序做拆分，因此出现了各种各样的数据格式以及拆分方式。比如，可以是这样的数据为“too young,too simple,sometimes naive”然后按照逗号拆分，第一部分为年龄，第二部分为阅历，第三部分为结果。
也可以是这样的数据为“too_young* too_simple*sometimes_naive”从数据开头开始截取前面十一个字符，去掉号并把下划线替换为空格作为第一部分，再截取接下来的十一个字符同样去掉并替换下划线为空格作为第二部分，最后把剩下的字符同样去号体会空格作为第三部分。
这两种方式都可以用来容纳数据并能够被解析，但是不直观，通用性也不好，而且如果出现超过限定字数的字符串就容纳不了，也可能出现数据本身就下划线字符导致需要做转义。基于这种情况，出现了xml这种数据格式， 上面的数据用XML表示的话可以是这样
<person age="too young" experience="too simple" result="sometimes naive" />
 
也可以是这样
 
<person>
    <age value="too young" />
    <experience value="too simple" />
    <result value="sometimes naive" />
</person>
 
两种方式都是xml，都很直观，附带了对数据的说明，并且具备通用的格式规范可以让程序做解析。如果用json格式来表示的话，就是下面这样看出来没，其实数据都是一样的，不同的只是数据的格式而已，同样的数据，我用xml格式传给你，你用xml格式解析出三个数据，用json格式传给你，你就用json格式解析出三个数据，还可以我本地保存的是xml格式的数据，我自己先解析出三个数据，然后构造成json格式传给你，你解析json格式，获得三个数据，再自己构造成xml格式保存起来，说白了，不管是xml还是json，都只是包装数据的不同格式而已，重要的是其中含有的数据，而不是包装的格式。
 
XML文件创建格式
 
例：
<?xml version="1.0" encoding="utf-8" ?>
<root>
    <part id = "01" name="选项一">
        <name>我是徐茅山</name>
        <age>今年20岁</age>
        <sex>男</sex>
    </part>
    <part id="02" name="选项二">
        <name>我是李逍遥</name>
        <age>今年22岁</age>
        <sex>男</sex>
    </part>
</root>
 
开始的
xml文件的解析
 
这里只是简单的提一下关于xml文件的解析，我使用的是比较流行的dom4j解析，[dom4j的文件下载地址](“https://dom4j.github.io/“)
实例：
package com.xinsi.qi.utils;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;

import java.io.File;
import java.util.List;

public class Dom4jXml {
    public void test(){
        try {
            File inputFile = new File("F:\\J2EE学习资料\\demoLes03\\web\\WEB-INF\\test.xml");
            SAXReader reader = new SAXReader();
            Document document = reader.read(inputFile);
            System.out.println("Root element :"+document.getRootElement().getName());

            Element classElement = document.getRootElement();

            List<Node> nodes = document.selectNodes("/class/part[@id='02']");

            System.out.println("--------------------");

            for (Node node:nodes){
                System.out.println("标签名=:"+node.getName());
                System.out.println("姓名:"+node.selectSingleNode("name").getText());
                System.out.println("年龄:"+node.selectSingleNode("age").getText());
                System.out.println("性别:"+node.selectSingleNode("sex").getText());
            }
        } catch (Exception e1) {
            e1.printStackTrace();
        }
    }

}
 
首先创建一个xml文件，这里使用的xml文件就是上面的xml例子，使用dom4j，先创建文件，将文件引入。
 File inputFile = new File("F:\\J2EE学习资料\\demoLes03\\web\\WEB-INF\\test.xml");
 
再创建dom4j的读取文件类，来读取xml文件
  SAXReader reader = new SAXReader();
 
Document是获取根元素类，控制台输出时，如下
System.out.println("Root element :"+document.getRootElement().getName());
输出Root element :root，该文件的根元素名称为root
 
Element类是获取根元素内的元素
 
List nodes = document.selectNodes(“/class/part[@id=’02’]”) 这段代码的意思是，定位到该元素属性的位置，使用该方法还需要下载，jaxen.jar包，jaxen的下载地址
@id=’02’的意思是定位到id为02的元素属性，以遍历的形式输出出来。
for (Node node:nodes){
System.out.println("标签名=:"+node.getName());
System.out.println("姓名:"+node.selectSingleNode("name").getText());
System.out.println("年龄:"+node.selectSingleNode("age").getText());
System.out.println("性别:"+node.selectSingleNode("sex").getText());
}
 
最终控制台的输出结果为：
标签名=:part
姓名:我是李逍遥
年龄:今年22岁
性别:男