Android 解析XML（3种方法）

最新推荐文章于 2024-08-16 14:19:18 发布
最新推荐文章于 2024-08-16 14:19:18 发布
阅读量831 收藏
点赞数 1
分类专栏： Android 文章标签： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dzzzheng95/article/details/57128869
版权

Android中的三种XML解析方式：

DOM （Android不推荐  因为会一次加载所有的文件）     
SAX  PULL （是边读边解析）

可以在云盘下载原代码：http://pan.baidu.com/s/1kVv5qRX

以下是个小demo： 效果图在下面：

–首先要在服务端生成XML
–生成XML要在 Eclipse 里编写（用的是SSH框架）

–Jsp代码： getData.jsp

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Insert title here</title>
</head>
<body>
    <a href="/front/fqAction.xhtml">获取XML数据</a><br/>
    <a href="/front/JsonAction.xhtml">获取Json数据</a>
</body>
</html>

然后编写实体类：

package com.zking.entity;

public class FQ {

    private String name;
    private String content;
    private String time;
    public FQ() {
        super();
        // TODO Auto-generated constructor stub
    }

    public FQ(String name, String content, String time) {
        super();
        this.name = name;
        this.content = content;
        this.time = time;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }
    public String getTime() {
        return time;
    }
    public void setTime(String time) {
        this.time = time;
    }
}

在Action里新建一个FQAction.java：

package com.zking.action;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Iterator;
import java.util.List;

import javax.servlet.http.HttpServletRequest;

import org.apache.struts2.ServletActionContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.opensymphony.xwork2.ActionSupport;
import com.zking.entity.FQ;

@Controller
public class FQAction  {
    @RequestMapping(value="/front/fqAction.xhtml")
    public String getXML(HttpServletRequest req) throws Exception {
        // 获取数据
        // 调用数据库查询数据，返回对象集合（....） 
        List<FQ> fqs = new ArrayList<FQ>();
        for (int i = 1; i <= 10; i++) {
            Calendar calendar = Calendar.getInstance();
            int year = calendar.get(Calendar.YEAR);
            int month = calendar.get(Calendar.MONTH);
            int day = calendar.get(Calendar.DAY_OF_MONTH);
            fqs.add(new FQ("pull" + i, "今天心情很nice", year + "-" + month + "-" + day));
        }

        // 将对象集合存放到请求域中
        req.setAttribute("fqs", fqs);
        return "dataResult";
    }

    @RequestMapping(value="/front/JsonAction.xhtml")
    public String getJson(HttpServletRequest req) throws Exception {
        // 获取数据
        // 调用数据库查询数据，返回对象集合（....） 
        List<FQ> fqs = new ArrayList<FQ>();
        for (int i = 1; i <= 10; i++) {
            Calendar calendar = Calendar.getInstance();
            int year = calendar.get(Calendar.YEAR);
            int month = calendar.get(Calendar.MONTH);
            int day = calendar.get(Calendar.DAY_OF_MONTH);
            fqs.add(new FQ("Json+pull" + i, "今天心情很nice", year + "-" + month + "-" + day));
        }
//          {}对象        JsonObject
//          []集合    JsonArray
            //将对象集合转换成Json
            JSONObject json=new JSONObject();
            json.put("clazz", "9990");
            json.put("lists", fqs.size());

            JSONArray jsona=new JSONArray();
            for (FQ fq : fqs) {
                JSONObject object=new JSONObject();
                object.put("name", fq.getName());
                object.put("content", fq.getContent());
                object.put("time", fq.getTime());
                jsona.add(object);
            }
            json.put("fqs", jsona);

        // 将对象集合存放到请求域中
        req.setAttribute("fqs", json.toString());
        return "dataResultJson";
    }

}

这里写图片描述

然后新建一个JSP dataResult.jsp
注：注意格式

<?xml version="1.0" encoding="UTF-8" ?><%@ page language="java" contentType="text/xml; charset=UTF-8" pageEncoding="UTF-8"%><%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%><fqs><c:forEach items="${fqs}" var="fq">
            <fq name="${fq.name}">
                <content>${fq.content}</content>
                <time>${fq.time}</time>
            </fq>
    </c:forEach>
    </fqs>

