1 XML解析No29
【
XML:可拓展标记语言，语言和HTML类似，也是一种标记语言。
特点：标记是自定义的，并区分大小写
除开文档声明的标签,XML文件中只能有一个根标签。
XML的应用场景
l传输数据
XML本质上是一段字符串，具有跨平台性的特性，因此XML常被用来在不同系统之间进行数据交换。
l配置文件
XML可以在保存数据的同时保存数据之间的关系。利用这一特点，它还经常用作应用程序配置文件来使用。
XML解析和序列化
lAndroid中，XML解析主要有三种方式
Ø DOM解析(org.w3c.dom)
ü 语法简单，但是使用时需要将整个文档加载到内存中，耗内存
ü 特点：在解析的时候会将文本中的数据一次性全部加载到内存中
Ø SAX解析(org.xml.sax)
ü 语法复杂，不需要一次性将文档加载到内存中，内存消耗小
ü 特点：在解析的时候是一点一点加载内容并解析
ØPull解析(org.xmlpull.v1)
ü 在Android鼓励使用Pull方式来解析xml文件（Android集成了Pull解析）
ü 类似于SAX解析，语法比SAX解析简单，效率更高
lPull解析方式
Ø Xml.newPullParser // 获取一个Pull解析器对象
Ø setInput(Reader reader)
Ø setInput(InputStreaminputStream, String inputEncoding)
Ø Context.getResources().getXml(intresId)
ü Android下专用的方法
ü 用于获得一个XmlResourceParser（其实就是XmlPullParser的子类）
ü 返回值对象已经指定了xml文件
ü 私有的xml文件也能像资源一样放入/res/xml下
Ø getEventType() // 获得当前的事件类型
ü XmlPullParser.START_DOCUMENT
ü XmlPullParser.END_DOCUMENT
ü XmlPullParser.START_TAG
ü XmlPullParser.END_TAG
ü XmlPullParser.TEXT
Ø next() // 访问下一个event，并返回下一个事件的类型
Ø getAtttributeValue() // 获取属性值
Ø nextText() // 获得当前标签后对应的值
lXml的序列化
有些时候，我们需要生成一个XML文件，生成XML文件的方法有很多，如：可以只使用一个StringBuilder组拼XML内容，然后把内容写入到文件中；或者使用DOM API生成XML文件，或者也可以使用pull序列化器生成XML文件，这里推荐大家使用Pull序列化器。
案例中需要用到的xml文件如下：
文件名称：iotek.xml
小强
5
如花
5
】
待解析文件：
【
zhangsan
20
lisi
21
wangwu
22
thinkinginJava
15
SpringAction
39
张明
30
莉莉
25
】
【
public class Student{
private String id;
private String name;
private String age;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
}
public classStudentHandler extends DefaultHandler {
private String currentTag ="";//当前标签
private List list;//声明在属性位置，生命周期长，可在多方法间操作
private Student student; //声明在属性位置，让各个方法都可以操作它指向的对象
@Override
//开始文档
public void startDocument() throwsSAXException {
list = newArrayList(); //创建list
}
//开始文档节点
@Override
public void startElement(String uri,String localName, String qName,
Attributesattributes) throws SAXException {
currentTag = qName; //每次遇到开始标签，把这个标签的名字赋给currentTag
if(currentTag.equals("student")){//当前标签为student
String attr =attributes.getValue("id");
student = newStudent(); //扫描student开始标签，就要创建一个Student对象
student.setId(attr); //将解析出的id值设置进student
}
}
//结束标签
@Override
public void endElement(String uri,String localName, String qName)
throws SAXException{
currentTag = "";//遇到结束标签，将currentTag改回""，避免后面的文本被误认为是name和age
if(qName.equals("student")){
list.add(student);//把新建并初始化好了的Student对象放进list
}
}
@Override
public void characters(char[] ch, intstart, int length)
throws SAXException{
if(currentTag.equals("name")){//如果当前标签为name
student.setName(newString(ch,start,length));//将最近new的学生对象名字设置成解析出的内容
}elseif(currentTag.equals("age")){//如果当前标签是age
student.setAge(newString(ch, start, length));//将最近new的学生对象年龄设置一下
}
}
@Override
public void endDocument() throwsSAXException {
System.out.println("文档解析结束");
}
//方法返回List
public List getList(){
return list;
}
}
测试：
SAXParserFactoryfactory =SAXParserFactory.newInstance();
StudentHandler handler = newStudentHandler();
try {
SAXParser parser =factory.newSAXParser();
parser.parse(newFileInputStream("g:/student.xml"), handler);
Listlist = handler.getList();//把解析好的，填充了学生对象的list取出来
for (Student s :list) {
System.out.println(s.getId()+""+s.getName()+" "+s.getAge());
}
SAXParserFactoryfactory = SAXParserFactory.newInstance();
try {
SAXParser parser =factory.newSAXParser();
URL url = newURL("http://localhost:8080/forecast/forecast.xml");
HttpURLConnectioncon = (HttpURLConnection) url.openConnection();
if(con.getResponseCode()==200){
TempHandlerhandler = new TempHandler();
parser.parse(con.getInputStream(),handler);
Listlist = handler.getList();
Collections.sort(list,new Comparator(){
publicint compare(City o1, City o2) {
returno1.getTemp()-o2.getTemp();
}
});
for(City c:list){
System.out.println(c);
}
}
】
Map形式存储：
【
public class MyHandler extends DefaultHandler {
privateHashMap map = null;//存储单个解析的完整对象
privateList> list = null;//存储所有解析对象
privateString currentTag = null; //正在解析的元素的标签
privateString currentValue = null; //解析当前元素的值
privateString nodeName = null; //解析当前的节点名称
//构造方法
publicMyHandler(String nodeName) {
this.nodeName= nodeName;
}
//属性list get方法
publicList> getList() {
returnlist;
}
@Override
//开始文档
public voidstartDocument() throws SAXException {
//TODO Auto-generated method stub
//当读到第一个开始标签的时候，就会触发这个方法
list= new ArrayList>();
}
@Override
//开始节点
public voidstartElement(String uri, String localName, String qName,
Attributesattributes) throws SAXException {
//当遇到文档开头的时候，调用这个方法
//TODO Auto-generated method stub
if(qName.equals(nodeName)) {
map= new HashMap();
}
if(attributes != null && map != null) {
for(int i = 0; i < attributes.getLength(); i++) {
map.put(attributes.getQName(i),attributes.getValue(i));
}
}
currentTag= qName;
}
@Override
//解析到文本
public voidcharacters(char[] ch, int start, int length)
throwsSAXException {
//TODO Auto-generated method stub
//这个方法是用来处理xml文件所读取到的内容
if(currentTag != null && map != null) {
currentValue= new String(ch, start, length);
if(currentValue != null && !currentValue.trim().equals("")
&&!currentValue.trim().equals("\n")) {
map.put(currentTag,currentValue);
}
}
currentTag= null; //把当前的节点的对应值和标签设置为空
currentValue= null;
}
@Override
public voidendElement(String uri, String localName, String qName)
throwsSAXException {
//TODO Auto-generated method stub
//遇到结束标记的时候，会调用这个方法
if(qName.equals(nodeName)) {
list.add(map);
map= null;
}
super.endElement(uri,localName, qName);
}
}
public class HttpUtils {
publicHttpUtils() {
}
publicstatic InputStream getXML(String path){
InputStreaminputStream=null;
try{
URLurl=new URL(path);
if(url!=null){
HttpURLConnectionconnection=(HttpURLConnection)url
.openConnection();
connection.setConnectTimeout(3000);
connection.setDoInput(true);
connection.setRequestMethod("GET");
intcode=connection.getResponseCode();
if(code==200){
inputStream=connection.getInputStream();
}
}
}catch (Exception e) {
//TODO: handle exception
}
returninputStream;
}
}
public class SaxService {
publicSaxService() {
//TODO Auto-generated constructor stub
}
publicstatic List> readXML(
InputStreaminputStream, String nodeName) {
/* List> list = null;*/
try{
//创建一个解析xml的工厂对象
SAXParserFactoryapf = SAXParserFactory.newInstance();
SAXParserparser = apf.newSAXParser();//解析xml
MyHandlerhandler = new MyHandler(nodeName);
parser.parse(inputStream,handler);
inputStream.close();
returnhandler.getList();
}catch (Exception e) {
//TODO: handle exception
}
returnnull;
}
}
public class Test {
publicTest() {
//TODO Auto-generated constructor stub
}
/**
* @param args
*/
publicstatic void main(String[] args) {
//TODO Auto-generated method stub
// Stringpath="http://192.168.81.144:8080/myhttp/persons.xml";
Stringpath="http://xys:8080/myhttp/persons.xml";
InputStreaminputStream=HttpUtils.getXML(path);
try{
List>list=SaxService.readXML(inputStream, "person");
for(HashMap map:list){
System.out.println(map.toString());
}
}catch (Exception e) {
//TODO: handle exception
}
}
}
】
待解析文件：
【
zhangsan
20
lisi
21
wangwu
22
】
解析1：
【
public class Student {
privateString id;
privateString name;
privateString age;
publicString getId() {
returnid;
}
public voidsetId(String id) {
this.id= id;
}
publicString getName() {
returnname;
}
public voidsetName(String name) {
this.name= name;
}
publicString getAge() {
returnage;
}
public voidsetAge(String age) {
this.age= age;
}
@Override
publicString toString() {
return"Student [id=" + id + ", name=" + name + ", age="+ age + "]";
}
}
publicstatic void main(String[] args) {
try{//创建解析工厂
XmlPullParserFactoryfactory = XmlPullParserFactory.newInstance();
//工厂制造解析器
XmlPullParserparser = factory.newPullParser();
//设置输入，设置要解析的东西
parser.setInput(newFileReader("g:/human.xml"));
//next方法返回下一个要解析的内容的类型，如：标签开始、标签结束、标签之间的文本
inttype = parser.next();//扫描下一个内容，返回下一个内容的类型，int类型的，赋给type
StringcurrentTag = "";//当前标签
while(type!=XmlPullParser.END_DOCUMENT){//通过type是否等于1来判断是否到达底部
if(type== XmlPullParser.START_TAG){//如果扫描的是开始标签
System.out.println("<"+parser.getName()+">");
currentTag= parser.getName();//currentTag赋为标签名
if(currentTag.equalsIgnoreCase("human")){//如果标签为Human
System.out.println(parser.getAttributeValue(null,"id"));//打印属性id值
}
}elseif(type== XmlPullParser.END_TAG){//如果扫描到的是结束标签
System.out.println("<"+parser.getName()+">");
currentTag="";//currentTag赋为空
}elseif(type == XmlPullParser.TEXT){//如果扫描到的是标签间的文本
System.out.println(parser.getText());//打印出标签间文本
if(currentTag.equals("human")){//如果这个文本在human的开始、结束标签之间
System.out.println(parser.getText().trim());//打印这个文本
}
}
type= parser.next();//每次操作完成后，再往后扫描
}
public static void main(String[] args) {
try{//创建解析工厂
XmlPullParserFactoryfactory = XmlPullParserFactory.newInstance();
//工厂制造解析器
XmlPullParserparser = factory.newPullParser();
//设置输入，设置要解析的东西
parser.setInput(newFileReader("g:/student.xml"));
//next方法返回下一个要解析的内容类型，如：标签开始、标签结束、标签之间的文本
inttype = parser.next();//扫描下一个内容，返回下一个内容的类型，int类型的，赋给type
StringcurrentTag = "";//当前标签
Listlist = new ArrayList();//空list
Students = null;//声明在循环外面，为了在多次循环中对同一个Student对象进行操作
while(type!= XmlPullParser.END_DOCUMENT){//通过type是否等于1来判断是否到达底部
if(type== XmlPullParser.START_TAG){//如果扫描的是开始标签
currentTag= parser.getName();//currentTag赋为标签名
if(currentTag.equals("student")){//如果是开始标签为student
s= new Student();//创建一个学生对象
s.setId(parser.getAttributeValue(null,"id"));//把id属性的值放进学生对象
}
}elseif(type == XmlPullParser.END_TAG){//如果扫描到的是结束标签
currentTag= "";//currentTag赋为空
if(parser.getName().equals("student")){//如果是student结束标签
list.add(s);//把这个学生放进list
}
}elseif(type==XmlPullParser.TEXT){//如果扫描到的是标签间的文本
if(currentTag.equals("name")){
s.setName(parser.getText().trim());//将内容设置进学生对象
}elseif(currentTag.equals("age")){//如果在age的开始、结束标签之间
s.setAge(parser.getText()); //设置进学生对象
}
}
type= parser.next();//每次操作完成后，再往后扫描
}
for(Student stu : list) {
System.out.println(stu);
}
public staticvoid main(String[] args) {
try{//创建解析器工厂
XmlPullParserFactoryfactory = XmlPullParserFactory.newInstance();
//工厂制造解析器
XmlPullParserparser = factory.newPullParser();
//设置输入，设置需要解析的东西
parser.setInput(newFileReader("g:/student.xml"));
inttype = 0;
StringcurrentTag = "";//当前标签
Listlist = new ArrayList();//空list
Students =null;//声明在循环外面，为了在多次循环中对同一个Student对象进行操作
while((type=parser.next())!=XmlPullParser.END_DOCUMENT){//通过type是否等于1来判断是否到达底部
// type= parser.next();//一次循环只能调用一次next()
if(type== XmlPullParser.START_TAG){//如果扫描的是开始标签
currentTag= parser.getName();//currentTag赋为标签名
if(currentTag.equals("student")){//如果是开始标签为student
s= new Student(); //创建一个学生对象
s.setId(parser.getAttributeValue(null,"id"));//把id属性的值放进学生对象
}
}elseif(type == XmlPullParser.END_TAG){//如果扫描到的是结束标签
currentTag= "";//currentTag赋为空
if(parser.getName().equals("student")){
list.add(s);//把这个学生放进list
}
}elseif(type == XmlPullParser.TEXT){//如果扫描到的是标签间的文本
if(currentTag.equals("name")){//如果这个文本在name的开始、结束标签之间
s.setName(parser.getText().trim());//将内容放置进学生对象
}elseif(currentTag.equals("age")){//如果在age的开始、结束标签之间
s.setAge(parser.getText().trim());//设置进学生对象
}
}
}
for(Student stu : list) {
System.out.println(stu.toString());
}
System.out.println(list.size());
】
解析2：
【
public class Person {
private intid;
privateString name;
private intage;
publicPerson() {
//TODO Auto-generated constructor stub
}
public intgetId() {
returnid;
}
public voidsetId(int id) {
this.id= id;
}
publicString getName() {
returnname;
}
public voidsetName(String name) {
this.name= name;
}
public intgetAge() {
returnage;
}
public voidsetAge(int age) {
this.age= age;
}
publicPerson(int id, String name, int age) {
this.id= id;
this.name= name;
this.age= age;
}
@Override
publicString toString() {
return"Person [id=" + id + ", name=" + name + ", age="+ age + "]";
}
}
public class HttpUtils {
publicHttpUtils() {
//TODO Auto-generated constructor stub
}
/**
*从服务器获得xml文件返回流
*
* @param path
* @return
*/
publicstatic InputStream getXML(String path) {
InputStreaminputStream = null;
try{
URLurl = new URL(path);
if(url != null) {
HttpURLConnectionconnection = (HttpURLConnection) url
.openConnection();
connection.setConnectTimeout(3000);
connection.setDoInput(true);
connection.setRequestMethod("GET");
intcode = connection.getResponseCode();
if(code == 200) {
inputStream= connection.getInputStream();
}
}
}catch (Exception e) {
//TODO: handle exception
}
returninputStream;
}
}
public class PullXMLTools {
/**
*主要是使用PULL解析xml
*/
publicPullXMLTools() {
//TODO Auto-generated constructor stub
}
/**
*
* @param inputStream
*从服务器获取xml文件，以流的形式返回
* @param encode
*编码格式
* @return
* @throws XmlPullParserException
*/
publicstatic List parseXML(InputStream inputStream, String encode)
throwsException {
Listlist = null;
Personperson = null; //装载解析每一个person节点的内容
//创建一个xml解析的工厂
XmlPullParserFactoryfactory = XmlPullParserFactory.newInstance();
//获得xml解析类的引用
XmlPullParserparser = factory.newPullParser();
parser.setInput(inputStream,encode);
//获得事件的类型
inteventType = parser.getEventType();
while(eventType != XmlPullParser.END_DOCUMENT) {
switch(eventType) {
caseXmlPullParser.START_DOCUMENT:
list= new ArrayList();
break;
caseXmlPullParser.START_TAG:
if("person".equals(parser.getName())) {
person= new Person();
//取出属性值
intid = Integer.parseInt(parser.getAttributeValue(0));
person.setId(id);
}else if ("name".equals(parser.getName())) {
Stringname = parser.nextText();//获取该节点的内容
person.setName(name);
}else if ("age".equals(parser.getName())) {
intage = Integer.parseInt(parser.nextText());
person.setAge(age);
}
break;
caseXmlPullParser.END_TAG:
if("person".equals(parser.getName())) {
list.add(person);
person= null;
}
break;
}
eventType= parser.next();
}
returnlist;
}
}
/**
* @param args
*/
publicstatic void main(String[] args) {
//TODO Auto-generated method stub
Stringpath="http://xys:8080/myhttp/persons.xml";
InputStreaminputStream=HttpUtils.getXML(path);
Listlist=null;
try{
list=PullXMLTools.parseXML(inputStream,"utf-8");
for(Personperson:list){
System.out.println(person);
}
}catch (Exception e) {
//TODO: handle exception
}
}
】
XML extensible markup language 可扩展标记语言，使用标签来表达信息，标签的使用方式和html是一样的，但是比html更灵活，使用范围更广泛，可以认为html是一种特殊的xml;一般用于网络信息传输、信息的保存(如web.xml)
SAX它是在JDK中集成了的xml处理工具,可以用来生成、解析xml
SAXParserFactory解析工厂
SAXParser解析器
parse(InputStreamis,DefaultHandler dh)
第一个参数是要解析什么，第二个是怎么解析
DefaultHandler 默认处理逻辑
要先定义一个类继承DefaultHandler，重写其中的关键方法,写上解析的逻辑，再将其实例化，作为第二个参数传给parse方法
关键方法:
startElement()在扫描到开始标签时回调
参数qName代表标签名
参数attributes代码属性，可以用getValue()取出某属性
endElement()在扫描到结束标签时回调
参数qName代表标签名
characters()扫描到标签之间文本时回调，要注意在任何两个标签之间都会回调这个方法；可以通过定义属性并在
可用三个参数生成new String(ch,start,length)
startElement()和endElement()中变更并在characters()中判断的方式过滤掉无效的文本
startDocument()在开始扫描文档时回调
endDocument()在结束扫描文档时回调
PULL 解析,Android自带，但JDK没有
【
XML文件：books.xml
《
哈利波特
99.9
Thinking In Java
120
小李飞刀
50
》
实体类：Book.java
《
publicclass Book {
private int id;
private String name;
private double price;
public Book(){
}
public Book(int id, String name, doubleprice) {
this.id = id;
this.name = name;
this.price = price;
}
。。。。。。。。。。。。。
》
解析：XMLDemo.java
《
publicclass XMLDemo {
public static void main(String[] args)throws XmlPullParserException, IOException {
// XML PULL解析案例
// pull解析器工厂
XmlPullParserFactory factory= XmlPullParserFactory.newInstance();
// 创建pull解析器对象
XmlPullParser parser =factory.newPullParser();
/*
* pull解析的解析方式是类似SAX解析，将解析xml的内容分成不同的事件
* 主要有以下事件：
* 1、XmlPullParser.START_DOCUMENT 文档的开始
* 2、XmlPullParser.END_DOCUMENT 文档的结尾
* 3、XmlPullParser.START_TAG 开始标签
* 4、XmlPullParser.END_TAG 结束标签
* 5、XmlPullParser.TEXT 文本的内容
*/
// 指定解析的文件
FileReader fr = newFileReader("src\\bo\\books.xml");
parser.setInput(fr);
// 声明List集合的引用
List list = null;
// 声明Book引用，用于临时保存Book对象的引用
Book book = null;
// 获取事件的类型
int eventType =parser.getEventType();
while(eventType !=XmlPullParser.END_DOCUMENT) {
// 对当前的事件进行解析
// 获取到当前标签的标签名
String tagName =parser.getName();
switch (eventType) {
caseXmlPullParser.START_TAG: // 开始标签
if("books".equals(tagName)){
//创建List集合对象，用于保存后面解析出来的Book对象
list= new ArrayList();
} elseif("book".equals(tagName)) {
//创建Book对象，用于保存后面解析出来的Book的属性
book= new Book();
//获取标签中的属性值（根据标签的索引获取，索引从0开始计数）
intid = Integer.parseInt(parser.getAttributeValue(0));
book.setId(id);
} elseif("name".equals(tagName)) {
//获取当前事件的后面的文本内容
Stringname = parser.nextText();
book.setName(name);
} elseif("price".equals(tagName)) {
doubleprice = Double.parseDouble(parser.nextText());
book.setPrice(price);
}
break;
caseXmlPullParser.END_TAG: // 结束标签
if("book".equals(tagName)){
//将Book对象存到list集合中
list.add(book);
//为了便于后期的维护，在使用完引用之后要引用置空，以便于保存下一个对象
book= null;
}
break;
default:
break;
}
// 移动到下一个事件
// 通过next方法可以移动到下一个事件，并获取到下一个事件的类型
eventType =parser.next();
}
fr.close();
fr = null;
for (Book b : list) {
System.out.println(b);
}
}
}
》
】
【
实体类：
/**
* 天气实体类
*/
publicclass Weather {
private String week;
private String temperature;
public String getWeek() {
return week;
}
public void setWeek(String week) {
this.week = week;
}
public String getTemperature() {
return temperature;
}
public void setTemperature(Stringtemperature) {
this.temperature =temperature;
}
@Override
public String toString() {
return "Weather[week=" + week + ", temperature=" + temperature + "]";
}
}
网络封装工具类：
publicclass HttpUtils {
private static final int TIMEOUT =10000;
//返回一个字节数组
public static byte[] doGet(Stringpath){
try {
URL mUrl = newURL(path);
HttpURLConnectionconn = (HttpURLConnection)mUrl.openConnection();
conn.setRequestMethod("GET");
conn.setReadTimeout(TIMEOUT);
conn.setReadTimeout(TIMEOUT);
conn.connect();
int code =conn.getResponseCode();
if(code == 200){
return readStream(conn.getInputStream());
}else{
throw new RuntimeException("网络访问失败："+code);
}
} catch(MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
public static byte[] doPost(String url,String params) {
HttpURLConnection conn =null;
try {
URL mUrl = newURL(url);
conn =(HttpURLConnection) mUrl.openConnection();
conn.setRequestMethod("POST");
conn.setConnectTimeout(TIMEOUT);
conn.setReadTimeout(TIMEOUT);
// 设置请求属性
conn.setRequestProperty("Content-Type","application/x-www-form-urlencoded");
conn.setRequestProperty("Content-Length",params.length()+"");
// Post请求必须要写以下两行代码
conn.setDoInput(true);
conn.setDoOutput(true);
// 将请求参数写到请求体中
conn.getOutputStream().write(params.getBytes());;
conn.connect();
int code =conn.getResponseCode();
if(code == 200) {
returnreadStream(conn.getInputStream());
} else {
throw newRuntimeException("网络访问失败："+ code);
}
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
if(conn != null) {
conn.disconnect();
conn =null;
}
}
}
//返回一个字符串
public static String doGetStr(Stringpath) throws IOException{
byte[] data = doGet(path);
return new String(data, "utf-8");
}
private static byte[]readStream(InputStream is) throws IOException{
ByteArrayOutputStream baos =new ByteArrayOutputStream();
byte[] buf = new byte[1024];
int len =0;
while((len =is.read(buf))!=-1){
baos.write(buf, 0,len);
}
return baos.toByteArray();
}
}
解析代码：
publicclass Test {
public static void main(String[] args)throws Exception {
// 下载数据
String url ="http://api.k780.com:88/?app=weather.future&weaid=1&&appkey=15250&sign=f88a5cecc3cbd37129bc090c0ae29943&format=xml";
String data = new String(HttpUtils.doGet(url),"utf-8");
System.out.println(data);
// 解析数据
XmlPullParserFactory factory= XmlPullParserFactory.newInstance();
XmlPullParser parser =factory.newPullParser();
StringReader sr = newStringReader(data);
parser.setInput(sr);
List list =null;
Weather weather = null;
int eventType =parser.getEventType();
tag:while(eventType !=XmlPullParser.END_DOCUMENT) {
String tagName =parser.getName();
//System.out.println(tagName);
switch (eventType) {
caseXmlPullParser.START_TAG: // 开始标签
if("success".equals(tagName)){
Stringsuccess = parser.nextText();
//如果success不是1的话，说明数据获取失败，直接结束解析
if(!"1".equals(success)){
System.out.println("数据获取失败");
breaktag;
}
} elseif("result".equals(tagName)) {
list= new ArrayList();
} elseif(tagName.startsWith("item")) {
weather= new Weather();
} elseif("week".equals(tagName)) {
Stringweek = parser.nextText();
weather.setWeek(week);
}else if("temperature".equals(tagName)) {
Stringtemperature = parser.nextText();
weather.setTemperature(temperature);
}
break;
caseXmlPullParser.END_TAG: // 结束标签
if(tagName.startsWith("item")){
list.add(weather);
weather= null;
}
break;
default:
break;
}
eventType =parser.next();
}
for (Weather w : list) {
System.out.println(w);
}
}
}
网络请求简约封装：
public static InputStream getXML(Stringpath) {
InputStream inputStream =null;
try {
URL url = newURL(path);
if (url != null) {
HttpURLConnectionconnection = (HttpURLConnection) url
.openConnection();
connection.setConnectTimeout(3000);
connection.setDoInput(true);
connection.setRequestMethod("GET");
intcode = connection.getResponseCode();
if (code ==200) {
inputStream= connection.getInputStream();
}
}
} catch (Exception e) {
// TODO: handleexception
}
return inputStream;
}
】
