在Android中读取/写入外部XML文件

我正在尝试学习更多关于在Android中读取/写入XML文件（作为一种数据库）的知识。我似乎找不到这方面的任何东西，所以我想我不知道该找什么术语

我的目标是将两个editText字段中的用户名和密码写入文件，然后在稍后为我的应用程序创建登录功能时读取它们（希望能够成功验证它们）

我希望读/写的文件位于服务器上，因此这对我来说有点复杂

如果有人能帮我找到一本关于读/写XML文件的教程，我将非常高兴

---

谢谢。

以下是写入XML文件的代码：

final String xmlFile = "userData";
String userNAme = "username";
String password = "password";
try {
    FileOutputStream fos = new  FileOutputStream("userData.xml");
    FileOutputStream fileos= getApplicationContext().openFileOutput(xmlFile, Context.MODE_PRIVATE);
    XmlSerializer xmlSerializer = Xml.newSerializer();              
    StringWriter writer = new StringWriter();
    xmlSerializer.setOutput(writer);
    xmlSerializer.startDocument("UTF-8", true);
    xmlSerializer.startTag(null, "userData");
    xmlSerializer.startTag(null, "userName");
    xmlSerializer.text(username_String_Here);
    xmlSerializer.endTag(null, "userName");
    xmlSerializer.startTag(null,"password");
    xmlSerializer.text(password_String);
    xmlSerializer.endTag(null, "password");             
    xmlSerializer.endTag(null, "userData");
    xmlSerializer.endDocument();
    xmlSerializer.flush();
    String dataWrite = writer.toString();
    fileos.write(dataWrite.getBytes());
    fileos.close();
}
catch (FileNotFoundException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}
catch (IllegalArgumentException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}
catch (IllegalStateException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}
catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}

要从XML文件中读取数据，请执行以下操作：