编写完成可以运行下
效果如：
注： 这个路径 http://localhost:8090/front/fqAction.xhtml 的localhost要改成你的网络IP地址
这里写图片描述

接下来要获取网络XML数据 （在Android Studio里编写）

-首先要先在清单文件下配置网络权限

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.dzz.android29_parsexml">

    <!--网络权限-->
    <uses-permission android:name="android.permission.INTERNET"></uses-permission>

    <application android:allowBackup="true" android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name" android:supportsRtl="true" android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

-然后编写XML —activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools" android:id="@+id/activity_main"
    android:layout_width="match_parent" android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    android:orientation="vertical"
    tools:context="com.dzz.android29_parsexml.MainActivity">

    <Button
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="获取XML"
        android:onClick="getXML"
        />
    <ListView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:id="@+id/lv_main"
        >
    </ListView>
</LinearLayout>

-然后获取网络数据 MainActivity

package com.dzz.android29_parsexml;

import android.app.ProgressDialog;
import android.os.AsyncTask;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.ListView;
import android.widget.TextView;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

public class MainActivity extends AppCompatActivity {

    private ListView lv_main;
    private ProgressDialog progressDialog;
    private List<FQ> lists=new ArrayList<>();
    private MyAdapter myAdapter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        lv_main = (ListView) findViewById(R.id.lv_main);

        //适配器
        myAdapter = new MyAdapter();
        lv_main.setAdapter(myAdapter);

