Xml的生成与解析

在Android中xml的生成有两种，其一是手工写入，其二是用XmlSerializer对象来生成。

比如要生成下面这中。

先创建一个SmsBean.java 类用来封装信息。

1 package cn.starry.xml.bean;
2 
3 public class SmsBean {
4     public String num;
5     public String msg;
6     public String date;
7     public int id;
8 }

View Code

然后用SmsDao.java去设置信息。

 1 package cn.starry.xml.dao;
 2 
 3 import java.util.ArrayList;
 4 
 5 import cn.starry.xml.bean.SmsBean;
 6 
 7 public class SmsDao {
 8     //获得短信数据，模拟一些假数据
 9     public static ArrayList<SmsBean> getAllSms() {
10             
11         ArrayList<SmsBean> arrayList = new ArrayList<SmsBean>();
12         
13         SmsBean smsBean = new SmsBean();
14         smsBean.id = 1;
15         smsBean.num = "120";
16         smsBean.msg = "dasdadas";
17         smsBean.date = "2017-7-17";
18         arrayList.add(smsBean);
19         
20         SmsBean smsBean1 = new SmsBean();
21         smsBean1.id = 2;
22         smsBean1.num = "110";
23         smsBean1.msg = "daAAAs";
24         smsBean1.date = "2017-7-17";
25         arrayList.add(smsBean1);
26         
27         SmsBean smsBean2 = new SmsBean();
28         smsBean2.id = 3;
29         smsBean2.num = "130";
30         smsBean2.msg = "daDDDs";
31         smsBean2.date = "2017-7-17";
32         arrayList.add(smsBean2);
33         return arrayList;
34         
35     }
36 
37 }

View Code

 

方法一：

创建一个StringBuffer对象，然后往里面手工append。

 1 public static boolean backupSms(Context mContext) {
 2         
 3         allSms = SmsDao.getAllSms();
 4         StringBuffer sb = new StringBuffer();
 5         //封装一个头
 6         sb.append("<?xml version='1.0' encoding='utf-8' standalone='yes' ?>");
 7         //封装根节点
 8         sb.append("<Smss>");
 9         //循环遍历list集合封装所有的短信
10         for (SmsBean smsBean : allSms) {
11             sb.append("<Sms id = \""+smsBean.id+"\">");
12             
13             sb.append("<num>");
14             sb.append(smsBean.num);
15             sb.append("</num>");
16             
17             sb.append("<msg>");
18             sb.append(smsBean.msg);
19             sb.append("</num>");
20             
21             sb.append("<date>");
22             sb.append(smsBean.date);
23             sb.append("</date>");
24             sb.append("</Sms>");
25         }
26         sb.append("</Smss>");
27         
28         try {
29             FileOutputStream openFileOutput = mContext.openFileOutput("backupsms.xml", Context.MODE_PRIVATE);
30             openFileOutput.write(sb.toString().getBytes());
31             openFileOutput.close();
32             return true;
33         } catch (Exception e) {
34             e.printStackTrace();
35         }
36         return false;
37     }

这种方法明显不好，只要有一个地方写错了，就有可能生成不了，比如把一个'/'丢了，肯定生成不了了。

正好Android里自带了一个XmlSerializer类，可以用来生成xml的。

里面有几个常用的方法

1、setOutput(os, encoding) :os表示写入的文件， encoding表示写入的编码

2、startDocument(encoding, standalone)：序列化xml的声明头，比如<?xml version='1.0' encoding='utf-8' standalone='yes' ?>  

　　　　　　　　　　　　　　　　　　　　encoding表示xml的编码，standalone：是否独立

3、startTag(namespace, name)：序列化一个根节点的开始节点，namespace表示命名空间，name表示根节点的名字

4、attribute(namespace, name, value)：name属性的名称，value属性值。

4、text(text)：text参数表示需要在根节点下添加的内容

5、endTag(namespace, name)：与startTag相反，一个根节点的结束

