在Android上解析xml数据时，XmlPullParser需要问题

我正在学习android xml解析教程（），但是当我逐步学习时，它似乎在以下方面失败了：

parser.require(XmlPullParser.START_TAG, ns, "rss");

然后就转到finally子句。我只是想知道是否有人能发现问题的症结所在，因为我已经玩了好几个小时，但都没有成功

我试图阅读的提要是：

非常感谢您的帮助，请查看以下代码：

package com.proxama.news_bbc;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.channels.Channels;
import java.nio.channels.ReadableByteChannel;
import java.util.ArrayList;
import java.util.List;

import javax.xml.parsers.DocumentBuilder;

import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;

import android.support.v7.app.ActionBarActivity;
import android.support.v4.app.Fragment;
import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.AsyncTask;
import android.os.Bundle;
import android.util.Log;
import android.util.Xml;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
import android.widget.ListView;
import android.provider.DocumentsContract.Document;

public class MainActivity extends ActionBarActivity {
    private static final String ns = null;
    /*
     * Only interested in the content of the following XML tags for each news
     * item:
     * 
     * item/media:thumbnail item/pubDate item/link item/description item/title
     */
    private void skip(XmlPullParser parser) throws XmlPullParserException,
            IOException {
        if (parser.getEventType() != XmlPullParser.START_TAG) {
            throw new IllegalStateException();
        }
        int depth = 1;
        while (depth != 0) {
            switch (parser.next()) {
                case XmlPullParser.END_TAG:
                    depth--;
                    break;
                case XmlPullParser.START_TAG:
                    depth++;
                    break;
            }
        }
    }

    public static class Entry {
        public final String title;
        public final String link;
        public final String summary;

        private Entry(String title, String summary, String link) {
            this.title = title;
            this.summary = summary;
            this.link = link;
        }
    }

    // Parses the contents of an entry. If it encounters a title, summary, or
    // link tag, hands them off
    // to their respective "read" methods for processing. Otherwise, skips the
    // tag.


    // Processes title tags in the feed.
    private String readTitle(XmlPullParser parser) throws IOException,
            XmlPullParserException {
        parser.require(XmlPullParser.START_TAG, ns, "title");
        String title = readText(parser);
        parser.require(XmlPullParser.END_TAG, ns, "title");
        return title;
    }

    // Processes link tags in the feed.
    private String readLink(XmlPullParser parser) throws IOException,
            XmlPullParserException {
        String link = "";
        parser.require(XmlPullParser.START_TAG, ns, "link");
        String tag = parser.getName();
        String relType = parser.getAttributeValue(null, "rel");
        if (tag.equals("link")) {
            if (relType.equals("alternate")) {
                link = parser.getAttributeValue(null, "href");
                parser.nextTag();
            }
        }
        parser.require(XmlPullParser.END_TAG, ns, "link");
        return link;
    }

    // Processes summary tags in the feed.
    private String readSummary(XmlPullParser parser) throws IOException,
            XmlPullParserException {
        parser.require(XmlPullParser.START_TAG, ns, "summary");
        String summary = readText(parser);
        parser.require(XmlPullParser.END_TAG, ns, "summary");
        return summary;
    }

    // For the tags title and summary, extracts their text values.
    private String readText(XmlPullParser parser) throws IOException,
            XmlPullParserException {
        String result = "";
        if (parser.next() == XmlPullParser.TEXT) {
            result = parser.getText();
            parser.nextTag();
        }
        return result;
    }

    private Entry readEntry(XmlPullParser parser)
            throws XmlPullParserException, IOException {
        parser.require(XmlPullParser.START_TAG, ns, "item");
        String title = null;
        String summary = null;
        String link = null;
        while (parser.next() != XmlPullParser.END_TAG) {
            if (parser.getEventType() != XmlPullParser.START_TAG) {
                continue;
            }
            String name = parser.getName();
            if (name.equals("title")) {
                title = readTitle(parser);
            } else if (name.equals("summary")) {
                summary = readSummary(parser);
            } else if (name.equals("link")) {
                link = readLink(parser);
            } else {
                skip(parser);
            }
        }
        return new Entry(title, summary, link);
    }

    private List readFeed(XmlPullParser parser) throws XmlPullParserException,
            IOException {
        List entries = new ArrayList();
        String xmlContents = parser.toString();
        parser.require(XmlPullParser.START_TAG, ns, "rss");
        Log.d("className", "Up to here ");
        while (parser.next() != XmlPullParser.END_TAG) {
            if (parser.getEventType() != XmlPullParser.START_TAG) {
                continue;
            }
            String name = parser.getName();
            // Starts by looking for the news item tag
            if (name.equals("item")) {
                entries.add(readEntry(parser));
            } else {
                skip(parser);
            }
        }
        return entries;
    }