        progressDialog = new ProgressDialog(this);
        progressDialog.setMessage("正在加载。。。");
    }
    //适配器
    class MyAdapter extends BaseAdapter{

        @Override
        public int getCount() {
            return lists.size();
        }

        @Override
        public Object getItem(int i) {
            return lists.get(i);
        }

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

        @Override
        public View getView(int i, View view, ViewGroup viewGroup) {
            if(view==null){
                view=LayoutInflater.from(MainActivity.this).inflate(R.layout.item_listview,null);

                ItemTag itemTag=new ItemTag();
                itemTag.tv_content= (TextView) view.findViewById(R.id.lv_a);
                itemTag.tv_name= (TextView) view.findViewById(R.id.lv_b);
                itemTag.tv_time= (TextView) view.findViewById(R.id.lv_c);
                view.setTag(itemTag);
            }
            ItemTag itemTag= (ItemTag) view.getTag();
            itemTag.tv_name.setText(lists.get(i).getName());
            itemTag.tv_content.setText(lists.get(i).getContent());
            itemTag.tv_time.setText(lists.get(i).getTime());

            return view;
        }
    }

    public void getXML(View view){
        new MyTask().execute();//执行
    }
    class MyTask extends AsyncTask{
        @Override
        protected void onPreExecute() {
            super.onPreExecute();
            progressDialog.show();
        }
        @Override
        protected Object doInBackground(Object[] objects) {
            List<FQ> fqs=new ArrayList<>();
            //获取网络数据
            //1.定义获取网络的数据       
            //这个路径 http://localhost:8090/front/fqAction.xhtml 在 values 的 strings.xml 下
            //可以编写一个
            //<resources>
            //    <string name="app_name">Android29_ParseXML</string>
            //    <string name="server_name">http://172.20.10.3:8090</string>
            //</resources>
            //可以公用一个    如下：

            String path=getString(R.string.server_name)+"/front/fqAction.xhtml";

            try {
                //2.实例化Url
                URL url=new URL(path);
                //3.获取连接对象
                HttpURLConnection con= (HttpURLConnection) url.openConnection();
                //4.设置请求方式
                con.setRequestMethod("GET");
                //5.设置请求连接超时的时间
                con.setConnectTimeout(5000);
                //6.获取响应码
                int code=con.getResponseCode();
                if(code==200){
                    //7.获取返回过来的数据（XML）
                    InputStream is =con.getInputStream();
                    Log.i("test",is+"***");
                    //8.测试（删除--注释）
                    //缓冲字符流
                    String str=null;
//                  测试用的
//                    BufferedReader br=new BufferedReader(new InputStreamReader(is));
//                    while ((str=br.readLine())!=null){
//                        Log.i("test",str);
//                    }
                    //9.解析XML
                    //解析XML有的方法： DOM   SAX  PULL
                    //1. 使用DOM解析
                    try {
                        DocumentBuilderFactory documentBuilderFactory=DocumentBuilderFactory.newInstance();
                        DocumentBuilder documentBuilder=documentBuilderFactory.newDocumentBuilder();
                        Document document=documentBuilder.parse(is); //流越大解析的越大    占用内存空间
                        //获取根标签
                        Element root=document.getDocumentElement();
                        NodeList nodeList=root.getElementsByTagName("fq");
                        for (int i = 0; i < nodeList.getLength(); i++) {
                            Element element= (Element) nodeList.item(i);
                            //获取属性name
                            String name=element.getAttribute("name");
                            //获取子标签<content><time>
                            Element elementContent= (Element) element.getElementsByTagName("content").item(0);
                            String content=elementContent.getTextContent();
                            Element elementTime= (Element) element.getElementsByTagName("time").item(0);
                            String time=elementTime.getTextContent();

                            Log.i("test",name+" "+content+" "+time);

                            FQ fq=new FQ(name,content,time);
                            fqs.add(fq);
                        }

                    } catch (ParserConfigurationException e) {
                        e.printStackTrace();
                    } catch (SAXException e) {
                        e.printStackTrace();
                    }

//                    2.使用SAX解析： 特点：边读边解析  基于事件（方法）驱动方式
//                    //开始文档  开始标签  结束标签 结束文档  文本
//                    try {
//                        SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
//                        SAXParser saxParser = saxParserFactory.newSAXParser();
//                        saxParser.parse(is, new DefaultHandler() {    //开始解析
//                            @Override    //文档的开始
//                            public void startDocument() throws SAXException {
//                                super.startDocument();
//                            }
//                            @Override  //文档的结束
//                            public void endDocument() throws SAXException {
//                                super.endDocument();
//                            }
//                            @Override
//                            public void characters(char[] ch, int start, int length) throws SAXException {
//                                super.characters(ch, start, length);
//                                if("content".equals(currentTag)){
//                                    String content=new String(ch,start,length);
//                                    fq.setContent(content);
//                                }
//                                else if("time".equals(currentTag)){
//                                    String time=new String(ch,start,length);
//                                    fq.setTime(time);
//                                }
//                            }
//                            @Override   //结束标签
//                            public void endElement(String uri, String localName, String qName) throws SAXException {
//                                super.endElement(uri, localName, qName);
//                                //细节
//                                currentTag=null;
//                                if("fq".equals(localName)){
//                                    fqs.add(fq);
//                                }
//                            }
//                            @Override   //开始标签
//                            public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
//                                super.startElement(uri, localName, qName, attributes);
//                                currentTag=localName;
//                                if("fq".equals(localName)){
                                    实例化对象
//                                    fq = new FQ();
//                                    String name=attributes.getValue(0);
//                                    fq.setName(name);
//                                }
//                            }
//                        });
//                    } catch (ParserConfigurationException e) {
//                        e.printStackTrace();
//                    } catch (SAXException e) {
//                        e.printStackTrace();
//                    }

                    //3. PULL 解析
//                    try {
//                        XmlPullParser xmlPullParser= Xml.newPullParser();
//                        xmlPullParser.setInput(is,"UTF-8");
//                        int type=xmlPullParser.getEventType();
//                        while (type!=XmlPullParser.END_DOCUMENT){
//                            switch (type){
//                                case XmlPullParser.START_TAG:
//                                    //获取开始标签的名字
//                                    String startTagName= xmlPullParser.getName();
//                                    if("fq".equals(startTagName)){
//                                        ffq = new FQ();
//                                        String name= xmlPullParser.getAttributeValue(0);
//                                        ffq.setName(name);
//                                    }
//                                    else if("content".equals(startTagName)){
//                                        String content=xmlPullParser.nextText();
//                                        ffq.setContent(content);
//                                    }
//                                    else if("time".equals(startTagName)){
//                                        String time=xmlPullParser.nextText();
//                                        ffq.setTime(time);
//                                    }
//                                    break;
//                                case XmlPullParser.END_TAG:
//                                    //获取结束标签的名字
//                                    String endTagName= xmlPullParser.getName();
//                                    if("fq".equals(endTagName)){
//                                        fqs.add(ffq);
//                                    }
//                                    break;
//                            }
//                            type=xmlPullParser.next();
//
//                        }
//
//                    } catch (XmlPullParserException e) {
//                        e.printStackTrace();
//                    }



                }
            } catch (MalformedURLException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return fqs;
        }
        @Override   //更新页面
        protected void onPostExecute(Object o) {
            super.onPostExecute(o);
            List<FQ> fqs=(List<FQ>) o;
            lists.addAll(fqs);
            myAdapter.notifyDataSetChanged();  //通知适配器发生改变

            progressDialog.cancel();
        }
    }
}

