精华内容
下载资源
问答
  • XML和JSON

    万次阅读 2015-08-30 17:57:19
    本文主要介绍XML和JSON。内容包括:PULL解析XML,SAX解析XML,JSONObject解析JSON,Gson解析JSON

    本文翻译自xmlpull,SAX,android,JSON官方文档(http://www.saxproject.org/quickstart.htmlhttp://www.json.org/),经测试整理如下。

    网络传输数据

    一般我们会在网络上传输一些格式化的数据,这些数据有自己的语义。当另一方收到数据时,以相同的语义进行解析,获取真正想要的数据。

    在网络中传输数据时最常用的方法是:XML和JSON,本文先介绍XML解析。

    XML,可扩展标记语言(Extensible Markup Language)是一个以文本来描述数据的文档,可以实现客户端与服务器之间的数据传输。如下一个xml文档示例:

    
    <?xml version="1.0" encoding="UTF-8"?>
    <person>
        <teacher id = "1">
            <name>wyg</name>
        </teacher>
        <teacher id = "2">
            <name>wyg</name>
        </teacher>
    </person>
    

    <?xml version="1.0" encoding="UTF-8"?>是xml头部分,标记该文档为xml文档,同时指出了版本号和编码格式。<person>为开始标签(或称为:标记,元素),</person>为结束标签。在本文档中<person>是根标签,包含了两个子标签:<teacher>,在该标签内有一个id属性。<teacher>又有一个<name>子标签,该标签的值为wyg

    一个基本的xml文件就是由上述部分构成。xml有以下用途:

    • 显示数据
    • 存储数据
    • 在服务器与客户端传输

    下面我们集中讨论一下如何解析xml,即在接收方怎么处理该xml文档。主要介绍两种:PULL解析和SAX解析。
    首先来看一下PULL解析

    PULL解析

    概述

    XmlPullParser是一个接口,通过XMLPULL V1 API定义了解析方法。
    根据特性不同可以有下列几种不同的解析:

    • 非通用型
      当设置FEATURE_PROCESS_DOCDECLtrue时,则是XML1.0规范中定义的解析。
    • 通用型
      当设置FEATURE_VALIDATIONtrue时,是XML1.0规范中定义的解析(这也表明FEATURE_PROCESS_DOCDECLtrue)。
    • FEATURE_PROCESS_DOCDECLfalse时(这是默认情况),那么解析器的行为像XML1.0兼容的非通用型解析器,在没有DOCDECL出现的情况下(内部实例仍然能够通过defineEntityReplacementText()定义)。这种适合有约束条件环境下的操作,如J2ME。

    XmlPullParser有两个关键的方法:next()nextToken()next()方法提供访问高级事件,nextToken()提供访问低级标记。

    可以通过getEventType()获取解析器中的当前事件状态。最初解析器的事件状态为:START_DOCUMENT

    next()方法可以进入到下一个事件状态。该方法的返回值(int值)决定了当前解析器的状态。该值等于此刻调用getEventType()方法的返回值。

    事件类型有如下几种:

    • START DOCUMENT
      开始读文档,现在还没读任何信息
    • START_TAG
      读到XML中的一个标签。
    • TEXT
      读到文本内容,可以通过getText()方法获得。当在通用型模式时,next()方法将会读取空白,使用nextToken()方法可以忽略。
    • END_TAG
      读到结束标签
    • END_DOCUMENT
      事件结束,完成XML解析。

    可以通过下列方式获取下一个事件:

    • next()
      获得下一个事件。
    • nextTag()
      调用next(),若事件是START_TAGEND_TAG则会返回,否则抛出异常。<tag/>这样的标签则会解析成两个事件: START_TAGEND_TAG
    • nextText()
      返回下一个事件的内容。若当前事件是START_TAG,且下一个事件是TEXT,那么调用该方法将会返回标签内的内容,或者下一个事件是END_TAG则会返回空字符串。
      对于TEXT事件,我们也可以通过getText()获取标签内的内容,
    • nextToken()
      这个方法和next()类似,也能返回事件。但是该方法将会返回额外的事件类型(COMMENT,CDSECT,DOCDECL,ENTITY_REF, PROCESSING_INSTRUCTION,IGNORABLE_WHITESPACE),前提xml中有这些信息。

    若当前标签有属性的话可以通过getAttributeName(int)获取属性名,参数为属性的索引,从0开始。getAttributeValue(int)获取属性值,参数为属性的索引,从0开始。

    在第一次使用nextXXX()方法时,通过下列方式能够获得XML的版本,standalone和编码方式:

    • version
      getProperty("http://xmlpull.org/v1/doc/properties.html#xmldecl-version")将返回”1.0”或者null(如果XML声明没有被读取的话,或者不支持该属性)
    • standalone
      getProperty("http://xmlpull.org/v1/doc/properties.html#xmldecl-standalone")。如果没有standalone声明的话,或者不支持该属性的话,方法返回null。若standalone="yes"则返回Boolean类型的true,standalone="no"将返回fasle。
    • encoding
      通过getInputEncoding()获得,若没有在设置(在setInputStream中设置)并且没有在文档中声明,将会返回null。

    PULL解析步骤

    为了通过PULL解析XML格式内容,我们需要完成以下内容

    1. 首先我们需要创建解析器实例,可以通过下面三步完成:
      1. 获得XMLPULL工厂实例;
      2. (可选步骤)默认情况下创建解析器的工厂实例不知道命名空间,可以通过setNamespaceAware(true)方法设置。
      3. 通过工厂实例创建解析器。
    2. 设置解析器的输入内容,可以通过setInput(Reader)setInput(InputStream, String)

    简单介绍一下命名空间:XML命名空间提供避免元素命名冲突的方法。XML命名空间属性被放置于元素的开始标签之中,并使用以下的语法:xmlns:namespace-prefix="namespaceURI",当命名空间被定义在元素的开始标签中时,使用时可以选择加上命名空间前缀(也可以不加)。例如:

    
    <wyg:person xmlns:wyg="http://www.sywyg.com">
        <wyg:teacher id = "1"/>
    </wyg:person>
    

    所有带有相同前缀的子元素都会与同一个命名空间相关联。上述内容来自:http://www.w3school.com.cn/xml/xml_namespaces.asp

    通过上述两步,我们就可以开始解析xml文档了。典型的XMLPULL程序会反复调用nextXXX()方法检索下一个事件,并进行相应的处理,直到遇到END_DOCUMENT事件。

    一套完整的解析代码如下:

    
    /**
     * XML解析:PULL解析
     * @author sywyg
     * @since 2015.7.27
     */
    
    public class MainActivity extends Activity {
        private final String TAG = "result";
    
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
        }
        public void btnClick(View view){
            String xmlData =
                    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
                    "<person>" +
                    "  <teacher id=\"1\" >" +
                    "        <name>wyg</name>" +
                    "  </teacher>" +
                    "  <teacher id=\"2\" name=\"sywyg\"></teacher>" +
                    "</person>";
            parseXMLWithPULL(xmlData);
        }
        // 解析数据
        public void parseXMLWithPULL(String xmlData) {
            ArrayList<Teacher> listTeacher = new ArrayList<Teacher>();
            XmlPullParserFactory factory = null;
            XmlPullParser xpp = null;
            //事件类型
            int eventType = 0;
            // xml文件位置
           // String xmlName = "person.xml";
            // 1. 创建PULL解析器
            try {
                // 1.1 获得XMLPULL工厂实例
                factory = XmlPullParserFactory.newInstance();
                // 1.2 通过工厂实例创建解析器
                xpp = factory.newPullParser();
                // 2. 设置xml文档数据
                xpp.setInput(new StringReader(xmlData));
                // 3. 开始解析数据
                eventType = xpp.getEventType();
                Teacher teacher = null;
                while (eventType != XmlPullParser.END_DOCUMENT) {
                    String nodeName = xpp.getName();
                    switch (eventType) {
                        case XmlPullParser.START_DOCUMENT:
                            Log.d(TAG,"Start document");
                        case XmlPullParser.START_TAG:
                            // 读取标签
                            if ("teacher".equals(nodeName)) {
                                teacher = new Teacher();
                                String id = xpp.getAttributeValue(0);
                                teacher.setId(Integer.parseInt(id));
                            } else if ("name".equals(nodeName)) {
                                teacher.setName(xpp.getText());
                            }
                        break;
                        case XmlPullParser.TEXT:
                            Log.d(TAG,"getText:" + xpp.getText());
                            break;
                        case XmlPullParser.END_TAG:
                            // 解析完某个节点
                            if("teacher".equals(nodeName)){
                                Log.d(TAG,teacher.toString());
                            }
                            break;
                        default:
                            Log.d(TAG,"end document ");
                            break;
                    }
                    eventType  = xpp.next(); // 可能抛出IO异常
                }
    
            } catch (XmlPullParserException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    

    更过相关内容请参考Android API,如require(),nextText(),nextToken()等。

    SAX解析

    看完PULL方式解析,我们来看一下SAX方式解析。

    SAX(Simple API for XML),可以方便的读取和操作XML数据。SAX解析方式也是基于事件处理数据流,在遇到相应的事件时,调用对应的方法处理事件。

    SAX解析中主要有四种处理事件的接口:EntityResolverDTDHandlerContentHandlerErrorHandler,而我们一般只需要继承DefaultHandler类即可,该类实现了上述四个接口。

    在继承DefaultHandler类时,我们需要重写父类的几个监听事件的方法,如下:

    
    public class MyXMLSAXHandler extends DefaultHandler {
        @Override
        public void startDocument() throws SAXException {}
        @Override
        public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {}
        @Override
        @Override
        public void characters(char[] ch, int start, int length) throws SAXException {}
        public void endElement(String uri, String localName, String qName) throws SAXException {}
        @Override
        public void endDocument() throws SAXException {}
    }
    

    根据方法名我们也能大体猜到每个方法的作用了:

    • startDocument()
      在开始解析XML文档时被调用。
    • startElement(String uri, String localName, String qName, Attributes attributes)
      在开始解析某个标签时被调用。
      参数分别为:

      1. uri:命名空间
      2. localName:不带前缀的标签名(前缀一般是命名空间指定的)
      3. qName:带前缀的标签名
      4. attributes:保存属性集合,以此来获取属性值(有一系列的`getXXX()`方法可以获取相关信息)
      
    • characters(char[] ch, int start, int length)
      在获取标签内容时调用。
      参数分别为:

      1. ch:读取到的标签内容字符数组
      2. start:数组的起始位置
      3. length:数组的长度
      
    • endElement(String uri, String localName, String qName)
      在结束标签时被调用。
      参数和startElement()方法的前三个一样。

    • endDocument()
      文档解析完毕时调用。

    解析步骤

    为了通过SAX解析XML格式内容,我们需要完成以下内容:

    1. 创建XMLReader对象
    2. 创建XML事件处理器
    3. 通过XMLReader的setContentHandler()setErrorHandler()(该方法是可选方法)方法注册事件处理器,这样解析器就能够处理信息。
    4. 通过XMLReader的parse()方法开始解析

    代码如下:

    
    public class MyXMLSAXHandler extends DefaultHandler {
        private static String xmlData = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
                                        + "<person>"
                                            + "<teacher id=\"1\">"
                                                + "<name>wyg</name>wyg2"
                                            + "</teacher>"
                                        + "</person>";
        private String id;
        private StringBuilder name;
        private String nodeName;
        public static void main(String[] args) {
            XMLReader reader = null;
                try {
                    // 1. 创建XMLReader对象
                    // 这种方式是通过XMLReaderFactory的静态方法获取的动态对象。
                    reader = XMLReaderFactory.createXMLReader();
                    // 2. 创建XML事件处理器
                    ContentHandler handler = new MyXMLSAXHandler();
                    // 3. 注册事件处理器
                    reader.setContentHandler(handler);
                    //reader.setErrorHandler((ErrorHandler) handler);
                    // 4. 开始执行解析
                    reader.parse(new InputSource(new StringReader(xmlData)));
                } catch (SAXException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }
        @Override
        public void startDocument() throws SAXException {
            name = new StringBuilder();
            System.out.println("start Document");
        }
        @Override
        public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
            nodeName = localName;
            if("teacher".equals(nodeName)){
                // 清空换行符或回车
                id = attributes.getValue(0).trim();
            }
            System.out.println("start Element");
        }
        @Override
        public void characters(char[] ch, int start, int length) throws SAXException {
            if("name".equals(nodeName)){
                name.append(ch, start, length);
                //System.out.println(name);
            }
            System.out.println("start characters");
        }
        @Override
        public void endElement(String uri, String localName, String qName) throws SAXException {
            if("teacher".equals(localName)){
                System.out.println("id = " + id);
                System.out.println("name = " + name);
                // 将name值清空,方便再读取
                name.setLength(0);
                id = null;
            }
            // 避免characters()方法读取换行符
            nodeName = null;
            System.out.println("end Element");
        }
        @Override
        public void endDocument() throws SAXException {
            System.out.println("end Document");
        }
    }
    

    注意:characters()该方法可能会在startElement()endElement()之后都被调用,如:

    
    <teacher id="1">
        <name>wyg</name>wyg2
    </teacher>
    

    对于上面的xml,则读取完结束标签</name>之后因为后面还有字符串(对于换行符也是),因此还会调用characters()。调用过程可能会存在下列顺序startDocument()--->startElement()--->characters()--->endElement()--->characters()--->startElement()......--->endDocument()。因此,在我们读取数据时,需要判断好是开始标签还是结束标签,对于结束标签其调用characters()的话就不做任何处理(可以在endDocument()将标签设置为null,如上)。

    下面我们看以下JSON数据。内容翻译自http://www.json.org/

    JSON

    JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式,易于人阅读和编写,同时也易于机器解析和生成。
    它基于JavaScript Programming Language, Standard ECMA-262 3rd Edition - December 1999的一个子集。
    JSON采用完全独立于语言的文本格式,但是也使用了类似于C语言家族的习惯(包括C, C++, C#, Java, JavaScript, Perl, Python等)。
    这些特性使JSON成为理想的数据交换语言。

    JSON建构于两种结构:

    • “名称/值”对的集合(A collection of name/value pairs)。
      不同的语言中,它被理解为对象(object),纪录(record),结构(struct),字典(dictionary),哈希表(hash table),有键列表(keyed list),或者关联数组 (associative array)。对于java就是对象。
    • 值的有序列表(An ordered list of values)。在大部分语言中,它被理解为数组(array)。

    这些都是常见的数据结构。事实上大部分现代计算机语言都以某种形式支持它们。这使得一种数据格式在同样基于这些结构的编程语言之间交换成为可能。

    JSON具有以下这些形式:

    对象是一个无序的“‘名称/值’对”集合。一个对象以“{”(左括号)开始,“}”(右括号)结束。每个“名称”后跟一个“:”(冒号);“‘名称/值’ 对”之间使用“,”(逗号)分隔。
    1

    例如:{"id":"5","name":"sywyg"}。
    数组是值(value)的有序集合。一个数组以“[”(左中括号)开始,“]”(右中括号)结束。值之间使用“,”(逗号)分隔。
    2

    值(value)可以是双引号括起来的字符串(string)、数值(number)、true、false、 null、对象(object)或者数组(array),这些结构可以嵌套。
    3

    字符串(string)是由双引号包围的任意数量Unicode字符的集合,使用反斜线转义。一个字符(character)即一个单独的字符串(character string)。
    字符串(string)与C或者Java的字符串非常相似。

    4

    数值(number)也与C或者Java的数值非常相似。除去未曾使用的八进制与十六进制格式。除去一些编码细节。

    5

    下面介绍一下Android中解析JSON,主要介绍两种:JSONObject,和谷歌的开源库GSON。

    首先介绍了一下JSONObject

    JSONObject

    使用JSONObject会涉及到以下几个类:

    • JSONArray
    • JSONObject
    • JSONStringer
    • JSONTokener

    注意这四个类都是线程不安全的,且其它类不应该继承这些类。

    JSONArray

    一组有序的值,值可能是:JSONObject/JSONArray/String/Integer/Long/Double/NULL/null
    注意:在两种情况下可能是null:java中的null值和获取失败时的。JSONObject.NULL不是。
    在该类中,提供了很多getXXX(int index)/optXXX(int index)可以通过索引获得到该对象中的各种值(可以先通过isNull(int)判断是否存在值再获得)。
    putXXX()方法用来添加或者替换其中的值(构建JSON数据),该方法返回自己的对象。

    JSONObject

    该类是用来处理json中对象的,对象名是唯一并且非空的字符串。值可能是:JSONObject/JSONArray/String/Integer/Long/Double/NULL。

    该类可以将值强制转换成另外的类型:

    • 当请求类型是boolean时,字符串会转换成“true”/“false”;
    • 当请求类型为double时,字符串将通过Double的valueOf(String)转换成double。
    • 当请求类型为int/long时,字符串将通过Double的valueOf(String)转换成double,然后再转换成int/long。
    • 当请求类型是String时,其它非null值将会通过String的valueOf(Object)转换成String类型,null也会被转换成“null”。

    JSONStringer

    实现了JSONObject和JSONArray的toString(),可以通过该类构建JSON字符串,即
    JSONObject和JSONArray的toString()源码实现是由JSONStringer实现的。

    该类只能解析标准格式的JSON字符串,特别是下面要求:

    • 必须有一个顶层的数组或对象。
    • 对应的方法调用必须配对,array()必须和endArray()object()必须和endObject()
    • 数组可能不包含keys。
    • 对象必须包含可选的keys和值。

    注意调用非格式JSON字符串将会抛出JSONException异常,该类没有提供缩进输出,需要缩进输出的话
    使用JSONObject和JSONArray的toString()

    JSONTokener

    JSON文本解析类,大部分应用只是用下列方式:

    
    String json = "{"
             + "  \"query\": \"Pizza\", "
             + "  \"locations\": [ 94043, 90210 ] "
             + "}";
    
     JSONObject object = (JSONObject) new JSONTokener(json).nextValue();
     String query = object.getString("query");
     JSONArray locations = object.getJSONArray("locations");
    

    对于下面的语法错误将会忽略:

    • \/\/#开始,换行符。
    • \/\*
    • 不正确的字符串。
    • 前缀是0x或0X。
    • 前缀是0。
    • 数组元素使用分割。
    • 使用==>;分割属性。

    下面介绍一下Gson

    Gson

    Gson是Google提供的用来在java对象和JSON数据之间进行映射的java类库。可以将一个JSON字符串转成一个java对象,
    也可以将java对象转换成JSON字符串。

    java数组/对象转换成JSON字符串

    从java数组/对象转换成JSON字符串可以通过Gson的toJson()方法,例如:

    
    Gson gson = new Gson();
    String[] strings = {"sywyg", "wyg"};
    String JsonStrings = gson.toJson(strings);
    

    其中,toJson()的参数可以为数组/list/set,在list/set中就可以设置相应的对象。

    JSON字符串转换成java数组/对象

    Gson提供了fromJson()方法来实现从JSON字符串到java数组/对象。该方法接收两个参数
    第一个参数为JSON字符串,第二个参数为对象类/数组/list/set。

    json和xml比较

    1.JSON和XML的数据可读性基本相同
    2.JSON和XML同样拥有丰富的解析手段
    3.JSON相对于XML来讲,数据的体积小,网络传输节省流量
    4.JSON与JavaScript的交互更加方便
    5.JSON对数据的描述性比XML较差
    6.JSON的速度要远远快于XML

    展开全文
  • xml和json

    2017-07-20 22:38:07
    - xml基础语法规范 - C程序中如何使用 xml开源库 - 借助开源库,在C程序中生成xml文件 - 已知一个xml文件,如何借助开源库解析xml文件数据 Json - json的基础语法规范 - C程序中如何使用 json开源库 ...
    xml
    - xml基础语法和规范
    - C程序中如何使用 xml开源库
    - 借助开源库,C程序中生成xml文件
    已知一个xml文件,如何借助开源库解析xml件数据

    Json

    - json的基础语法和规范
    - C程序中如何使用 json开源库 - cjson
    - 使用 cjson生成json文件
    - 已知一个json文件,使用 cjson库解析文件数据

    minixml官网地址
    http://www.msweet.org/projects.php/Mini-XML
    包含头文件: mxml.h
    -lmxml
    /usr/local/lib
    编译的时候需要添加动态库: libmxml.so
    其他解析xml开源库: tinyxml pugixml


    安装
    ./configure --enable-threads=no && make
    sudo make install

    cjson的使用
    压缩包解压缩,直接使用里边的cJSON.ccJSON.h即可
    链接时还需要加上-lm 表示链接math库
    json数组 json对象 json数组和json对象






    展开全文
  • XML和JSON数据格式

    千次阅读 2018-10-14 16:05:33
    目录 ...XML和JSON都是web存储和传输过程中数据的格式,其中JSON使用比较广泛,主要用来前后端交互数据。 XML XML(Extensible Markup Language)扩展标记语言 ,是一种常用的标记语言,用于标记...

    目录

    XML

    DTD(文档类型定义)

    DTD声明

    DTD实体

    JSON

    使用python解析JSON数据

    XML和JSON的区别 

    XML的优缺点

    JSON的优缺点


    XML和JSON都是web存储和传输过程中数据的格式,其中JSON 使用比较广泛,主要用来前后端交互数据。

    XML

    XML(Extensible Markup Language)扩展标记语言 ,是一种常用的标记语言,用于标记电子文件使其具有结构性,可以用来标记数据、定义数据类型,是一种允许用户对自己的标记语言进行定义的源语言。 XML使用 DTD(document type definition)文档类型定义来组织数据;格式统一,跨平台和语言,早已成为业界公认的标准。XML是标准通用标记语言 (SGML) 的子集,非常适合 Web 传输。XML 提供统一的方法来描述和交换独立于应用程序或供应商的结构化数据。

    #XML声明
    <?xml version="1.0" encoding="UTF-8"?> 
    #文档类型定义DTD
    <!DOCTYPE note [
        <!ELEMENT note (to,from,heading,body)>
        <!ELEMENT to       (#PCDATA)>
        <!ELEMENT from     (#PCDATA)>
        <!ELEMENT heading  (#PCDATA)>
        <!ELEMENT body     (#PCDATA)>
    ]>
    #文档元素
    <note>
      <to>Tove</to>
      <from>Jani</from>
      <heading>Reminder</heading>
      <body>Hello,word!</body>
    </note>

    XML文档的构建模块 

    所有的 XML 文档(以及 HTML 文档)均由以下简单的构建模块构成:

    • 元素
    • 属性
    • 实体
    • PCDATA
    • CDATA

    下面是每个构建模块的简要描述。
    1:元素
    元素是 XML 以及 HTML 文档的主要构建模块,元素可包含文本、其他元素或者是空的。
    实例:

    <body>body text in between</body>

    空的 HTML 元素的例子是 <hr>、<br> 以及 <img>。

    2:属性
    属性可提供有关元素的额外信息
    实例:

    <img src="computer.gif" />

    3:实体
    实体是用来定义普通文本的变量。实体引用是对实体的引用。

    4:PCDATA
    PCDATA 的意思是被解析的字符数据(parsed character data)。
    PCDATA 是会被解析器解析的文本。这些文本将被解析器检查实体以及标记。

    5:CDATA
    CDATA 的意思是字符数据(character data)。
    CDATA 是不会被解析器解析的文本。

    DTD(文档类型定义)

    DTD(文档类型定义)的作用是定义 XML 文档的合法构建模块。

    DTD 可以在 XML 文档内声明,也可以外部引用。

    DTD声明

    1:内部声明:<!DOCTYPE   根元素   [元素声明]  > 

    <?xml version="1.0"?>
    <!DOCTYPE note [
      <!ELEMENT note (to,from,heading,body)>
      <!ELEMENT to      (#PCDATA)>
      <!ELEMENT from    (#PCDATA)>
      <!ELEMENT heading (#PCDATA)>
      <!ELEMENT body    (#PCDATA)>
    ]>
    <note>
      <to>George</to>
      <from>John</from>
      <heading>Reminder</heading>
      <body>Don't forget the meeting!</body>
    </note>

    2:外部声明(引用外部DTD):<!DOCTYPE 根元素 SYSTEM "文件名">  

    <?xml version="1.0"?>
    <!DOCTYPE note SYSTEM "http://127.0.0.1/note.dtd">
    <note>
    <to>George</to>
    <from>John</from>
    <heading>Reminder</heading>
    <body>Don't forget the meeting!</body>
    </note> 
    
    #而http://127.0.0.1/note.dtd的内容为
    <!ELEMENT note (to,from,heading,body)>
    <!ELEMENT to (#PCDATA)>
    <!ELEMENT from (#PCDATA)>
    <!ELEMENT heading (#PCDATA)>
    <!ELEMENT body (#PCDATA)>

    DTD实体

    DTD实体是用于定义引用普通文本或特殊字符的快捷方式的变量,可分为内部实体和外部实体。

    • 内部实体:<!ENTITY  实体名  实体的值 >
    • 外部实体:<!ENTITY  实体名  SYSTEM   url  >

    内外部实体又可分为 一般实体 和 参数实体

    • 一般实体的声明语法:<!ENTITY  实体名   "实体内容“>                  引用实体的方式:&实体名;
    • 参数实体只能在DTD中使用,参数实体的声明格式: <!ENTITY  %实体名   "实体内容“>        引用实体的方式:%实体名;
    <?xml version="1.0"?>
    <!DOCTYPE message [
        <!ENTITY normal    "hello">     <!-- 内部一般实体 -->
        <!ENTITY % normal2 "hello">     <!-- 内部参数实体 -->
        <!ENTITY normal3 SYSTEM "http://xml.org/hhh.dtd">    <!-- 外部一般实体 -->
        <!ENTITY % normal4 SYSTEM "file:///1234.dtd">        <!-- 外部参数实体 -->
        %normal4;            <!-- 引用参数实体 -->
    ]>
    <message>&normal;</message>    <!-- 引用参数实体 -->

    而且参数实体还能嵌套定义,但需要注意的是,内层的定义的参数实体% 需要进行HTML转义,否则会出现解析错误。

    <?xml version="1.0"?>
    <!DOCTYPE test [
        <!ENTITY % outside '<!ENTITY &#x25; files SYSTEM "file:///etc/passwd">'>
    ]>
    <message>&normal;</message>

     内部实体声明

    一般实体

    一般实体
    <?xml version="1.0"?>
    <!DOCTYPE test [
        <!ENTITY writer "Bill Gates">
        <!ENTITY copyright "Copyright W3School.com.cn">
    ]>
    <test>&writer;&copyright;</test>
    
    

    参数实体 

    <?xml version="1.0"?>
    <!DOCTYPE test [
        <!ENTITY %writer "Bill Gates">
        <!ENTITY %copyright "Copyright W3School.com.cn">
    ]>
    <test>%writer;%copyright;</test>

     外部实体声明

    一般实体

    <?xml version="1.0"?>
    <!DOCTYPE test [
        <!ENTITY  writer  SYSTEM  "http://www.w3school.com.cn/dtd/entities.dtd">
        <!ENTITY  copyright  SYSTEM  "http://www.w3school.com.cn/dtd/entities.dtd">
    ]>
    <author>&writer;&copyright;</author>

    参数实体 

    <?xml version="1.0"?>
    <!DOCTYPE test [
        <!ENTITY  %writer  SYSTEM  "http://www.w3school.com.cn/dtd/entities.dtd">
        <!ENTITY  %copyright  SYSTEM  "http://www.w3school.com.cn/dtd/entities.dtd">
    ]>
    <author>%writer;%copyright;</author>

    JSON

    JSON全称JavaScaript对象表示法(JavaScript Object Notation),是存储和交换文本信息的语法。具有文本量更小、更快和更易解析的特点。Json和HTML不一样,HTML主要用于显示数据,JSON主要用于传递数据,所以一般作为数据的查询接口。

    在 JS 语言中,一切都是对象。因此,任何支持的类型都可以通过 JSON 来表示,例如字符串、数字、对象、数组等。对象和数组是比较特殊且常用的两种类型:

    • 对象表示为键值对
    • 数据由逗号分隔
    • 花括号保存对象
    • 方括号保存数组

    JSON键值对表 

    { "name":"xie",
      "sex" :"man",
      "id" : "66" }
    
    注意: ""和值之间不能有空格,不然取值的时候会出错

    JSON数组

    表示一:
    [ { "name":"xie",
        "sex" :"man",
        "id" : "66" },
      { "name":"xiao",
        "sex" :"woman",
        "id" : "88" },
      { "name":"hong",
        "sex" :"woman",
        "id" : "77" }]
    
    表示二:
    {
      "name":["xie","xiao","hong"],
      "sex" :["man","woman","woman"],
      "id"  :["66","88","77"]
    }
    
    表示三:
    {
       "student":[ { "name":"xie",
                     "sex" :"man",
                     "id" : "66" },
                   { "name":"xiao",
                     "sex" :"woman",
                     "id" : "88" },
                   { "name":"hong",
                     "sex" :"woman",
                     "id" : "77" }]
    }

    使用python解析JSON数据

    对于表示法一和表示法二方法表示的JSON数据,可以采用下面方法读取JSON数据

    1.json是上面的表示法一 ,2.json是上面的表示法二。可以看出,虽然数据是一样的,但是数据读取出来的排序是不一样的。

    查询列的话直接 ['name']  ,查询行的话data.iloc[0] 表示第一行,或者 data.loc['1'] 表示打印出行名1的那行

    而对于表示法三表示的数据,则可以通过下面的方法读取。把数据读取在 jsonObject 对象中,然后访问数据的话,一层一层的访问。

    jsonString是JSON的字符串格式数据,如果没有解码,调用decode() 函数即可

    json.loads( jsonString )

    XML和JSON的区别 

    XML的优缺点

    XML的优点:

    • 格式统一,符合标准;
    • 容易与其他系统进行远程交互,数据共享比较方便。

    XML的缺点:

    • XML文件庞大,文件格式复杂,传输占带宽;
    • 服务器端和客户端都需要花费大量代码来解析XML,导致服务器端和客户端代码变得异常复杂且不易维护;
    • 客户端不同浏览器之间解析XML的方式不一致,需要重复编写很多代码;
    • 服务器端和客户端解析XML花费较多的资源和时间。

    JSON的优缺点

    JSON的优点:

    • 数据格式比较简单,易于读写,格式都是压缩的,占用带宽小;
    • 易于解析,客户端JavaScript可以简单的通过eval()进行JSON数据的读取;
    • 支持多种语言,包括ActionScript, C, C#, ColdFusion, Java, JavaScript, Perl, PHP, Python, Ruby等服务器端语言,便于服务器端的解析;
    • 在PHP世界,已经有PHP-JSON和JSON-PHP出现了,偏于PHP序列化后的程序直接调用,PHP服务器端的对象、数组等能直接生成JSON格式,便于客户端的访问提取;
    • 因为JSON格式能直接为服务器端代码使用,大大简化了服务器端和客户端的代码开发量,且完成任务不变,并且易于维护。

    JSON的缺点:

    • 没有XML格式这么推广的深入人心和喜用广泛,没有XML那么通用性;
    • JSON格式目前在Web Service中推广还属于初级阶段。

    相关文章:XXE(XML外部实体注入)

                     XXE漏洞利用

    展开全文
  • VB.NET XML和JSON序列化与反序列化,根据实体类可以快速解析XML和json文件,和生成xml,json文件
  • XML和JSON区别

    2016-07-24 19:20:04
    XML和JSON区别

    XML和JSON区别

    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>.DOMDOM是把一个数据交换格式XML看成一个DOM对象,需要把XML文件整个读入内存,这一点上JSON和XML的原理是一样的,但是XML要考虑父节点和子节点,这一点上JSON的解析难度要小很多,因为JSON构建于两种结构:key/value,键值对的集合;值的有序集合,可理解为数组;

    <2>.SAXSAX不需要整个读入文档就可以对解析出的内容进行处理,是一种逐步解析的方法。程序也可以随时终止解析。这样,一个大的文档就可以逐步的、一点一点的展现出来,所以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都使用结构化方法来标记数据,下面来做一个简单的比较。

    [
    {
    "length" : "12",
    "url" : "http:\/\/127.0.0.1\/resources\/videos\/minion_01.mp4",
    "image" : "http:\/\/127.0.0.1\/resources\/images\/minion_01.png",
    "ID" : "01",
    "name" : "小黄人 第01部"
    },
    {
    "length" : "14",
    "url" : "http:\/\/127.0.0.1\/resources\/videos\/minion_02.mp4",
    "image" : "http:\/\/127.0.0.1\/resources\/images\/minion_02.png",
    "ID" : "02",
    "name" : "小黄人 第02部"
    },
    {
    "length" : "16",
    "url" : "http:\/\/127.0.0.1\/resources\/videos\/minion_03.mp4",
    "image" : "http:\/\/127.0.0.1\/resources\/images\/minion_03.png",
    "ID" : "03",
    "name" : "小黄人 第03部"
    },
    {
    "length" : "18",
    "url" : "http:\/\/127.0.0.1\/resources\/videos\/minion_04.mp4",
    "image" : "http:\/\/127.0.0.1\/resources\/images\/minion_04.png",
    "ID" : "04",
    "name" : "小黄人 第04部"
    },
    {
    "length" : "20",
    "url" : "http:\/\/127.0.0.1\/resources\/videos\/minion_05.mp4",
    "image" : "http:\/\/127.0.0.1\/resources\/images\/minion_05.png",
    "ID" : "05",
    "name" : "小黄人 第05部"
    },
    {
    "length" : "22",
    "url" : "http:\/\/127.0.0.1\/resources\/videos\/minion_06.mp4",
    "image" : "http:\/\/127.0.0.1\/resources\/images\/minion_06.png",
    "ID" : "06",
    "name" : "小黄人 第06部"
    },
    {
    "length" : "24",
    "url" : "http:\/\/127.0.0.1\/resources\/videos\/minion_07.mp4",
    "image" : "http:\/\/127.0.0.1\/resources\/images\/minion_07.png",
    "ID" : "07",
    "name" : "小黄人 第07部"
    },
    {
    "length" : "26",
    "url" : "http:\/\/127.0.0.1\/resources\/videos\/minion_08.mp4",
    "image" : "http:\/\/127.0.0.1\/resources\/images\/minion_08.png",
    "ID" : "08",
    "name" : "小黄人 第08部"
    },
    {
    "length" : "28",
    "url" : "http:\/\/127.0.0.1\/resources\/videos\/minion_09.mp4",
    "image" : "http:\/\/127.0.0.1\/resources\/images\/minion_09.png",
    "ID" : "09",
    "name" : "小黄人 第09部"
    },
    {
    "length" : "30",
    "url" : "http:\/\/127.0.0.1\/resources\/videos\/minion_10.mp4",
    "image" : "http:\/\/127.0.0.1\/resources\/images\/minion_10.png",
    "ID" : "10",
    "name" : "小黄人 第10部"
    },
    {
    "length" : "32",
    "url" : "http:\/\/127.0.0.1\/resources\/videos\/minion_11.mp4",
    "image" : "http:\/\/127.0.0.1\/resources\/images\/minion_11.png",
    "ID" : "11",
    "name" : "小黄人 第11部"
    },
    {
    "length" : "34",
    "url" : "http:\/\/127.0.0.1\/resources\/videos\/minion_12.mp4",
    "image" : "http:\/\/127.0.0.1\/resources\/images\/minion_12.png",
    "ID" : "12",
    "name" : "小黄人 第12部"
    },
    {
    "length" : "36",
    "url" : "http:\/\/127.0.0.1\/resources\/videos\/minion_13.mp4",
    "image" : "http:\/\/127.0.0.1\/resources\/images\/minion_13.png",
    "ID" : "13",
    "name" : "小黄人 第13部"
    },
    {
    "length" : "38",
    "url" : "http:\/\/127.0.0.1\/resources\/videos\/minion_14.mp4",
    "image" : "http:\/\/127.0.0.1\/resources\/images\/minion_14.png",
    "ID" : "14",
    "name" : "小黄人 第14部"
    },
    {
    "length" : "40",
    "url" : "http:\/\/127.0.0.1\/resources\/videos\/minion_15.mp4",
    "image" : "http:\/\/127.0.0.1\/resources\/images\/minion_15.png",
    "ID" : "15",
    "name" : "小黄人 第15部"
    },
    {
    "length" : "42",
    "url" : "http:\/\/127.0.0.1\/resources\/videos\/minion_16.mp4",
    "image" : "http:\/\/127.0.0.1\/resources\/images\/minion_16.png",
    "ID" : "16",
    "name" : "小黄人 第16部"
    }
    ]

    XML

    <?xml version="1.0" encoding="UTF-8"?>

    <vedios>
    <vedio ID = "01" name = "小黄人 第01部" length = "12" image = "http://127.0.0.1/resources/images/minion_01.png" url = "http://127.0.0.1/resources/videos/minion_01.mp4" />
    <vedio ID = "02" name = "小黄人 第02部" length = "14" image = "http://127.0.0.1/resources/images/minion_02.png" url = "http://127.0.0.1/resources/videos/minion_02.mp4" />
    <vedio ID = "03" name = "小黄人 第03部" length = "16" image = "http://127.0.0.1/resources/images/minion_03.png" url = "http://127.0.0.1/resources/videos/minion_03.mp4" />
    <vedio ID = "04" name = "小黄人 第04部" length = "18" image = "http://127.0.0.1/resources/images/minion_04.png" url = "http://127.0.0.1/resources/videos/minion_04.mp4" />
    <vedio ID = "05" name = "小黄人 第05部" length = "10" image = "http://127.0.0.1/resources/images/minion_05.png" url = "http://127.0.0.1/resources/videos/minion_05.mp4" />
    <vedio ID = "06" name = "小黄人 第06部" length = "12" image = "http://127.0.0.1/resources/images/minion_06.png" url = "http://127.0.0.1/resources/videos/minion_06.mp4" />
    <vedio ID = "07" name = "小黄人 第07部" length = "16" image = "http://127.0.0.1/resources/images/minion_07.png" url = "http://127.0.0.1/resources/videos/minion_07.mp4" />
    <vedio ID = "08" name = "小黄人 第08部" length = "18" image = "http://127.0.0.1/resources/images/minion_08.png" url = "http://127.0.0.1/resources/videos/minion_08.mp4" />
    <vedio ID = "09" name = "小黄人 第09部" length = "20" image = "http://127.0.0.1/resources/images/minion_09.png" url = "http://127.0.0.1/resources/videos/minion_09.mp4" />
    <vedio ID = "10" name = "小黄人 第10部" length = "12" image = "http://127.0.0.1/resources/images/minion_10.png" url = "http://127.0.0.1/resources/videos/minion_10.mp4" />
    <vedio ID = "11" name = "小黄人 第11部" length = "13" image = "http://127.0.0.1/resources/images/minion_11.png" url = "http://127.0.0.1/resources/videos/minion_11.mp4" />
    <vedio ID = "12" name = "小黄人 第12部" length = "12" image = "http://127.0.0.1/resources/images/minion_12.png" url = "http://127.0.0.1/resources/videos/minion_12.mp4" />
    <vedio ID = "13" name = "小黄人 第13部" length = "11" image = "http://127.0.0.1/resources/images/minion_13.png" url = "http://127.0.0.1/resources/videos/minion_13.mp4" />
    <vedio ID = "14" name = "小黄人 第14部" length = "15" image = "http://127.0.0.1/resources/images/minion_14.png" url = "http://127.0.0.1/resources/videos/minion_14.mp4" />
    <vedio ID = "15" name = "小黄人 第15部" length = "14" image = "http://127.0.0.1/resources/images/minion_15.png" url = "http://127.0.0.1/resources/videos/minion_15.mp4" />
    <vedio ID = "16" name = "小黄人 第16部" length = "18" image = "http://127.0.0.1/resources/images/minion_16.png" url = "http://127.0.0.1/resources/videos/minion_16.mp4" />
    </vedios>


    编码的可读性来说,XML有明显的优势,毕竟人类的语言更贴近这样的说明结构。JSON读起来更像一个数据块,读起来就比较费解了。不过,我们读起来费解的语言,恰恰是适合机器阅读,所以通过JSON的索引country.provinces[0].name就能够读取“黑龙江”这个值。编码的手写难度来说,XML还是舒服一些,好读当然就好写。不过写出来的字符JSON就明显少很多。去掉空白制表以及换行的话,JSON就是密密麻麻的有用数据,而XML却包含很多重复的标记字符。


    展开全文
  • 本文实例讲述了python中xml和json格式相互转换操作。分享给大家供大家参考,具体如下:python中xml和json格式是可以互转的,就像json格式转python字典对象那样。xml格式和json格式互转用到的xmltodict库安装...
  • Spring REST XML和JSON示例

    2019-03-11 01:54:33
    Spring REST XML和JSON示例 欢迎使用Spring Restful Web Services XML和JSON示例。有一段时间我写了一篇关于Spring REST JSON的文章,我收到很多评论,询问如何更改程序以支持XML。我收到了一些电子邮件,询问...
  • Java xml和json相互转换1. maven依赖org.jsonjson201808132. 使用示例import org.json.JSONObject;import org.json.XML;/*** json xml互转** @author yh* @version 2019/6/11 上午 10:45*/public final class ...
  • XML和JSON的比较

    2020-06-03 12:07:36
    XML和JSON的比较 XML与JSON都可以用来描述或者存储数据,两者都有各自的优点,使用场景取决于需求。 描述 XML 可扩展标记语言Extensible Markup Language,是一种用于标记电子文件使其具有结构性的标记语言,可以...
  • XML和JSON类型数据

    2018-08-12 22:44:33
    xml和 json是经常被我们用来解析的数据类型,在这里记录一下xml和 json数据格式 XML (可扩展标记语言) 什么是XML? * XML全称是可扩展标记语言。 * XML设计用来传输数据,HTML用来显示数据。 * XML的标签...
  • 本文实例讲述了Python中xml和json格式相互转换操作。分享给大家供大家参考,具体如下:Python中xml和json格式是可以互转的,就像json格式转Python字典对象那样。xml格式和json格式互转用到的xmltodict库安装...
  • 本文实例讲述了Python中xml和json格式相互转换操作。分享给大家供大家参考,具体如下:Python中xml和json格式是可以互转的,就像json格式转Python字典对象那样。xml格式和json格式互转用到的xmltodict库安装...
  • 关于XML和JSON

    2016-06-28 09:24:18
    本文主要是对XML和JSON的简要介绍,大部分内容摘自“tcpipstack”的“10分钟掌握XML、JSON及其解析”。 XML 1.XML即可扩展标记语言(eXtensible Markup Languange)。是一种数据描述语言,主要用于数据的传输和存储...
  • go 操作xml json

    2018-07-12 22:16:07
    go 操作xml json 分别使用 encoding/xml encoding/json 来实现 下面我们通过代码来讲解一下go 操作xml 文件 json 格式数据 读取xml 假设我有一个xml 文件如下 C:\\Users\\admin\\go\\src\\...
  • 安卓中的XML和JSON

    千次阅读 2019-04-10 20:10:16
    XML和JSON其实还是比较常见了,JAVASE和JAVAEE的学习中或多或少会有些接触的,这篇文章主要关于XML和JSON在安卓中的一些应用。 XML 概述 XML是一种常用的存储数据方式,设计初衷就是为了传输和存储数据。 在...
  • XML和JSON瞎掰

    2016-04-08 11:48:00
    XML和JSON瞎掰XML 跟 JSON 的圣战,或许会成为自 vim/emacs 圣战,cli/gui 圣战等等圣战以来的又一个圣战,而所有的圣战大抵都不会有结果,因为每方都有各自的道理,谁都不服谁。在我看来,XML 更适合数据定义,数据...
  • 文章目录XML和JSON1. XML1.1 概述1.2 XML语法1.2.1 基本语法1.2.2 语法进阶CDATA2. Java解析XML2.1 SAX解析2.2 DOM解析2.3 JDOM解析2.4 DOM4J解析2.4.1 DOM4J解析XML2.4.2 DOM4J - XPATH解析XML3. Java生成XML3.1 ...
  • XML和JSON的特点

    2016-08-18 10:14:52
    XML和JSON的特点 今天说一说XML和JSON的特点,为一些初学者。。 Xml特点: 1.有且只有一个根节点 2.是数据传输的载体 3.所有的标签都需要自定义 4.是纯文本的文件 Json(JavaScript Object Notation)...
  • HTML、XML和JSON 汇总

    2020-02-22 14:28:54
    阅读目录1.... XML语言2.1 XML的特点2.2 ...3.3 XML和JSON对比 写在前面:楼主也是刚刚接触这方面的知识,之前完全是零基础,后来经朋友推荐了几个不错的博文,看完以后豁然开朗。但是此博文更...
  • JAVA学习之XML和JSON

    2020-09-10 23:49:22
    XML和JSON 一、概念 又称为可扩展性语言 特点:与平台无关的独立标记语言。并且具有自我描述性。 注意: .XML文件是保存XML数据的一种方式 XML数据也可以以其他的方式存在(如在内存中构建XML数据)。 不要将XML...
  • xml和json的相互转换

    2016-12-08 13:51:17
    xml和json的相互转换 class xmljson{ /** * xml to json */ public static function xml_to_json($source,$add='xml') { if(is_file($source)){ //传的是文件,还是xml的string的判断 $xm
  • Java xml和json互转

    2019-09-13 19:38:05
    Java xml和json相互转换 1. maven依赖 <dependency> <groupId>org.json</groupId> <artifactId>json</artifactId> ...
  • 数据交换格式之XML和JSON

    千次阅读 2018-03-07 14:44:49
    学习知识点XML和JSON一、什么是数据交换格式客户端与服务器常用数据交换格式xml、json、html二、数据交换格式应用场景移动端(安卓、IOS)通讯方式采用http协议+JSON格式走restful风格。很多互联网项目都采用Http协议+...
  • XML和JSON的区别

    2016-06-15 09:38:46
    XML和JSON的区别?(1).数据体积方面。 JSON相对于XML来讲,数据的体积小,传递的速度更快些。 (2).数据交互方面。 JSON与JavaScript的交互更加方便,更容易解析处理,更好的数据交互。 (3).数据描述方面。 JSON...
  • XML和JSON的获取和生成

    2018-05-22 23:59:55
    指可扩展标记语言 是一种标记语言,很类似 HTML今天主要学习了xml和json的生成和获取 xml的获取 例如 我们需要查询手机号的所属地址 那么我们就注册了一个k780的账号从里面 获取它的xml数据 &lt;?php ...
  • xml和json之间的关系

    2017-11-03 16:20:56
    xml和json之间的关系第1章 接口数据格式 编号 格式 样例 用途 01 无规律文本 02 预定义位置含义 0-10位姓名,不足左/右补空格或0;11-15位年龄,不足左/右补空格或0 03 键值对 name=张三&age=23 ...
  • org.json XML和Json互转

    千次阅读 2015-01-13 14:53:59
    org.json包里有一个类org.json.XML可以实现XML和JSON之间的转换。 http://www.json.org/javadoc/org/json/XML.html @Test public void testExcute1() throws JSONException { JSONObject json = XML....
  • sql查询结果转XML和JSON

    2017-07-06 13:27:54
    sql查询结果转XML和JSON

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,576
精华内容 8,630
关键字:

xml和json