    private List parseXml(InputStream in) throws XmlPullParserException,
            IOException {

        try {
            XmlPullParser parser = Xml.newPullParser();
            parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, false);
            parser.setInput(in, null);
            return readFeed(parser);
        } finally {
            in.close();
        }
    }

    private String downloadUrl(String myurl) throws IOException {
        // TODO allow for internal storage if external is unavailable or full
        File root = android.os.Environment.getExternalStorageDirectory();
        String Directory = root.getAbsolutePath() + "/xmls";
        String xmlFileName = "bbc_news_rss.xml";
        String fullXmlPath = Directory + "/" + xmlFileName;

        File dir = new File(Directory);
        if (dir.exists() == false) {
            dir.mkdirs();
        }

            /*URL url = new URL(myurl);
            InputStream is = url.openStream();
            OutputStream os = new FileOutputStream(fullXmlPath);

            byte[] b = new byte[2048];
            int length;

            while ((length = is.read(b)) != -1) {
                os.write(b, 0, length);
            }

            is.close();
            os.close();*/
        URL url = new URL(myurl);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setReadTimeout(10000 /* milliseconds */);
        conn.setConnectTimeout(15000 /* milliseconds */);
        conn.setRequestMethod("GET");
        conn.setDoInput(true);
        // Starts the query
        conn.connect();
        InputStream in = conn.getInputStream();

        Log.d("className", "Saved XML file to: " + fullXmlPath);
        Log.d("className", "Starting to parse XML file: " + fullXmlPath);
        //InputStream in = new FileInputStream(fullXmlPath);
        try {
            parseXml(in);
        } catch (XmlPullParserException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return fullXmlPath;
    }

    // Uses AsyncTask to create a task away from the main UI thread. This task
    // takes a
    // URL string and uses it to create an HttpUrlConnection. Once the
    // connection
    // has been established, the AsyncTask downloads the contents of the webpage
    // as
    // an InputStream. Finally, the InputStream is converted into a string,
    // which is
    // displayed in the UI by the AsyncTask's onPostExecute method.
    private class DownloadWebpageTask extends AsyncTask<String, Void, String> {
        @Override
        protected String doInBackground(String... stringUrl) {
            try {
                Log.d("className", "Downloading url: " + stringUrl[0]);
                return downloadUrl(stringUrl[0]);
            } catch (IOException e) {
                return "Unable to retrieve file.";
            }
        }

        // onPostExecute displays the results of the AsyncTask.
        @Override
        protected void onPostExecute(String result) {
            Log.d("className",
                    "In onpostexecute and result of downloadUrl is: " + result);

            // If the file has been saved correctly, parse it.
            if (result != "Unable to retrieve file.") {
                Log.d("className", "Creating list view");
                createList();
            }

        }
    }

    /** Pull in the XML from http://feeds.bbci.co.uk/news/rss.xml */
    public void pull_xml(View view) {
        ConnectivityManager connMgr = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo networkInfo = connMgr.getActiveNetworkInfo();
        if (networkInfo != null && networkInfo.isConnected()) {
            // can connect so fetch XML file
            Log.d("className", "Successfully connected to network!");
            new DownloadWebpageTask()
                    .execute("http://feeds.bbci.co.uk/news/rss.xml");
        } else {
            // display error
            Log.d("className",
                    "Unable to connect to network, trying to use a previously saved local xml file");
        }

    }

    public void createList() {
        setContentView(R.layout.activity_main);

        // Get ListView object from XML
        ListView listView = (ListView) findViewById(R.id.listView1);

        // Defined Array values to show in ListView
        String[] values = new String[] { "Ukraine begins 'anti-terror' action" };

        // Define a new Adapter
        // First parameter - Context
        // Second parameter - Layout for the row
        // Third parameter - ID of the TextView to which the data is written
        // Forth - the Array of data

        ArrayAdapter<String> adapter = new ArrayAdapter<String>(this,
                android.R.layout.simple_list_item_1, android.R.id.text1, values);

        // Assign adapter to ListView
        listView.setAdapter(adapter);
    }

    // Original classes and methods that came by default with new android
    // projects.
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // retrieve the XML and create list view
        pull_xml(null);

        if (savedInstanceState == null) {
            getSupportFragmentManager().beginTransaction()
                    .add(R.id.container, new PlaceholderFragment()).commit();
        }
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {

        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();
        if (id == R.id.action_settings) {
            return true;
        }
        return super.onOptionsItemSelected(item);
    }

    /**
     * A placeholder fragment containing a simple view.
     */
    public static class PlaceholderFragment extends Fragment {

        public PlaceholderFragment() {
        }

        @Override
        public View onCreateView(LayoutInflater inflater, ViewGroup container,
                                 Bundle savedInstanceState) {
            View rootView = inflater.inflate(R.layout.fragment_main, container,
                    false);
            return rootView;
        }
    }

}