final String xmlFile = "userData";
ArrayList<String> userData = new ArrayList<String>();
try {
    fis = getApplicationContext().openFileInput(xmlFile);
    isr = new InputStreamReader(fis);
    inputBuffer = new char[fis.available()];
    isr.read(inputBuffer);
    data = new String(inputBuffer);
    isr.close();
    fis.close();
}
catch (FileNotFoundException e3) {
    // TODO Auto-generated catch block
    e3.printStackTrace();
}
catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}
XmlPullParserFactory factory = null;
try {
    factory = XmlPullParserFactory.newInstance();
}
catch (XmlPullParserException e2) {
    // TODO Auto-generated catch block
    e2.printStackTrace();
}
factory.setNamespaceAware(true);
XmlPullParser xpp = null;
try {
    xpp = factory.newPullParser();
}
catch (XmlPullParserException e2) {
    // TODO Auto-generated catch block
    e2.printStackTrace();
}
try {
    xpp.setInput(new StringReader(data));
}
catch (XmlPullParserException e1) {
    // TODO Auto-generated catch block
    e1.printStackTrace();
}
int eventType = 0;
try {
    eventType = xpp.getEventType();
}
catch (XmlPullParserException e1) {
    // TODO Auto-generated catch block
    e1.printStackTrace();
}
while (eventType != XmlPullParser.END_DOCUMENT){
    if (eventType == XmlPullParser.START_DOCUMENT) {
        System.out.println("Start document");
    }
    else if (eventType == XmlPullParser.START_TAG) {
        System.out.println("Start tag "+xpp.getName());
    }
    else if (eventType == XmlPullParser.END_TAG) {
        System.out.println("End tag "+xpp.getName());
    }
    else if(eventType == XmlPullParser.TEXT) {
        userData.add(xpp.getText());
    }
    try {
        eventType = xpp.next();
    }
    catch (XmlPullParserException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}
String userName = userData.get(0);
String password = userData.get(1);

最终字符串xmlFile=“userData”；
ArrayList userData=新的ArrayList（）；
试一试{
fis=getApplicationContext（）.openFileInput（xmlFile）；
isr=新的输入流阅读器（fis）；
inputBuffer=新字符[fis.available（）]；
isr.read（输入缓冲区）；
数据=新字符串（inputBuffer）；
isr.close（）；
fis.close（）；
}
捕获（FileNotFoundException e3）{
//TODO自动生成的捕捉块
e3.printStackTrace（）；
}
捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
XmlPullParserFactory工厂=null；
试一试{
factory=XmlPullParserFactory.newInstance（）；
}
catch（XmlPullParserException e2）{
//TODO自动生成的捕捉块
e2.printStackTrace（）；
}
factory.setNamespaceAware（true）；
XmlPullParser xpp=null；
试一试{
xpp=factory.newPullParser（）；
}
catch（XmlPullParserException e2）{
//TODO自动生成的捕捉块
e2.printStackTrace（）；
}
试一试{
xpp.setInput（新的StringReader（数据））；
}
捕获（XmlPullParserException e1）{
//TODO自动生成的捕捉块
e1.printStackTrace（）；
}
int-eventType=0；
试一试{
eventType=xpp.getEventType（）；
}
捕获（XmlPullParserException e1）{
//TODO自动生成的捕捉块
e1.printStackTrace（）；
}
while（eventType！=XmlPullParser.END_文档）{
if（eventType==XmlPullParser.START\u文档）{
System.out.println（“开始文档”）；
}
else if（eventType==XmlPullParser.START_标记）{
System.out.println（“开始标记”+xpp.getName（））；
}
else if（eventType==XmlPullParser.END_标记）{
System.out.println（“结束标记”+xpp.getName（））；
}
else if（eventType==XmlPullParser.TEXT）{
add（xpp.getText（））；
}
试一试{
eventType=xpp.next（）；
}
catch（XMLPullParseRexE）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
字符串userName=userData.get（0）；
字符串密码=userData.get（1）；

要在/storage/sdcard0/your_app_name/中创建新文件，请使用以下命令：

File file = new File(Environment.getExternalStorageDirectory().getAbsolutePath() + "/" + "your_app_name" + "/" + xmlFile);
        file.createNewFile();
        FileOutputStream fileos = new FileOutputStream(file);

公共类SkillsParser实现AssyncXmlReader{
私有字符串ns=“”；
@凌驾
公共对象解析（InputStream in）引发XmlPullParserException，
IOException{
试一试{
XmlPullParser=Xml.newPullParser（）；
setFeature（XmlPullParser.FEATURE_进程_名称空间，false）；
setInput（in，null）；
parser.nextTag（）；
返回readSkills（解析器）；
}最后{
in.close（）；
}
}
私有对象readSkills（XmlPullParser）抛出XmlPullParserException，IOException{
require（XmlPullParser.START_标记，ns，“skills”）；
列表技能=新建ArrayList（）；
while（parser.next（）！=XmlPullParser.END_标记）{
if（parser.getEventType（）！=XmlPullParser.START_标记）{
继续；
}
String name=parser.getName（）；
//首先查找条目标记
如果（名称等于（“技能”））{
添加（readSkill（解析器））；
}否则{
跳过（解析器）；
}
}  
回归技能；
}
私有ESkill readSkill（XmlPullParser）抛出XmlPullParserException，IOException{
/*
软件工程
*/
字符串技能_name=“”；
while（parser.next（）！=XmlPullParser.END_标记）{
if（parser.getEventType（）！=XmlPullParser.START_标记）{
继续；
}
String name=parser.getName（）；
如果（“名称”。等于（名称））{
skill_name=readName（解析器）；
}否则{
跳过（解析器）；
}
}
返回新的ESkill（）.setSkill（技能名称）；
}
//处理提要中的标题标记。
私有字符串readName（XmlPullParser解析器）引发IOException，XmlPullParserException{
require（XmlPullParser.START_标记，ns，“name”）；
字符串描述=readText（解析器）；
require（XmlPullParser.END_标记，ns，“name”）；
返回说明；
}
//对于标记标题和摘要，提取其文本值。
私有字符串readText（XmlPullParser解析器）引发IOException，XmlPullParserException{
字符串结果=”；
if（parser.next（）==XmlPullParser.TEXT）{
结果=parser.getText（）；
parser.nextTag（）；
}
返回结果；
}
私有void skip（XmlPullParser解析器）抛出XmlPullParserException，IOException{
if（parser.getEventType（）！=XmlPullParser.START_标记）{
抛出新的非法状态异常（）；
}
int深度=1；
while（深度！=0）{
开关（parser.next（））{
case XmlPullParser.END_标记：
深度--；
打破
case XmlPullParser.START_标记：
深度++；
打破
}
}
}
}

这会创建一个名为

public class SkillsParser implements AssyncXmlReader {

    private String ns = "";
    @Override
    public Object 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 readSkills(parser);
        } finally {
            in.close();
        }
    }

    private Object readSkills(XmlPullParser parser) throws XmlPullParserException, IOException {
        parser.require(XmlPullParser.START_TAG, ns, "skills");
        List<ESkill> skills = new ArrayList<ESkill>();
        
        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("skill")) {
                skills.add(readSkill(parser));
            } else {
                skip(parser);
            }
        }  
        return skills;
    }
    
    private ESkill readSkill(XmlPullParser parser) throws XmlPullParserException, IOException {
        /*
        <skill>
            <name>Software Engineering</name>
        
        </skill>
        */
        String skill_name = "";
        
        while (parser.next() != XmlPullParser.END_TAG) {
            if (parser.getEventType() != XmlPullParser.START_TAG) {
                continue;
            }
            String name = parser.getName();
            if ("name".equals(name)) {
                skill_name = readName(parser);
            } else {
                skip(parser);
            }
        }
        
        return new ESkill().setSkill(skill_name);
    }
    
    // Processes title tags in the feed.
    private String readName(XmlPullParser parser) throws IOException, XmlPullParserException {
        parser.require(XmlPullParser.START_TAG, ns, "name");
        String description = readText(parser);
        parser.require(XmlPullParser.END_TAG, ns, "name");
        return description;
    }
    
    // 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;
    }
    
    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;
            }
        }
     }
}