网络下的数据传输之XML数据的解析

最新推荐文章于 2023-12-01 12:15:56 发布
最新推荐文章于 2023-12-01 12:15:56 发布
阅读量5.3k 收藏 7
点赞数 2
分类专栏： Android基础 文章标签： xml javascript 数据 网络 语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_dsw/article/details/49475237
版权

网络下的数据传输之XML数据的解析

在app应用开发中，网络的使用无处不在，所以涉及到手机端与后台的数据交互也必然存在。主要存在以下两种格式的数据：XML和Json。

概述

1、XML简介
XML（Extensible Markup Language）可扩展标记语言，一种标准通用的语言。它通过一些简单的标签进行描述数据，从而达到数据传输的目的。
2、JSON简介
JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。它基于ECMAScript的一个子集。 JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯（包括C、C++、C#、Java、JavaScript、Perl、Python等）。这些特性使JSON成为理想的数据交换语言。 易于人阅读和编写，同时也易于机器解析和生成(一般用于提升网络传输速率)。

数据的解析

1、XML解析
在Android中，常见的XML解析器分别为SAX解析器、DOM解析器和PULL解析器。后面会分别介绍。
2、JSON解析
JSON的解析可以借助gson.jar包进行接下。

XML的解析

我们建立下面的xml文件用于测试：

<?xml version="1.0" encoding="utf-8"?>
    <books>
        <book>
            <name>Android源码设计模式解析与实战</name>
            <author>何红辉、关爱民</author>
            <price>79.0</price>
        </book>
        <book>
            <name>Android开发艺术探索</name>
            <author>任玉刚</author>
            <price>66.2</price>
        </book>
        <book>
            <name>Android群英传</name>
            <author>徐宜生</author>
            <price>49.0</price>
        </book>
    </books>
一、使用DOM解析器解析XML

DOM（Document Object Model）一种用于XML文档的对象模型，可用于直接访问XML文档的任何部分。在DOM中将真个文档加载进内存，文档被解析成树状模型。所以，我们可以通过api接口遍历整个文档来进行需要的读取。在DOM解析器下，我们需要了解以下概念：
1、节点

  • 整个文档是一个文档节点
  • 每个XML标签是一个元素节点
  • 包含在XML元素中的文本是文本节点
  • 每一个XML属性是一个属性节点

2、常见节点类型：

  • Node:DOM基本数据类型
  • Element：最主要的处理对象
  • Attr：代表元素的属性
  • Text：一个Element或Attr的内容
  • Document:代表整个文档对象

dom

我们建立名称为DataXMLParse的module。下面开始我们的具体开发步骤：
1、根据books.xml文件，建立一个对应的实体类。

<?xml version="1.0" encoding="utf-8"?>
    <books>
        <book>
            <icon>hhh</icon>
            <name>Android源码设计模式解析与实战</name>
            <author>何红辉、关爱民</author>
            <price>79.0</price>
        </book>
        <book>
            <icon>ryg</icon>
            <name>Android开发艺术探索</name>
            <author>任玉刚</author>
            <price>66.2</price>
        </book>
        <book>
            <icon>xys</icon>
            <name>Android群英传</name>
            <author>徐宜生</author>
            <price>49.0</price>
        </book>
    </books>

2、有了我们的xml数据，我们想把它解析出来用ListView进行显示。
(1)、创建T_BookEntity实体，用于存储我们解析的数据。

