public void startDocument()
当遇到文档的开头的时候，调用这个方法，可以在其中做一些预处理的工作。 public void startElement(String namespaceURI, String localName, String qName, Attributes attributes)
当读到一个开始标签的时候，会触发这个方法，再次获得元素的属性。namespaceURI就是命名空间，localName是不带命名空间前缀的标签名，qName是带命名空间前缀的标签名。通过attributes可以得到所有的属性名和相应的值。要注意的是SAX中一个重要的特点就是它的流式处理，当遇到一个标签的时候，它并不会纪录下以前所碰到的标签，也就是说，在startElement()方法中，所有你所知道的信息，就是标签的名字和属性，至于标签的嵌套结构，上层标签的名字，是否有子元属等等其它与结构相关的信息，都是不得而知的，都需要你的程序来完成。这使得SAX在编程处理上没有DOM来得那么方便。 public void characters(char[] ch, int start, int length)
这个方法用来处理在XML文件中读到的内容，第一个参数用于存放文件的内容，后面两个参数是读到的字符串在这个数组中的起始位置和长度，使用new String(ch,start,length)就可以获取内容。 public void endElement(String uri, String localName, String name)
和startElement()方法相对应，在遇到结束标签的时候，调用这个方法。public void endDocument()
和startDocument()方法相对应。当文档结束的时候，调用这个方法，可以在其中做一些善后的工作。 

<?xml version="1.0" encoding="UTF-8"?>
<persons><person id="01"><name>smyh</name><age>22</age></person><person id="02"><name>vae</name><age>24</age></person>
</persons>

 1 package com.example.androidsaxxml.http;
 2
 3 import java.io.InputStream;
 4 import java.net.HttpURLConnection;
 5 import java.net.URL;
 6
 7 //工具类：通过URLHttpConnection获取服务器上的XML流
 8 public class HttpUtils {
 9
10     public HttpUtils() {
11     }
12
13     //方法：返回的InputStream对象就是服务器返回的XML流。
14     public static InputStream getXML(String path) {//参数path：之后将在MainActivity中指定具体的url链接
15         try {
16             URL url=new URL(path);
17             if(url!=null)
18             {
19                 HttpURLConnection connection=(HttpURLConnection)url.openConnection();
20                 connection.setDoInput(true);
21                 connection.setConnectTimeout(3000);
22                 connection.setRequestMethod("GET");
23                 int requesetCode=connection.getResponseCode();
24                 if(requesetCode==200)
25                 {
26                     //如果执行成功，返回HTTP响应流
27                     return connection.getInputStream();
28                 }
29             }
30         } catch (Exception e) {
31             // TODO: handle exception
32         }
33         return null;
34     }
35 } 

 1 package com.example.androidsaxxml.handler;
 2
 3 import java.util.ArrayList;
 4 import java.util.HashMap;
 5 import java.util.List;
 6
 7 import org.xml.sax.Attributes;
 8 import org.xml.sax.SAXException;
 9 import org.xml.sax.helpers.DefaultHandler;