6、endDocument 完成xml的序列化

 1 public static boolean backupSms_androind(Context mContext){
 2         try{
 3             allSms = SmsDao.getAllSms();
 4             //1创建一个XmlSerializer对象
 5             XmlSerializer xs = Xml.newSerializer();
 6             //2设置XmlSerializer的一些参数，比如：设置写入的xml文件的对象
 7             xs.setOutput(mContext.openFileOutput("backupsms2.xml", mContext.MODE_PRIVATE), "utf-8");
 8             //3序列化一个xml的声明头
 9             xs.startDocument("utf-8", true);
10             //4序列化一个根节点的开始节点
11             xs.startTag(null, "Smss");
12             //5循环遍历list集合序列化一条条短信
13             
14             for (SmsBean smsBean : allSms) {
15                 xs.startTag(null, "sms");
16                 //name:属性的名称   value:属性值
17                 xs.attribute(null, "id", smsBean.id+"");
18                 
19                 
20                 xs.startTag(null, "num");
21                 xs.text(smsBean.num);
22                 xs.endTag(null, "num");
23                 
24                 
25                 xs.startTag(null, "msg");
26                 xs.text(smsBean.msg);
27                 xs.endTag(null, "msg");
28                 
29                 xs.startTag(null, "date");
30                 xs.text(smsBean.date);
31                 xs.endTag(null, "date");
32                 
33                 
34                 xs.endTag(null, "sms");
35             }
36             
37             //6序列化一个跟根节点的结束节点
38             xs.endTag(null, "Smss");
39             //7将xml写入到文件中，完成xml的序列化
40             
41             xs.endDocument();
42             return true;
43         }catch (Exception e) {
44             e.printStackTrace();
45         }
46         return false;
47     }

 

 

 

 

xml的解析可以通过Xml获取一个XmlPullParse对象来操作。

XmlPullParse对象常用方法有：

1、getEventType()：获取当前xml行的事件类型

2、getName():获取标签的名字

3、getAttributeValue(namespace, name):获取属性

4、nextText():获取当前标签的内容

然后可以通过XmlPullParser.END_DOCUMENT、XmlPullParser.START_TAG、XmlPullParser.END_TAG判断文档是否结束或标签是否开始或结束来操作。

 

除了从mContext下的目录获取xml外，还可以从assets中获取。

 1 public static int restoreSms(Context mContext) {
 2         ArrayList<SmsBean> arrayList = null;
 3         SmsBean smsBean = null;
 4         try{
 5             //1通过Xml获取一个XMLPullParse对象
 6             XmlPullParser xpp = Xml.newPullParser();
 7             //2设置XmlPullParse对象的参数，需要解析的是哪个文件，设置一个文件读取流
 8             
 9             //通过context获取一个资产管理者对象
10             AssetManager assets = mContext.getAssets();
11             InputStream inputStream = assets.open("backupsms2.xml");
12             xpp.setInput(inputStream, "utf-8");
13             
14 //            xpp.setInput(mContext.openFileInput("backupsms2.xml"), "utf-8");
15             //3获取当前Xml行的事件类型
16             int type = xpp.getEventType();
17             //4判断事件类型是否是文档结束的事件类型
18             while(type != XmlPullParser.END_DOCUMENT) {
19                 //5如果不是，循环遍历解析每一行的数据，解析一行后，获取下一行的事件类型
20                 
21                 String currentTagName = xpp.getName();
22                 //判断当前行的事件类型是开始标签还是结束标签
23                 switch (type) {
24                 case XmlPullParser.START_TAG:
25                     if(currentTagName.equals("Smss")){
26                         arrayList = new ArrayList<SmsBean>();
27                     }else if(currentTagName.equals("sms")) {
28                         smsBean = new SmsBean();
29                         smsBean.id = Integer.parseInt(xpp.getAttributeValue(null, "id"));
30                     }else if(currentTagName.equals("num")) {
31                         smsBean.num = xpp.nextText();
32                     }else if(currentTagName.equals("msg")) {
33                         smsBean.msg = xpp.nextText();
34                     }else if(currentTagName.equals("date")) {
35                         smsBean.date = xpp.nextText();
36                     }
37                     break;
38                 case XmlPullParser.END_TAG:
39                     if(currentTagName.equals("sms")){
40                         arrayList.add(smsBean);
41                     }
42                     break;
43                 default:
44                     break;
45                 }
46                 
47                 type = xpp.next();
48             }
49             
50             return arrayList.size();
51             
52             
53             //6将解析的数据封装到list中
54         }catch (Exception e) {
55             e.printStackTrace();
56         }
57         return 0;
58     }

 

转载于:https://www.cnblogs.com/xingkongyihao/p/7327723.html