如何在android中使用SAX解析获取数据

对于下面的xml示例，任何主体都可以展示如何使用SAX解析从xml文档中获取数据

<root>
   <parent>
      <child1>xyz</child1>
      <child2>abc</child2>
   </parent>
</root>        

xyz
abc

为此，我们如何在android中编写sax解析代码

---

感谢您的帮助……

这里有很多SAX教程和答案。是关于StackOverflow的一个很好的答案，它清楚地解释了SAX解析器的工作原理

公共类JaappApplication扩展了应用程序{
    public class JaappApplication extends Application {
        public static final int FAIL = 0;
        public static final int SUCCESS = 1;

        //XML parsers
        public static final int QUESTIONS = 0;


        //PUTEXTRAS 
        public static final String SUBJECTID = "subjectid";
        public static String subtypeid;
        public static String subtypeoption;

    }

    public static ArrayList<QuestionsDto> getQuestionsDtos(String quesid)
    {
        ArrayList<QuestionsDto> arr = new ArrayList<QuestionsDto>();
        String url1 = url + "getquestions.php?subjectid=" + quesid;
        XMLParser xmlParser = new XMLParser(JaappApplication.QUESTIONS);
        int x = xmlParser.parseXml(url1, JaappApplication.QUESTIONS);
        arr = xmlParser.getQuestions();
        return arr;
    }

                package com.jaapp.xmlparsing;

        import java.io.InputStream;
        import java.net.URI;
        import java.net.UnknownHostException;
        import java.util.ArrayList;

        import javax.xml.parsers.SAXParser;
        import javax.xml.parsers.SAXParserFactory;

        import org.apache.http.HttpResponse;
        import org.apache.http.client.HttpClient;
        import org.apache.http.client.methods.HttpGet;
        import org.apache.http.impl.client.DefaultHttpClient;
        import org.xml.sax.InputSource;
        import org.xml.sax.XMLReader;

        import com.jaapp.application.JaappApplication;
        import com.jaapp.dto.QuestionsDto;

        import android.util.Log;

        public class XMLParser {
            protected static final String TAG = XMLParser.class.getCanonicalName();
            private static QuestionsReader questionHandler;

            public XMLParser(int initHandler) {
                if (initHandler == JaappApplication.QUESTIONS) {
                    questionHandler = new QuestionsReader();
                }
            }

            public int parseXml(String parseString, int type) {
                try {
                    /* Create a URL we want to load some xml-data from. */
                    URI lUri = new URI(parseString);

                    // Prepares the request.
                    HttpClient lHttpClient = new DefaultHttpClient();
                    HttpGet lHttpGet = new HttpGet();
                    lHttpGet.setURI(lUri);

                    // Sends the request and read the response
                    HttpResponse lHttpResponse = lHttpClient.execute(lHttpGet);
                    InputStream lInputStream = lHttpResponse.getEntity().getContent();
                    int status = lHttpResponse.getStatusLine().getStatusCode();

                    /* Get a SAXParser from the SAXPArserFactory. */
                    SAXParserFactory spf = SAXParserFactory.newInstance();
                    spf.setNamespaceAware(true);
                    SAXParser sp = spf.newSAXParser();

                    /* Get the XMLReader of the SAXParser we created. */
                    XMLReader xr = sp.getXMLReader();
                    if(type == JaappApplication.QUESTIONS)  {
                        xr.setContentHandler(questionHandler);  
                    }


                    /* Create a new ContentHandler and apply it to the XML-Reader */

                    /* Parse the xml-data from our URL. */

                    if (!((status >= 200) && (status < 300))) {
                    }
                    else
                    {
                        InputSource is = new InputSource(lInputStream);
                        is.setEncoding("ISO-8859-1");
                        xr.parse(is);

                    }
                    /* Parsing has finished. */
                    return JaappApplication.SUCCESS;
                }
                catch(UnknownHostException e)
                {
                    Log.e(TAG, e.toString());
                    return JaappApplication.FAIL;
                }
                catch (Exception e) {
                    /* Display any Error to the GUI:. */
                    Log.e(TAG, e.toString());
                    return JaappApplication.FAIL;
                }

            }

            public int parseXml(InputStream is, int type) {
                try {
                    /* Get a SAXParser from the SAXPArserFactory. */
                    SAXParserFactory spf = SAXParserFactory.newInstance();
                    spf.setNamespaceAware(true);
                    SAXParser sp = spf.newSAXParser();

                    /* Get the XMLReader of the SAXParser we created. */
                    XMLReader xr = sp.getXMLReader();
                    if(type == JaappApplication.QUESTIONS)  {
                        xr.setContentHandler(questionHandler);  
                //  }   else if(type == NRTApplication.BOTTOMAD)    {
                //      xr.setContentHandler(myBottomAdHandler);    
                    }

                    /* Create a new ContentHandler and apply it to the XML-Reader */

                    /* Parse the xml-data from our URL. */
                    InputSource is1 = new InputSource(is);
                    is1.setEncoding("ISO-8859-1");
                    xr.parse(is1);
                    /* Parsing has finished. */
                    return JaappApplication.SUCCESS;
                }
                catch(UnknownHostException e)
                {
                    Log.e(TAG, e.toString());
                    return JaappApplication.FAIL;
                }
                catch (Exception e) {
                    /* Display any Error to the GUI:. */
                    Log.e(TAG, "Exception XML parser: " + e.toString());
                    return JaappApplication.FAIL;
                }

            }


            public ArrayList<QuestionsDto> getQuestions() {
                return questionHandler.getQuestions();
            }



        }












        package com.jaapp.xmlparsing;

        import java.util.ArrayList;

        import org.xml.sax.Attributes;
        import org.xml.sax.SAXException;
        import org.xml.sax.helpers.DefaultHandler;

        import android.util.Log;

        import com.jaapp.dto.QuestionsDto;

        public class QuestionsReader extends DefaultHandler {
            private static final String TAG = QuestionsReader.class.getCanonicalName();
            private String tempVal;
            private ArrayList<QuestionsDto> completeQuestionsList;
            private QuestionsDto tempQues;

            public QuestionsReader() {
                completeQuestionsList = new ArrayList<QuestionsDto>();
            }

            @Override
            public void startDocument() throws SAXException {
            }

            @Override
            public void endDocument() throws SAXException {
                // Nothing to do
            }

            @Override
            public void startElement(String uri, String localName, String qName,
                    Attributes attributes) throws SAXException {
                if (localName.equalsIgnoreCase("question")) {
                    tempQues = new QuestionsDto();
                }
                tempVal = "";
            }

            @Override
            public void characters(char[] ch, int start, int length)
                    throws SAXException {
                tempVal += new String(ch, start, length);
            }

            @Override
            public void endElement(String uri, String localName, String qName)
                    throws SAXException {
                if (localName.equalsIgnoreCase("question")) {
                    completeQuestionsList.add(tempQues);
                } else if(localName.equalsIgnoreCase("id")) {
                    tempQues.setQid(tempVal);
                } else if(localName.equalsIgnoreCase("level")) {
                    tempQues.setQlevel(Integer.parseInt(tempVal));
                } else if(localName.equalsIgnoreCase("description")) {
                    tempQues.setQquestion(tempVal);
                }
            }

            public ArrayList<QuestionsDto> getQuestions() {
                return completeQuestionsList;
            }
        }

公共静态最终整数失败=0；
公共静态最终整数成功=1；
//XML解析器
公共静态最终整数问题=0；
//多余的
公共静态最终字符串SUBJECTID=“SUBJECTID”；
公共静态字符串子类型ID；
公共静态字符串子类型选项；
}
公共静态数组列表getQuestionsDtos（字符串quesid）
{
ArrayList arr=新的ArrayList（）；
字符串url1=url+“getquestions.php？subjectid=“+quesid；
XMLParser=newxmlparser（JaappApplication.QUESTIONS）；
intx=xmlParser.parseXml（url1，JaappApplication.QUESTIONS）；
arr=xmlParser.getQuestions（）；
返回arr；
}
包com.jaapp.xml解析；
导入java.io.InputStream；
导入java.net.URI；
导入java.net.UnknownHostException；
导入java.util.ArrayList；
导入javax.xml.parsers.SAXParser；
导入javax.xml.parsers.SAXParserFactory；
导入org.apache.http.HttpResponse；
导入org.apache.http.client.HttpClient；
导入org.apache.http.client.methods.HttpGet；
导入org.apache.http.impl.client.DefaultHttpClient；
导入org.xml.sax.InputSource；
导入org.xml.sax.XMLReader；
导入com.jaapp.application.JaappApplication；
导入com.jaapp.dto.questionsdo；
导入android.util.Log；
公共类XMLParser{
受保护的静态最终字符串标记=XMLParser.class.getCanonicalName（）；
私有静态问题阅读器问题处理程序；
公共XMLParser（int initHandler）{
if（initHandler==JaappApplication.QUESTIONS）{
questionHandler=新的QuestionsReader（）；
}
}
公共int-parseXml（String-parseString，int-type）{
试一试{
/*创建要从中加载一些xml数据的URL*/
URI lUri=新URI（parseString）；
//准备请求。
HttpClient lHttpClient=新的DefaultHttpClient（）；
HttpGet lHttpGet=新的HttpGet（）；
lHttpGet.setURI（lUri）；
//发送请求并读取响应
HttpResponse lHttpResponse=lHttpClient.execute（lHttpGet）；
InputStream lInputStream=lHttpResponse.getEntity（）.getContent（）；
int status=lHttpResponse.getStatusLine（）.getStatusCode（）；
/*从SAXPArserFactory获取SAXParser*/
SAXParserFactory spf=SAXParserFactory.newInstance（）；
spf.setNamespaceAware（true）；
SAXParser sp=spf.newSAXParser（）；
/*获取我们创建的SAXParser的XMLReader*/
XMLReader xr=sp.getXMLReader（）；
if（type==JaappApplication.QUESTIONS）{
xr.setContentHandler（questionHandler）；
}
/*创建新的ContentHandler并将其应用于XML读取器*/
/*从我们的URL解析xml数据*/
如果（！（（状态>=200）和&（状态<300）））{
}
其他的
{
InputSource is=新的InputSource（lInputStream）；
is.setEncoding（“ISO-8859-1”）；
xr.parse（is）；
}
/*解析已完成*/
返回JaappApplication.SUCCESS；
}
捕获（未知后异常e）
{
Log.e（标记，e.toString（））；
返回JaappApplication.FAIL；
}
捕获（例外e）{
/*向GUI显示任何错误：*/
Log.e（标记，e.toString（））；
返回JaappApplication.FAIL；
}
}
公共int-parseXml（InputStream为，int类型）{
试一试{
/*从SAXPArserFactory获取SAXParser*/
SAXParserFactory spf=SAXParserFactory.newInstance（）；
spf.setNamespaceAware（true）；
SAXParser sp=spf.newSAXParser（）；
/*获取我们创建的SAXParser的XMLReader*/
XMLReader xr=sp.getXMLReader（）；
if（type==JaappApplication.QUESTIONS）{
xr.setContentHandler（questionHandler）；
//}else if（type==nrtaplication.BOTTOMAD）{
//xr.setContentHandler（myBottomAdHandler）；
}
/*创建新的ContentHandler并将其应用于XML读取器*/
/*从我们的URL解析xml数据*/
InputSource is1=新的InputSource（is）；
is1.设置编码（“ISO-8859-1”）；
xr.parse（is1）；
/*解析已完成*/
返回JaappApplication.SUCCESS；
}
捕获（未知后异常e）
{
Log.e（标记，e.toString（））；
返回JaappApplication.FAIL；
}
捕获（例外e）{
/*向GUI显示任何错误：*/