package com.proxama.news\u英国广播公司；
导入java.io.File；
导入java.io.FileInputStream；
导入java.io.FileNotFoundException；
导入java.io.FileOutputStream；
导入java.io.IOException；
导入java.io.InputStream；
导入java.io.OutputStream；
导入java.net.HttpURLConnection；
导入java.net.URL；
导入java.nio.channels.channels；
导入java.nio.channels.ReadableByteChannel；
导入java.util.ArrayList；
导入java.util.List；
导入javax.xml.parsers.DocumentBuilder；
导入org.xmlpull.v1.XmlPullParser；
导入org.xmlpull.v1.XmlPullParserException；
导入android.support.v7.app.ActionBarActivity；
导入android.support.v4.app.Fragment；
导入android.content.Context；
导入android.net.ConnectivityManager；
导入android.net.NetworkInfo；
导入android.os.AsyncTask；
导入android.os.Bundle；
导入android.util.Log；
导入android.util.Xml；
导入android.view.LayoutInflater；
导入android.view.Menu；
导入android.view.MenuItem；
导入android.view.view；
导入android.view.ViewGroup；
导入android.widget.ArrayAdapter；
导入android.widget.ListView；
导入android.provider.documents contract.Document；
公共类MainActivity扩展了ActionBarActivity{
私有静态最终字符串ns=null；
/*
*只对每个新闻的以下XML标记的内容感兴趣
*项目：
* 
*项目/媒体：缩略图项目/发布日期项目/链接项目/说明项目/标题
*/
私有void skip（XmlPullParser解析器）抛出XmlPullParserException，
IOException{
if（parser.getEventType（）！=XmlPullParser.START_标记）{
抛出新的非法状态异常（）；
}
int深度=1；
while（深度！=0）{
开关（parser.next（））{
case XmlPullParser.END_标记：
深度--；
打破
case XmlPullParser.START_标记：
深度++；
打破
}
}
}
公共静态类条目{
公共最终字符串标题；
公共最终字符串链接；
公开最终字符串摘要；
私有条目（字符串标题、字符串摘要、字符串链接）{
this.title=标题；
this.summary=摘要；
this.link=link；
}
}
//解析条目的内容。如果它遇到标题、摘要或
//链接标签，把手拿开
//到各自的“读取”方法进行处理。否则，跳过
//标签。
//处理提要中的标题标记。
私有字符串readTitle（XmlPullParser解析器）引发IOException，
XmlPullParserException{
require（XmlPullParser.START_标记，ns，“title”）；
字符串title=readText（解析器）；
require（XmlPullParser.END_标记，ns，“title”）；
返回标题；
}
//处理提要中的链接标记。
私有字符串读取链接（XmlPullParser）引发IOException，
XmlPullParserException{
字符串链接=”；
require（XmlPullParser.START_标记，ns，“link”）；
String tag=parser.getName（）；
String relType=parser.getAttributeValue（null，“rel”）；
if（tag.equals（“link”））{
if（relType.equals（“替代”））{
link=parser.getAttributeValue（null，“href”）；
parser.nextTag（）；
}
}
require（XmlPullParser.END_标记，ns，“link”）；
返回链接；
}
//处理提要中的摘要标记。
私有字符串readSummary（XmlPullParser解析器）引发IOException，
XmlPullParserException{
require（XmlPullParser.START_标记，ns，“summary”）；
String summary=readText（解析器）；
require（XmlPullParser.END_标记，ns，“summary”）；
返回摘要；
}
//对于标记标题和摘要，提取其文本值。
私有字符串readText（XmlPullParser解析器）引发IOException，
XmlPullParserException{
字符串结果=”；
if（parser.next（）==XmlPullParser.TEXT）{
结果=parser.getText（）；
parser.nextTag（）；
}
返回结果；
}
私有条目readEntry（XmlPullParser）
引发XmlPullParserException，IOException{
require（XmlPullParser.START_标记，ns，“item”）；
字符串标题=null；
字符串摘要=null；
字符串链接=null；
while（parser.next（）！=XmlPullParser.END_标记）{
if（parser.getEventType（）！=XmlPullParser.START_标记）{
继续；
}
String name=parser.getName（）；
如果（名称等于（“头衔”））{
title=readTitle（解析器）；
}else if（name.equals（“summary”））{
summary=readSummary（解析器）；
}else if（name.equals（“link”））{
link=readLink（解析器）；
}否则{
跳过（解析器）；
}
}
返回新条目（标题、摘要、链接）；
}
私有列表readFeed（XmlPullParser解析器）抛出XmlPullParserException，
IOException{
列表项=新的ArrayList（）；
字符串xmlContents=parser.toString（）；
require（XmlPullParser.START_标记，ns，“rss”）；
Log.d（“className”，“截至此处”）；
while（parser.next（）！=XmlPullParser.END_标记）{
if（parser.getEventType（）！=XmlPullParser.START_标记）{
继续；
}
String name=parser.getName（）；
//Sta
if ("Unable to retrieve file.".equals(result)) {
    Log.d("className", "Creating list view");
    createList();
}