Java Xml解析嵌套标记返回null

您好，我是XML解析新手，并完成了关于XML解析的google教程。在本教程中，他们将使用：

所以我想用关于文章作者的信息来扩展它，我尝试了一下，但是无论我在author标记（uri标记和name标记）中使用什么，它总是返回null

“搜索标签”发生在我的文件中

/**
*此类解析stackoverflow.com中的XML提要。
*给定提要的InputStream表示形式，它将返回条目列表，
*其中，每个列表元素表示XML提要中的单个条目（post）。
*/
公共类StackOverflowXmlParser{
私有静态最终字符串ns=null；
//我们不使用名称空间
公共列表解析（InputStream in）抛出XmlPullParserException，IOException{
试一试{
XmlPullParser=Xml.newPullParser（）；
setFeature（XmlPullParser.FEATURE_进程_名称空间，false）；
setInput（in，null）；
parser.nextTag（）；
返回readFeed（解析器）；
}最后{
in.close（）；
}
}
私有列表readFeed（XmlPullParser解析器）抛出XmlPullParserException，IOException{
列表项=新的ArrayList（）；
require（XmlPullParser.START_标记，ns，“feed”）；
while（parser.next（）！=XmlPullParser.END_标记）{
if（parser.getEventType（）！=XmlPullParser.START_标记）{
继续；
}
String name=parser.getName（）；
//首先查找条目标记
如果（名称等于（“条目”））{
add（readEntry（解析器））；
} 
否则{
跳过（解析器）；
}
}
返回条目；
}
//此类表示XML提要中的单个条目（post）。
//它包括数据成员“标题”、“链接”和“摘要”
公共静态类条目
{
公开最终字符串评级；
公共最终字符串标题；
公共最终字符串链接；
公共最终字符串作者；
私有条目（字符串分级、字符串标题、字符串链接、字符串作者）
{
这个。评级=评级；
this.title=标题；
this.link=link；
this.author=作者；
}        
}
//解析条目的内容。如果它遇到标题、摘要或链接标记，则将其交给
//关
//到各自的“读取”方法进行处理。否则，跳过标记。
私有条目readEntry（XmlPullParser解析器）抛出XmlPullParserException，IOException{
require（XmlPullParser.START_标记，ns，“entry”）；
字符串评级=空；
字符串标题=null；
字符串链接=null；
字符串author=null；
while（parser.next（）！=XmlPullParser.END_标记）{
if（parser.getEventType（）！=XmlPullParser.START_标记）{
继续；
}
String name=parser.getName（）；
如果（名称等于（“re:rank”））{
rating=读取rating_名称（解析器）；
} 
如果（名称等于（“头衔”））{
title=readTitle\u名称（解析器）；
}
else if（name.equals（“id”））{
link=readLink\u名称（解析器）；
}
else if（name.equals（“name”））{
author=readAuthor\u名称（解析器）；
}
其他的
{
跳过（解析器）；
}
}
返回新条目（评级、标题、链接、作者）；
}
//处理提要中的标题标记。
私有字符串readRating_name（XmlPullParser）抛出IOException，XmlPullParserException{
require（XmlPullParser.START_标记，ns，“re:rank”）；
字符串评级=readText（解析器）；
require（XmlPullParser.END_标记，ns，“re:rank”）；
回报率；
}   
私有字符串readTitle_name（XmlPullParser解析器）引发IOException，XmlPullParserException{
require（XmlPullParser.START_标记，ns，“title”）；
字符串title=readText（解析器）；
require（XmlPullParser.END_标记，ns，“title”）；
返回标题；
} 
私有字符串readLink_name（XmlPullParser解析器）引发IOException，XmlPullParserException{
require（XmlPullParser.START_标记，ns，“id”）；
字符串链接=读文本（解析器）；
require（XmlPullParser.END_标记，ns，“id”）；
返回链接；
} 
私有字符串readAuthor_name（XmlPullParser解析器）引发IOException，XmlPullParserException{
require（XmlPullParser.START_标记，ns，“name”）；
字符串author=readText（解析器）；
require（XmlPullParser.END_标记，ns，“name”）；
返回作者；
}          
//对于标记标题和摘要，提取其文本值。
私有字符串readText（XmlPullParser）
抛出IOException、XmlPullParserException{
字符串结果=”；
if（parser.next（）==XmlPullParser.TEXT）{
结果=parser.getText（）；
parser.nextTag（）；
}
返回结果；
}
//跳过解析器不感兴趣的标记。使用深度处理嵌套标记。例如。，
//如果开始标记后的下一个标记不是匹配的结束标记，则它将一直运行，直到找到它为止
//查找匹配的END_标记（如“depth”的值为0所示）。
私有void skip（XmlPullParser解析器）抛出XmlPullParserException，IOException{
if（parser.getEventType（）！=XmlPullParser.START_标记）{
抛出新的非法状态异常（）；
}
int深度=1；
while（深度！=0）{
开关（parser.next（））{
case XmlPullParser.END_标记：
深度--；
打破
case XmlPullParser.START_标记：
深度++；
打破
}
}
}
}