-在Activity 里新建 实体类 是要有的

package com.dzz.android29_parsexml;

public class FQ {
    private String name;
    private String content;
    private String time;
    public FQ() {
        super();
    }
    public FQ(String name, String content, String time) {
        super();
        this.name = name;
        this.content = content;
        this.time = time;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }
    public String getTime() {
        return time;
    }
    public void setTime(String time) {
        this.time = time;
    }
}

-在Activity 里新建一个 ItemTag 

package com.dzz.android29_parsexml;
import android.widget.TextView;
/**
 * Created by 朝花偏不夕拾 on 2017/2/24.
 */

public class ItemTag {
    public TextView tv_name;
    public TextView tv_content;
    public TextView tv_time;
}

-还要新建一个布局文件 - item_listview.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="horizontal" android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:layout_width="0dp"
        android:layout_weight="1"
        android:layout_height="wrap_content"
        android:textAppearance="?android:attr/textAppearanceLarge"
        android:text="Large Text"
        android:id="@+id/lv_a" />

    <TextView
        android:layout_width="0dp"
        android:layout_weight="1"
        android:layout_height="wrap_content"
        android:textAppearance="?android:attr/textAppearanceLarge"
        android:text="Large Text"
        android:id="@+id/lv_b"  />

    <TextView
        android:layout_width="0dp"
        android:layout_weight="1"
        android:layout_height="wrap_content"
        android:textAppearance="?android:attr/textAppearanceLarge"
        android:text="Large Text"
        android:id="@+id/lv_c" />
</LinearLayout>

然后是效果图：
这里写图片描述
这里写图片描述