package dsw.com.androidnedemo;

    /**
     * Created by dsw on 2015/10/27.
     */
    public class T_BookEntity{
        private String name;
        private String author;
        private String price;
        private String iconId;

        public String getIconId() {
            return iconId;
        }

        public void setIconId(String iconId) {
            this.iconId = iconId;
        }

        public String getAuthor() {
            return author;
        }

        public void setAuthor(String author) {
            this.author = author;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getPrice() {
            return price;
        }

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

（2）、实体创建完毕，我们就开始进行解析，按照我们上面的分析流程图，我们创建一个名为DataParseUtils类进行封装解析xml文件的方法。

public class DataParseUtils {

    public static List<T_BookEntity> DomXMLUtils(InputStream inputStream){
        List<T_BookEntity> list = new ArrayList<>();
        T_BookEntity t_bookEntity;
        //创建DocumentBuilderFactory对象
        DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
        try {
            //创建DocumentBuilder对象进行创建Document对象
            DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
            //创建一个Document对象
            Document document = documentBuilder.parse(inputStream);
            //获取根节点
            Element element = document.getDocumentElement();
            //获取所有名为book的子节点
            NodeList nodeList = element.getElementsByTagName("book");
            //遍历获取的节点集合
            for(int i=0;i<nodeList.getLength();i++){
                t_bookEntity = new T_BookEntity();
                Element nodeBook = (Element) nodeList.item(i);
                //遍历book节点下的子节点，然后遍历获取属性值
                NodeList nodeChildes = nodeBook.getChildNodes();
                for(int index = 0;index < nodeChildes.getLength();index++){
                    Node childNode = nodeChildes.item(index);
                    if(childNode.getNodeType() == Node.ELEMENT_NODE){
                        if("name".equals(childNode.getNodeName())){
                            t_bookEntity.setName(childNode.getFirstChild().getNodeValue());
                        }else if("author".equals(childNode.getNodeName())){
                            t_bookEntity.setAuthor(childNode.getFirstChild().getNodeValue());
                        }else if("price".equals(childNode.getNodeName())){
                            t_bookEntity.setPrice(childNode.getFirstChild().getNodeValue());
                        }else if("icon".equals(childNode.getNodeName())){
                            t_bookEntity.setIconId(childNode.getFirstChild().getNodeValue());
                        }
                    }
                }
                list.add(t_bookEntity);
            }
        } catch (ParserConfigurationException e) {
            e.printStackTrace();
        } catch (SAXException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return list;
     }
    }

在上面的方法中，我们通过getChildNodes()方法进行遍历节点解析数据，通过getNodeValue()方法获取节点的值，然后存储到对应的实体中，最后返回一个集合到activity中进行处理。

3、MainActivity中的处理，以及Adapter的写法：
（1）、MainActivity的处理：

public class MainActivity extends AppCompatActivity {
        private ListView mListView;
        private List<T_BookEntity> list;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            initListData();
            mListView = (ListView) findViewById(R.id.listView);
            mListView.setAdapter(new ListViewAdapter(getApplication(),list));
        }

        private void initListData(){
            String dataPath = "/data/data/dsw.com.androidnedemo/books.xml";
            try {
                InputStream is = new FileInputStream(dataPath);
                list = DataParseUtils.DomXMLUtils(is);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }
    }

我们将xml文件当道data/data对应的文件夹下，然后通过上面的解析方法进行解析。

（2）、Adapter的源码以及xml布局文件。

public class ListViewAdapter extends BaseAdapter {
        private Context mContext;
        private List<T_BookEntity> list;
        private ViewHolder viewHolder;
        public ListViewAdapter(Context context,List<T_BookEntity> list){
            this.mContext = context;
            this.list = list;
        }
        @Override
        public int getCount() {
            return list == null ? 0 :list.size();
        }

        @Override
        public Object getItem(int position) {
            return list == null ? null :list.get(position);
        }

        @Override
        public long getItemId(int position) {
            return position;
        }

        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            if(convertView == null || convertView.getTag() == null){
                viewHolder = new ViewHolder();
                convertView = LayoutInflater.from(mContext).inflate(R.layout.book_item,null);
                viewHolder.iv_icon = (ImageView) convertView.findViewById(R.id.iv_icon);
                viewHolder.tv_name = (TextView) convertView.findViewById(R.id.tv_name);
                viewHolder.tv_author = (TextView) convertView.findViewById(R.id.tv_author);
                viewHolder.tv_price = (TextView) convertView.findViewById(R.id.tv_price);
            }else{
                viewHolder = (ViewHolder) convertView.getTag();
            }

            int id = mContext.getResources().getIdentifier(list.get(position).getIconId(),
                    "mipmap","dsw.com.androidnedemo");
            viewHolder.iv_icon.setBackgroundResource(id);
            viewHolder.tv_name.setText(list.get(position).getName());
            viewHolder.tv_author.setText(list.get(position).getAuthor());
            viewHolder.tv_price.setText(list.get(position).getPrice());
            return convertView;
        }

        private static class ViewHolder{
            public ImageView iv_icon;
            public TextView tv_name;
            public TextView tv_author;
            public TextView tv_price;
        }
    }

xml布局文件：

<?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:orientation="horizontal"
        android:padding="10dp"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:gravity="center_vertical">
        <ImageView
            android:id="@+id/iv_icon"
            android:layout_width="50dp"
            android:layout_height="50dp"
            android:layout_marginRight="10dp"
            android:layout_centerVertical="true"
            android:background="@mipmap/hhh"/>
        <LinearLayout
            android:id="@+id/linear"
            android:layout_alignParentRight="true"
            android:layout_marginLeft="10dp"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_centerVertical="true"
            android:orientation="vertical">
            <TextView
                android:id="@+id/tv_author"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="何红辉、关爱民"
                android:textSize="15sp"/>
            <TextView
                android:id="@+id/tv_price"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="79.0"
                android:gravity="right"
                android:textSize="15sp"/>
        </LinearLayout>
        <TextView
            android:id="@+id/tv_name"
            android:layout_toRightOf="@id/iv_icon"
            android:layout_toLeftOf="@id/linear"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_centerVertical="true"
            android:text="Android源码设计模式解析与实战"
            android:textSize="17sp"/>
    </RelativeLayout>

至此，我们的所有解析工作已经完成。看下dom解析做出来的效果图：
domresult

二、使用SAX解析器解析XML

1、SAX概述
SAX是一种以事件为驱动的解析方法，由它定义的事件流可以指定从解析器传到专门的处理代码。特点是解析速度快，占用内存少。所以特别适合android移动设备。

SAX 允许您在读取文档时处理它，从而不必等待整个文档被存储之后才采取操作。它不涉及 DOM 所必需的开销和概念跳跃。 SAX API是一个基于事件的API ，适用于处理数据流，即随着数据的流动而依次处理数据。SAX API
在其解析您的文档时发生一定事件的时候会通知您。SAX API中主要有四种处理事件的接口，它们分别是ContentHandler，DTDHandler， EntityResolver 和 ErrorHandler 。我们只需要继承DefaultHandler，然后去重写对应的方法即可。主要有：

  • startDocument()方法只会在文档开始解析的时候被调用，每次解析只会调用一次。
  • startElement()方法每次在开始解析一个元素，即遇到元素标签开始的时候都会调用。
  • characters()方法也是在每次解析到元素标签携带的内容时都会调用，即使该元素标签的内容为空或换行。而且如果元素内嵌套元素，在父元素结束标签前， characters()方法会再次被调用，此处需要注意。
  • endElement()方法每次在结束解析一个元素，即遇到元素标签结束的时候都会调用。
  • endDocument() startDocument()方法只会在文档解析结束的时候被调用，每次解析只会调用一次。

解析来，我们就用SAX方法解析我们上面的books.xml文件。我们在DataXMLParse工程中创建名为SAXParseHandler的类。

/**
     * Created by dsw on 2015/10/28.
     */
    public class SAXParseHandler extends DefaultHandler {
        //存储解析返回的集合
        private List<T_BookEntity> list;
        //记录当前节点
        private T_BookEntity t_bookEntity;
        //用来存放每次遍历后的元素名称(节点名称)
        private String tagName;
        /**
         * 只调用一次，在文档开始解析的时候，可用于初始化一些变量
         * @throws SAXException
         */
        @Override
        public void startDocument() throws SAXException {
            list = new ArrayList<>();
        }

        /**
         * 解析xml文件的元素，调用多次
         * @param uri
         * @param localName
         * @param qName
         * @param attributes
         * @throws SAXException
         */
        @Override
        public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
            if("book".equals(qName)){//是book节点就创建一个实体存储
                if(t_bookEntity == null)
                t_bookEntity = new T_BookEntity();
            }
            //记录当前tag，后面用于判断
            tagName = qName;
        }

        /**
         * 调用多次，
         * @param ch
         * @param start
         * @param length
         * @throws SAXException
         */
        @Override
        public void characters(char[] ch, int start, int length) throws SAXException {
            String data = new String(ch,start,length);
            if(tagName != null && !data.trim().equals("")){
                if("name".equals(tagName)){
                    t_bookEntity.setName(data);
                }else if("author".equals(tagName)){
                    t_bookEntity.setAuthor(data);
                }else if("price".equals(tagName)){
                    t_bookEntity.setPrice(data);
                }else if("icon".equals(tagName)){
                    t_bookEntity.setIconId(data);
                }
            }

        }

        /**
         * 解析完一个标签结束时调用
         * @param uri
         * @param localName
         * @param qName
         * @throws SAXException
         */
        @Override
        public void endElement(String uri, String localName, String qName) throws SAXException {
            if("book".equals(qName)){//遍历完一个节点
                list.add(t_bookEntity);
                t_bookEntity = null;
            }
            tagName = null;
        }

        /**
         * 文档解析结束时调用，调用一次
         * @throws SAXException
         */
        @Override
        public void endDocument() throws SAXException {
            super.endDocument();
        }

        public List<T_BookEntity> getList() {
            return list;
        }
    }

这样就完成了我们解析器的编写，下面就是我们如何使用了。

  /**
     * 通过SAX方法进行解析
     */
    private void userSAXParser(){
        SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
        try {
            String dataPath = "/data/data/dsw.com.androidnedemo/books.xml";
            SAXParser saxParser = saxParserFactory.newSAXParser();
            //实例化我们的SAXParseHandler对象
            SAXParseHandler saxParseHandler = new SAXParseHandler();
            //加载资源转换成流
            InputStream inputStream = new FileInputStream(dataPath);
            saxParser.parse(inputStream,saxParseHandler);
            list = saxParseHandler.getList();
        } catch (ParserConfigurationException e) {
            e.printStackTrace();
        } catch (SAXException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

效果图：
domresult

三、使用SAX解析器解析XML

Pull解析器和SAX解析器虽有区别但也有相似性。他们的区别为：SAX解析器的工作方式是自动将事件推入注册的事件处理器进行处理；而Pull解析器的工作方式为允许你的应用程序代码主动从解析器中获取事件，正因为是主动获取事件，因此可以在满足了需要的条件后不再获取事件，结束解析。这是他们主要的区别。

我们同样在DataParseUtils类中增加一个PullXMLUtils方法。

  /**
     * 通过PullParser方式解析
     * @param inputStream
     * @return
     */
    public static List<T_BookEntity> PullXMLUtils(InputStream inputStream,String encode){
        List<T_BookEntity> list = null;
        T_BookEntity t_bookEntity = null;
        XmlPullParserFactory xmlPullParserFactory = null;
        try {
            //创建PullParserFactory构造器
            xmlPullParserFactory = XmlPullParserFactory.newInstance();
            //创建XmlPullParser解析器，或者通过xmlPullParser = Xml.newPullParser();
            XmlPullParser xmlPullParser = xmlPullParserFactory.newPullParser();
            //设置我们的数据流
            xmlPullParser.setInput(inputStream,encode);
            //获取节点类型
            int type = xmlPullParser.getEventType();
            while(type != XmlPullParser.END_DOCUMENT){
                switch (type){
                    case XmlPullParser.START_DOCUMENT:
                        list = new ArrayList<>();
                        break;
                    case XmlPullParser.START_TAG:
                        if("book".equals(xmlPullParser.getName())){//是book的起始标签
                            t_bookEntity = new T_BookEntity();
                        }else if("name".equals(xmlPullParser.getName())){
                            t_bookEntity.setName(xmlPullParser.nextText());
                        }else if("author".equals(xmlPullParser.getName())){
                            t_bookEntity.setAuthor(xmlPullParser.nextText());
                        }else if("price".equals(xmlPullParser.getName())){
                            t_bookEntity.setPrice(xmlPullParser.nextText());
                        }else if("icon".equals(xmlPullParser.getName())){
                            t_bookEntity.setIconId(xmlPullParser.nextText());
                        }
                        break;
                    case XmlPullParser.END_TAG:
                        if("book".equals(xmlPullParser.getName())){//book结束标签
                            list.add(t_bookEntity);
                        }
                        break;
                    case XmlPullParser.END_DOCUMENT:
                        break;
                }
                type = xmlPullParser.next();
            }
        } catch (XmlPullParserException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return list;
    }

然后在MainActivity中调用。

 /**
     * 通过Pull方式进行解析xml
     */
    private void pullParserXml(){
        String dataPath = "/data/data/dsw.com.androidnedemo/books.xml";
        try {
            InputStream is = new FileInputStream(dataPath);
            list = DataParseUtils.PullXMLUtils(is, "utf-8");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

展示效果图同样使用ListView展示。
domresult

至此，我们已经学习完了XML的解析方法，三种方法，我个人认为还是使用Pull方法进行比较方便，同时在实际工作中，我也推荐大家使用Pull方法进行解析。另外补充一个知识点，以上我们都是对XML文件进行解析，所以补充的知识点就是对XML文件的序列本地化。例如下面的demo：

 /**
     * 进行XML文件的序列化
     * @param list
     * @param outputStream
     */
    private void XmlSerializerUtils(List<T_BookEntity> list,OutputStream outputStream){
        XmlSerializer xmlSerializer = Xml.newSerializer();
        try {
            xmlSerializer.setOutput(outputStream, "utf-8");
            xmlSerializer.startDocument("utf-8", true);
            xmlSerializer.startTag(null,"books");
            for(T_BookEntity t_bookEntity : list){
                xmlSerializer.startTag(null,"book");

                xmlSerializer.startTag(null,"icon");
                xmlSerializer.text(t_bookEntity.getIconId());
                xmlSerializer.endTag(null, "icon");

                xmlSerializer.startTag(null, "name");
                xmlSerializer.text(t_bookEntity.getName());
                xmlSerializer.endTag(null, "name");

                xmlSerializer.startTag(null, "author");
                xmlSerializer.text(t_bookEntity.getAuthor());
                xmlSerializer.endTag(null, "author");

                xmlSerializer.startTag(null, "price");
                xmlSerializer.text(t_bookEntity.getPrice());
                xmlSerializer.endTag(null,"price");

                xmlSerializer.endTag(null,"book");
            }
            xmlSerializer.endTag(null,"books");
            xmlSerializer.endDocument();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

分析三种方式：
1、占用内存
这是一个根本问题，由于Android系统对内存比较吃紧，所以xml的解析速度回直接影响程序的性能。SAX、Pull的解析方式占用内存比DOM方式少。

2、编程方式
1、SAX是一种事件驱动的方式，说白了就是通过重写父类的方法，然后进行处理。也就是说针对不同的xml文件需要编写不同的处理类，同时这样造成了有需要写大量的代码，不是很方便。Dom方式是W3C所规范的，所以是用比较广泛，它通过将xml文档解析称一种树的形式进行解析，所以比较消耗内存和时间。Pull方式是android系统独具的，代码编写比较简单，所以推荐使用。

上面，我们已经完成了网络数据传输中的XML文件的解析。下篇，我们讲解下在手机端与服务器交互的比较流行的一种数据格式解析Json。

作者：mr_dsw 欢迎转载，与人分享是进步的源泉！

转载请保留地址：http://blog.csdn.net/mr_dsw

Exploring1024
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
XML数据解析传送
qq_27622131的博客
07-21 176
xml
Android XML数据解析简单示例
09-04
总结起来，Android中的XML数据解析主要涉及以下几个步骤： 1. 获取XML资源。 2. 创建DOM解析器。 3. 解析XML数据到`Document`对象。 4. 通过DOM API访问和处理XML元素及属性。 DOM解析器适用于小到中等大小的XML...
c++ http服务器客户端程序-传输xml解析xml数据（3）
u011269801的专栏
04-24 586
1、服务器端的实例： #include "stdafx.h" #include <iostream> #include <chrono> #include <cstdio> #include "httplib.h" using namespace httplib; using namespace std; #include "pugixml/pugixml.cpp" struct xml_string_writer : pugi::xml_writer {
C++解析xml示例
最新发布
四儿家的小祖宗的博客
12-01 1424
Xml（Extensible Markup Language）即可扩展标记语言，Xml是互联网数据传输的重要工具，它可以跨越互联网任何的平台，不受编程语言和操作系统的限制，可以说它是一个拥有互联网最高级别通行证的数据携带者。Xml用于标记电子文件使其具有结构性的标记语言，可以用来标记数据、定义数据类型，是一种允许用户对自己的标记语言进行定义的源语言。Xml是标准通用标记语言（SGML）的子集，非常适合Web传输。Xml提供统一的方法来描述和交换独立于应用程序或供应商的结构化数据。
轻松定义自己的网络通讯协议
wdmboy的专栏
11-22 1533
每次编写设计网络通讯程序时，总面对一个问题，就是要自定义一组应用协议（即通讯协议），然后再写相应的方法来解析协议，并提供相应的接口供上层调用。如果只是简单的文本信息通讯还容易，但要交换一些控制信息或结构复杂的数据时，比如做联机游戏，更是让人头疼。最近突然想到一个点子，可以用对象串行化技术将对象直接转换为二进制数据发送，然后接收时直接还原为对象。具体过程是，将要发送的数据放在一个HashTabl
xml传递数据
weixin_44943389的博客
09-25 669
在前端和后端之间传递数据时，可以使用多种格式，其中之一就是使用 XML（eXtensible Markup Language）作为数据传输格式。总的来说，通过将数据转换成 XML 格式，你可以在前端和后端之间进行可靠的数据传输。然而，现在更常见的是使用 JSON 作为数据传输格式，因为它更轻量、易于处理，且在大多数情况下效率更高。首先，在前端，你可以将数据转换成 XML 格式，然后将其发送到后端。如果需要，后端可以生成一个新的 XML 文档作为响应，然后将其发送回前端。模块来解析 XML 数据。
语法篇--XML数据传输格式
qq_62377885的博客
08-20 2583
XML被发明的目的是传输和存储数据,而不是展示数据;XML的标签必须自定义，但是在写标签名的时候一定要有含义;
iOS开发使用XML解析网络数据
09-02
XML是一种结构化数据表示方式，常用于网络数据传输。本篇文章将主要介绍XML解析的基本概念以及在iOS中如何使用XML解析。 XML解析有两种主要方式： 1. DOM（Document Object Model）：这种解析方式会一次性加载整个...
Android XML数据的三种解析方式
09-01
Android XML 数据解析是Android开发中常见的一种数据处理方式，它主要用于读取和处理XML格式的配置文件或数据传输。XML（eXtensible Markup Language）是一种结构化数据表示语言，适用于存储和交换数据。在Android中...
xml.zip_iphone访问webservice视频_xml_数据解析
09-14
4. **XML数据解析**： - iOS提供了NSXMLParser类，可以逐事件地解析XML文档，如开始元素、结束元素、字符数据等。 - GDataXMLNode和GDataXMLDocument是Google提供的XML解析库，提供了更友好的API来查询和操作XML树...
从网络获取XML数据并且显示出来
04-08
从网络获取XMl数据并在客户端显示出来，包含web应用端和Android客户端以及需要的JAR包。
XML解决站点式远程监控系统的数据传输问题
08-05
解析器可以将XML数据转换为程序内部可以操作的形式，生成器则根据业务逻辑构造新的XML文档。 （6） 业务逻辑层这一层包含了具体的应用功能，如数据分析、报警处理、远程控制等。业务逻辑层根据XML文件控制层提供的...
XML 数据传输格式
ConorChan的博客
08-07 699
对XML 数据传输格式的认识
XML数据解析以及发送
Lin_林的博客
11-26 228
java 后端获取XML 数据方式 @RequestMapping(value ="/deliveryorder.create") @ResponseBody public String closeOrder1(HttpServletRequest request) throws JAXBException { // 获取HTTP请求的输入流 // 已HTTP请求输入流建立一个BufferedReader对象 BufferedRea...
java中xml进行报文发送和解析
半个西瓜的博客
01-06 8671
Java中xml进行报文发送和解析 利用OKhttp网络框架，进项Maven项目托管 //报文发送 <dependency> <groupId>com.squareup.okhttp3</groupId> <artifactId>okhttp</artifactId> <version>3....
android 解析网络xml数据,发送xml数据,解析json数据
懒人鱼
09-25 2400
video实体类 包含id title time字段  为这个demo提供网络数据的是自己写的一个j2ee工程, 主activity代码 package com.itcast.net_xml; import java.io.IOException; import java.util.ArrayList; import java.util.HashMap; import java.u
xml介绍与解析，及xml库包使用
求真、务实
05-11 1573
@ toc 参考1：https://docs.python.org/zh-cn/3/library/xml.html
XMPP 协议笔记 二 XML数据包
tigertang2的专栏
10-27 681
3. XMPP 核心数据包 XMPP 的核心数据包类型有Precense，Message，Iq ，此外加上初始化 stream 用到的 Stream 数据包。这些数据包是 XMPP 信息传输的载体，被用于 XMPP 核心功能和扩展功能的实现。 该部分仅对 XMPP 中使用的数据包进行概览，用于感受基于 XML 的数据包与其他非 XML 数据包协议的差别，不能替代 IETF 关于 XMP
读取xml数据
qq_44930716的博客
03-30 403
1.引两个包 <dependency> <groupId>dom4j</groupId> <artifactId>dom4j</artifactId> <version>1.6.1</version> </dependency> <dependency> &l

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值