我的c

/**
 * This class parses XML feeds from stackoverflow.com.
 * Given an InputStream representation of a feed, it returns a List of entries,
 * where each list element represents a single entry (post) in the XML feed.
 */
public class StackOverflowXmlParser {
    private static final String ns = null;

    // We don't use namespaces

    public List<Entry> parse(InputStream in) throws XmlPullParserException, IOException {
        try {
            XmlPullParser parser = Xml.newPullParser();
            parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, false);
            parser.setInput(in, null);
            parser.nextTag();
            return readFeed(parser);
        } finally {
            in.close();
        }
    }

    private List<Entry> readFeed(XmlPullParser parser) throws XmlPullParserException, IOException {
        List<Entry> entries = new ArrayList<Entry>();

        parser.require(XmlPullParser.START_TAG, ns, "feed");
        while (parser.next() != XmlPullParser.END_TAG) {
            if (parser.getEventType() != XmlPullParser.START_TAG) {
                continue;
            }
            String name = parser.getName();
            // Starts by looking for the entry tag
            if (name.equals("entry")) {
                entries.add(readEntry(parser));
            } 

            else {
                skip(parser);
            }
        }
        return entries;
    }

    // This class represents a single entry (post) in the XML feed.
    // It includes the data members "title," "link," and "summary."
    public static class Entry 
    {
       public final String rating;
       public final String title;
       public final String link;
       public final String author;

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


    // Parses the contents of an entry. If it encounters a title, summary, or link tag, hands them
    // off
    // to their respective &quot;read&quot; methods for processing. Otherwise, skips the tag.
    private Entry readEntry(XmlPullParser parser) throws XmlPullParserException, IOException {
        parser.require(XmlPullParser.START_TAG, ns, "entry");
        String rating = null;
        String title = null;
        String link = null;
        String author = null;



        while (parser.next() != XmlPullParser.END_TAG) {
            if (parser.getEventType() != XmlPullParser.START_TAG) {
                continue;
            }

            String name = parser.getName();

            if (name.equals("re:rank")){
                rating = readRating_name(parser);
            } 

            else if (name.equals("title")){
                title = readTitle_name(parser);
            }

            else if (name.equals("id")){
                link = readLink_name(parser);
            }

            else if (name.equals("name")){
                author = readAuthor_name(parser);
            }

            else 
            {
                skip(parser);
            }
        }
        return new Entry(rating, title, link, author);
    }

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

    private String readTitle_name(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;
    } 

    private String readLink_name(XmlPullParser parser) throws IOException, XmlPullParserException {
        parser.require(XmlPullParser.START_TAG, ns, "id");
        String link = readText(parser);
        parser.require(XmlPullParser.END_TAG, ns, "id");
        return link;
    } 

    private String readAuthor_name(XmlPullParser parser) throws IOException, XmlPullParserException {
        parser.require(XmlPullParser.START_TAG, ns, "name");
        String author = readText(parser);
        parser.require(XmlPullParser.END_TAG, ns, "name");
        return author;
    }          

    // 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;
    }

    // Skips tags the parser isn't interested in. Uses depth to handle nested tags. i.e.,
    // if the next tag after a START_TAG isn't a matching END_TAG, it keeps going until it
    // finds the matching END_TAG (as indicated by the value of "depth" being 0).
    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;
            }
        }
    }
}

// Uploads XML from stackoverflow.com, parses it, and combines it with
// HTML markup. Returns HTML string.
private String loadXmlFromNetwork(String urlString) throws XmlPullParserException, IOException 
{
    InputStream stream = null;
    StackOverflowXmlParser stackOverflowXmlParser = new StackOverflowXmlParser();
    List<Entry> entries = null;




    StringBuilder htmlString = new StringBuilder();         

    try {
        stream = downloadUrl(urlString);
        entries = stackOverflowXmlParser.parse(stream);
    // Makes sure that the InputStream is closed after the app is
    // finished using it.
    } 

    finally 
    {
        if (stream != null) 
        {
            stream.close();
        }
    }


    // Content section


    for (Entry entry : entries) 
    {
        // <a href="Link">Name link</a>

        String question = getString(R.string.question);
        String rating = getString(R.string.rating);
        String author = getString(R.string.author);

        // Question link + title

        htmlString.append("<p>" + question + "<a href='" + entry.link + "'>" + entry.title + "</a><br />");
        htmlString.append(rating + entry.rating + "<br />");
        htmlString.append(author + entry.author + "</p>");




    }
    return htmlString.toString();
}

String xml = "xml here...";                
XMLSerializer xmlSerializer = new XMLSerializer(); 
JSON json = xmlSerializer.read( xml );