10
11
12 //类：MyHandler，继承DefaultHandler类，用于解析XML数据。
13 //之后在MainActivity中通过设定具体的nodeName来实例化MyHandler
14 public class MyHandler extends DefaultHandler {
15     private List<HashMap<String, String>> list = null; //解析后的XML内容
16     private HashMap<String, String> map = null;  //存放当前需要记录的节点的XML内容
17     private String currentTag = null;//当前读取的XML节点
18     private String currentValue = null;//当前节点的XML文本值
19     private String nodeName = null;//需要解析的节点名称
20
21     public MyHandler(String nodeName) {
22         // 设置需要解析的节点名称
23         this.nodeName = nodeName;
24     }
25
26     @Override
27     public void startDocument() throws SAXException {
28         // 接收文档开始的通知
29         // 实例化ArrayList用于存放解析XML后的数据
30         list = new ArrayList<HashMap<String, String>>();
31     }
32
33     @Override
34     public void startElement(String uri, String localName, String qName,
35             Attributes attributes) throws SAXException {
36         // 接收元素开始的通知
37         if (qName.equals(nodeName)) {
38             //如果当前运行的节点名称与设定需要读取的节点名称相同，则实例化HashMap
39             map = new HashMap<String, String>();
40         }
41         //Attributes为当前节点的属性值，如果存在属性值，则属性值也读取。
42         if (attributes != null && map != null) {
43             for (int i = 0; i < attributes.getLength(); i++) {
44                 //读取到的属性值，插入到Map中。
45                 map.put(attributes.getQName(i), attributes.getValue(i));
46             }
47         }
48         //记录当前节点的名称。
49         currentTag = qName;
50     }
51
52     @Override
53     public void characters(char[] ch, int start, int length)
54             throws SAXException {
55         // 接收元素中字符数据的通知。
56         //当前节点有值的情况下才继续执行
57         if (currentTag != null && map != null) {
58             //获取当前节点的文本值，ch这个直接数组就是存放的文本值。
59             currentValue = new String(ch, start, length);
60             if (currentValue != null && !currentValue.equals("")
61                     && !currentValue.equals("\n")) {
62                 //读取的文本需要判断不能为null、不能等于”“、不能等于”\n“
63                 map.put(currentTag, currentValue);
64             }
65         }
66         //读取完成后，需要清空当前节点的标签值和所包含的文本值。
67         currentTag = null;
68         currentValue = null;
69     }
70
71     @Override
72     public void endElement(String uri, String localName, String qName)
73             throws SAXException {
74         // 接收元素结束的通知。
75         if (qName.equals(nodeName)) {
76             //如果读取的结合节点是我们需要关注的节点，则把map加入到list中保存
77             list.add(map);
78             //使用之后清空map，开始新一轮的读取person。
79             map = null;
80         }
81     }
82
83     //方法：获取解析之后的数据
84     public List<HashMap<String, String>> getList() {
85         return list;
86     }
87 }

 1 package com.example.androidsaxxml.service;
 2
 3 import java.io.InputStream;
 4 import java.util.HashMap;
 5 import java.util.List;
 6
 7 import javax.xml.parsers.SAXParser;
 8 import javax.xml.parsers.SAXParserFactory;
 9
10 import com.example.androidsaxxml.handler.MyHandler;
11
12
13 //类：用于实例化例化一个SAX解析器的工厂对象:SAXParserFactory
14 public class SaxService {
15
16     public SaxService() {
17         // TODO Auto-generated constructor stub
18     }
19
20     //方法：解析xml数据并返回，返回值类型是HashMap
21     public static List<HashMap<String, String>> readXML(InputStream inputStream,String nodeName)
22     {
23         try {
24             //实例化SAX工厂类
25             SAXParserFactory factory=SAXParserFactory.newInstance();
26             //实例化SAX解析器。
27             SAXParser sParser=factory.newSAXParser();
28             //实例化工具类MyHandler，设置需要解析的节点
29             MyHandler myHandler=new MyHandler(nodeName);
30             // 开始解析
31             sParser.parse(inputStream, myHandler);
32             // 解析完成之后，关闭流
33             inputStream.close();
34             //返回解析结果。
35             return myHandler.getList();  //在这里返回解析之后的数据
36         } catch (Exception e) {
37             // TODO: handle exception
38         }
39         return null;
40     }
41
42 } 

 1 package com.example.androidsaxxml;
 2
 3 import java.io.InputStream;
 4 import java.util.HashMap;
 5 import java.util.List;
 6
 7 import android.app.Activity;
 8 import android.os.Bundle;
 9 import android.view.View;
10 import android.widget.Button;
11
12 import com.example.androidsaxxml.http.HttpUtils;
13 import com.example.androidsaxxml.service.SaxService;
14
15
16 public class MainActivity extends Activity {
17     private Button button;
18     @Override
19     protected void onCreate(Bundle savedInstanceState) {
20         super.onCreate(savedInstanceState);
21         setContentView(R.layout.activity_main);
22
23         button=(Button)findViewById(R.id.button1);
24         button.setOnClickListener(new View.OnClickListener() {
25
26             @Override
27             //点击按钮，开启线程访问网络
28             public void onClick(View v) {
29                 Thread thread=new Thread(new Runnable() {
30
31                     @Override
32                     public void run() {
33                         // 设置XML文档的路径
34                         String path="http://192.168.1.112:8080/smyhvae.xml";
35                         //调用类HttpUtils：从服务器上获取XML流。
36                         InputStream inputStream=HttpUtils.getXML(path);
37                         try {
38                             //调用类SaxService：解析流，同时设定需要解析的节点
39                             List<HashMap<String, String>> list=SaxService.readXML(inputStream, "person");
40                             for(HashMap<String,String> map:list)
41                             {
42                                 //打印到LogCat中
43                                 System.out.println(map.toString());
44                             }
45                         } catch (Exception e) {
46                             // TODO: handle exception
47                         }
48                     }
49                 });
50                 thread.start();
51             }
52         });
53     }
54 }