南山巅上
关注
专栏目录
android解析XML总结（SAX、Pull、Dom三种方式）附带DOM4J、JDOM
一朶婲
10-09 3859
摘要: 在android开发中，经常用到去解析xml文件，常见的解析xml的方式有一下三种：SAX、Pull、Dom解析方式。最近做了一个android版的CSDN阅读器，用到了其中的两种（sax,pull），今天对android解析xml的这三种方式进行一次 ... 在android开发中，经常用到去解析xml文件，常见的解析xml的方式有一下三种：SAX、Pull、Dom解析方式。最近做了一
Android解析XML的三种方式
d_shadow的博客
02-16 1万+
在Android中提供了三种解析XML的方式:SAX(Simple API XML),DOM(Document Objrect Model),以及Android推荐的Pull解析方式. 如图： 这里是获取网络XML： DOM，即对象文档模型，它是将整个XML文档载入内存(所以效率较低，不推荐使用)，每一个节点当做一个对象，结合代码分析 /** * DOM解析
Android XML解析
飒然的天空
04-08 168
在Android平台上可以使用Simple API for XML(SAX) 、 Document Object Model(DOM)和Android附带的pull解析器解析XML文件。   下面是本例子要解析的XML文件： 文件名称：itcast.xml &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;persons&gt; &l...
【安卓】解析XML格式数据
最新发布
君子慎独，不欺暗室。卑以自牧，含章可贞。
08-16 752
这里需要搭建一个Web服务器，在这个服务器上提供一段XML文本，然后在程序里去访问这个服务器，再对得到的XML文本进行解析。首先需要下载一个Apache服务器的安装包，官方下载地址是：http://httpd.apache.org。然后一直点击“Next”，会提示让你输入自己的域名，我们随便填一个域名就可以了。之后继续点击“Next”就可以完成安装了，安装成功后服务器会自动启动。
Android解析XML文件
热门推荐
钟秀
07-27 4万+
按计划每周更新一篇技术博文，第一篇：《Android解析XML文件》 一、在Android应用中的XML文件来源 1、本地xml文件     本地XML文件可以放在应用根目录assets文件夹、res/xml、res/raw、SDcard卡、应用的data目录等； 除res/xml可直接通过getXml(int id)获取XML文档，返回一个解析器对象（XmlResourcePar
详解android解析Xml的三种方式——DOM、SAX以及XMLpull
jandroid
09-23 107
今天学习了android解析Xml的三种方式——DOM、SAX以及XMLpull，这里对它们进行总结。 如果理解有误，欢迎指正 ^_* 一、DOM方式解析： xml是先把xml文档都读到内存中，然后再用DOM API来访问树形结构，并获取数据。这个写起来很简单，但是很消耗内存。要是数据过大，手机不够牛逼，可能手机直接死机。 常用的DoM接口和类： Document：该接口定义分析并...
Android解析xml数据
东天里的冬天
05-09 289
在移动开发中，服务器常以xml形式向Android传递数据，这个时候就需要解析服务器传递过来的xml了，以下图为例，服务器传过来的数据如图所示 public class XmlParserUtils { //解析xml的业务方法 public List&lt;News&gt; parserXml(InputStream in) throws Exception {...
Android 解析XML 文件的四种方法总结
01-20
本文主要介绍了四种在Java和Android中解析XML文件的方法：DOM、SAX、JDOM和DOM4J。 1. DOM（Document Object Model）解析： DOM是W3C推荐的标准，它将XML文档解析为一个节点树，允许开发者在整个树结构中查找和操作...
Android解析XML文件升级APK的方法
08-27
Android 解析 XML 文件升级 APK 的方法是一种常见的应用场景，在实际开发中，我们经常需要从服务器端获取 XML 文件，然后解析该文件以获取所需的信息，并将其应用于 APK 的升级中。下面我们将详细介绍 Android 解析 ...
Android 解析 XML 三种方法
03-29
总结，Android解析XML的三种方法——SAX、DOM和PULL，各有适用场景。理解它们的工作原理和优缺点，可以帮助我们更好地选择和运用XML解析技术，提高应用的效率和用户体验。在实践中不断学习和探索，才能真正掌握这些...
Android三种解析XML方式demo
05-12
在Android平台上可以使用Simple?API?for XML(SAX) 、 Document Object Model(DOM)和Android附带的pull解析器解析XML文件
Android中解析XML
05-26
昨两天偶然在csdn上学习到Android中解析XML，感觉博主写得清晰易懂，但是未有源码，于是自己整理了一下。学习参考：http://blog.csdn.net/liuhe688/article/details/6415593/
Android 解析xml 文件
xujian197的博客
03-28 5551
xml 文件在各种开发中都广泛应用.Android中也不例外.作为承载数据的一个重要角色.如何读写xml成为一项十分重要的技能. 在Android中,常见的xml解析器分为DOM解析器,SAX解析器,PULL解析器. 将该xml文件放置在assets目录中. <?xml version="1.0" encoding="utf-8"?> <persons> &...
Android之Xml的三种解析方式
true100的专栏
12-28 3346
Android中xml格式文件的三种解析小DEMO: import android.app.Activity; import android.os.Bundle; import android.support.annotation.Nullable; import android.util.Xml; import android.view.View; import android.widget.B...
Android 解析XML文件的三种方式 DOM,SAX,PULL
haha_mingg的专栏
04-17 9412
我是通过参考：http://www.cnblogs.com/zhangdongzi/archive/2011/04/14/2016434.html在XML操作过程中，我们经常会想如何去处理它，在Android平台下，有三种解析XML文件的方式。第一种是DOM，它的特点是一次全部加载，如果对于数据量小的情况下，它的效率还可以，如果XML文件很大的情况下，速度就会慢起来。在androd手机中处理xml数据时很常见的事情，通常在不同平台传输数据的时候，我们就可能使用xml，xml是与平台无关的特性，被广泛运用于数
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值