Xml解析

最新推荐文章于 2021-02-16 18:17:05 发布
最新推荐文章于 2021-02-16 18:17:05 发布
阅读量328 收藏
点赞数
分类专栏： android进阶 文章标签： android xml
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fancheng614/article/details/77131034
版权

XML解析在Android中应用的比较多，很多时候存储数据需要使用到XML。

这里介绍四种XML解析方式，很多地方说是三种xml解析方式（除去第一种原生xml解析），但是这里的XmlResourceParser跟其他三种不知道是否重复：

1、原生XML解析：XmlResourceParser

2、SAX解析器，

3、DOM解析器，

4、PULL解析器

公共接口：

public interface BookParser {

    //解析输入流，得到book对象集合
    public List<Book> parse(InputStream is) throws Exception;

    //序列化Book对象集合，得到xml形式字符串
    public String serialize(List<Book> books) throws Exception;
}

公共实体类： 

package com.mfc.xmlutils;

/**
 * Created by Administrator on 2017/8/11.
 */

public class Book {
    private int id;
    private String name;
    private float price;

    public Book() {
    }

    public Book(int id, String name, float price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public float getPrice() {
        return price;
    }

    public void setPrice(float price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}


一、原生XML解析：XmlResourceParser

books.xml:(这个xml存放在res的xml文件夹里)：

<?xml version="1.0" encoding="utf-8"?>
<books>
    <book price="1.0" id="1001">Java</book>
    <book price="89.0" id="1002">Java EE</book>
    <book price="69.0" id="1003">Ajax</book>
</books>


工具类：

package com.mfc.xmlutils;

import android.content.Context;
import android.content.res.XmlResourceParser;

import com.example.administrator.parsexml.R;

import java.util.ArrayList;
import java.util.List;

public class XmlResourceParserUtil {
    private Context context;
    public XmlResourceParserUtil(Context context){
        this.context = context;
    }
    public List<Book> getXmlResource(){
        XmlResourceParser xlp = context.getResources().getXml(R.xml.books);
        try {
            List<Book> books = new ArrayList<Book>();
            Book book = null;
            //循环，如果还没有到xml文档的结尾处
            while (xlp.getEventType() != XmlResourceParser.END_DOCUMENT){
                //如果遇到了开始标签
                if (xlp.getEventType() == XmlResourceParser.START_TAG){
                    //获取标签名
                    String tagName = xlp.getName();
                    //如果遇到Book标签
                    if (tagName.equals("book")){
                        book = new Book();
                        //根据属性名来获取属性值
                        String bookPrice = xlp.getAttributeValue(0);
                        book.setPrice(Float.parseFloat(bookPrice));
                        String id = xlp.getAttributeValue(1);
                        book.setId(Integer.parseInt(id));
                        //获取文本节点的值
                        book.setName(xlp.nextText());
                        books.add(book);
                    }

                }
                xlp.next();
            }
            return books;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

activity： 

parserButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                XmlResourceParserUtil xmlResourceParserUtil = new XmlResourceParserUtil(SAXParserXmlActivity.this);
                List<Book> books = xmlResourceParserUtil.getXmlResource();
                StringBuilder stringBuilder = new StringBuilder();
                for (Book book : books) {
                    stringBuilder.append(book.toString());
                }
                XMLContent.setText(stringBuilder.toString());
             }
        });

二、SAX解析器：

books.xml（这个xml存放在assets文件夹下）：以下几种解析xml的方法都使用的这一个xml

<?xml version="1.0" encoding="utf-8"?>
<books>
    <book>
        <id>1001</id>
        <name>java编程思想</name>
        <price>80.00</price>
    </book>
    <book>
        <id>1002</id>
        <name>Android群英传</name>
        <price>90.00</price>
    </book>
    <book>
        <id>1003</id>
        <name>spring源码解析</name>
        <price>100.00</price>
    </book>
</books>


工具类：

package com.mfc.xmlutils;

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

import java.io.InputStream;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.List;

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Result;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.sax.TransformerHandler;
import javax.xml.transform.stream.StreamResult;

/**
 * Created by Administrator on 2017/8/11.
 */

public class BookSaxParser implements BookParser {
    @Override
    public List<Book> parse(InputStream is) throws Exception {
        //取得SAXParserFactory实例
        SAXParserFactory factory = SAXParserFactory.newInstance();
        //从factory获取SAXParser实例
        SAXParser parser = factory.newSAXParser();
        //实例化自定义的Handler
        MyHandler myHandler = new MyHandler();
        parser.parse(is,myHandler);
        return myHandler.getBooks();
    }

    @Override
    public String serialize(List<Book> books) throws Exception {
        //取得SAXTransformerFactory实例
        SAXTransformerFactory factory = (SAXTransformerFactory) TransformerFactory.newInstance();
        //从factory获取TransformerHandler实例
        TransformerHandler handler = factory.newTransformerHandler();
        //从handler获取Transformer实例
        Transformer transformer = handler.getTransformer();
        //设置输出采用的编码方式
        transformer.setOutputProperty(OutputKeys.ENCODING,"UTF-8");
        //是否自动添加额外的空白
        transformer.setOutputProperty(OutputKeys.INDENT,"yes");
        //是否忽略xml声明
        transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION,"no");

        StringWriter writer = new StringWriter();
        Result result = new StreamResult(writer);
        handler.setResult(result);

        //代表命名空间的URI，当URI无值时，需设置为空字符串
        String uri = "";
        //命名空间的本地名称(不包含前缀)，当没有进行命名空间处理时，需要设置为空字符串
        String localName = "";

        handler.startDocument();;
        handler.startElement(uri,localName,"books",null);

        //负责存放元素的属性信息
        AttributesImpl attrs = new AttributesImpl();
        char[] ch = null;
        for (Book book : books){
            //清空属性列表
            attrs.clear();
            //添加一个名为id的属性（type影响不大，这里设置为String）
            attrs.addAttribute(uri,localName,"id","string",String.valueOf(book.getId()));
            //开始一个book元素，关联上面设定的id属性
            handler.startElement(uri,localName,"book",attrs);
            //开始一个那么属性，没有元素
            handler.startElement(uri,localName,"name",null);
            ch = String.valueOf(book.getName()).toCharArray();
            //设置price元素的文本节点
            handler.characters(ch,0,ch.length);
            handler.endElement(uri,localName,"price");
            handler.endElement(uri,localName,"book");
        }
        handler.endElement(uri,localName,"books");
        handler.endDocument();
        return writer.toString();
    }

    //需要重写DefaultHandler的方法
    private class MyHandler extends DefaultHandler{
        private List<Book> books;
        private Book book;
        private StringBuilder builder;

        //返回解析后得到的Book对象集合

        public List<Book> getBooks() {
            return books;
        }

        //初始化
        @Override
        public void startDocument() throws SAXException {
            super.startDocument();
            books = new ArrayList<Book>();
            builder = new StringBuilder();
        }

        @Override
        public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
            super.startElement(uri, localName, qName, attributes);
            //开始如果遇到了book标签，就新建一个Book对象
            if (localName.equals("book")) {
                book = new Book();
            }
            //将字符长度设置为0，一边重新开始读取元素的字符节点
            builder.setLength(0);
        }

        @Override
        public void characters(char[] ch, int start, int length) throws SAXException {
            super.characters(ch, start, length);
            //将读取的字符数组追加到builder中
            builder.append(ch,start,length);
        }

        @Override
        public void endElement(String uri, String localName, String qName) throws SAXException {
            super.endElement(uri, localName, qName);
            //遇到book标签后，接下来将遇到的标签对应的值放进实体类对应的属性里面
            if (localName.equals("id")){
                book.setId(Integer.parseInt(builder.toString()));
            }else if (localName.equals("name")) {
                book.setName(builder.toString());
            }else if (localName.equals("price")) {
                book.setPrice(Float.parseFloat(builder.toString()));
            }else if (localName.equals("book")) {
                books.add(book);
            }
        }
    }
}

activity： 

 parserXmlBySAXButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                try {
                    InputStream is = getAssets().open("books.xml");
                    //创建SaxBookParser实例
                    parserSAX = new BookSaxParser();
                    //解析输入流
                    books = parserSAX.parse(is);
                    StringBuilder stringBuilder = new StringBuilder();
                    for (Book book : books) {
                        stringBuilder.append(book.toString());
                    }
                    XMLContent.setText(stringBuilder.toString());
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        writerXmlBySAXButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                try {
                    String xml = parserSAX.serialize(books);
                    FileOutputStream fos = openFileOutput("books.xml", Context.MODE_PRIVATE);
                    fos.write(xml.getBytes("UTF-8"));
                    Toast.makeText(SAXParserXmlActivity.this, "写入成功",Toast.LENGTH_LONG).show();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

三、DOM解析器：

工具类：

package com.mfc.xmlutils;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import java.io.InputStream;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.List;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

/**
 * Created by Administrator on 2017/8/12.
 */

public class BookDomParser implements BookParser {
    @Override
    public List<Book> parse(InputStream is) throws Exception {

        List<Book> books = new ArrayList<Book>();
        //获取DocumentBuilderFactory实例
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        //从factory获取DocumentBuilder实例
        DocumentBuilder builder = factory.newDocumentBuilder();
        //解析输入流，得到Document实例
        Document doc = builder.parse(is);
        Element rootElement = doc.getDocumentElement();
        NodeList items = rootElement.getElementsByTagName("book");
        for (int i=0;i<items.getLength();i++) {
            Book book = new Book();
            Node item = items.item(i);
            NodeList properties = item.getChildNodes();
            for (int j = 0;j<properties.getLength();j++) {
                Node property = properties.item(j);
                String nodeName = property.getNodeName();
                if(nodeName.equals("id")){
                    book.setId(Integer.parseInt(property.getFirstChild().getNodeValue()));
                } else if (nodeName.equals("name")) {
                    book.setName(property.getFirstChild().getNodeValue());
                } else if (nodeName.equals("price")) {
                    book.setPrice(Float.parseFloat(property.getFirstChild().getNodeValue()));
                }

            }
            books.add(book);
        }
        return books;
    }

    @Override
    public String serialize(List<Book> books) throws Exception {
        //获取DocumentBuilderFactory对象
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = factory.newDocumentBuilder();
        //由builder创建新文档
        Document doc = builder.newDocument();
        Element rootElement = doc.createElement("books");
        for (Book book : books) {
            Element bookElement = doc.createElement("book");
            bookElement.setAttribute("id",book.getId()+"");
            Element nameElement = doc.createElement("name");
            nameElement.setTextContent(book.getName());
            bookElement.appendChild(nameElement);

            Element priceElement = doc.createElement("price");
            priceElement.setTextContent(book.getPrice()+"");
            bookElement.appendChild(priceElement);

            rootElement.appendChild(bookElement);
        }
        doc.appendChild(rootElement);

        //取得TransformerFactory实例
        TransformerFactory transFactory = TransformerFactory.newInstance();
        //从transFactory获取Transformer实例
        Transformer transformer = transFactory.newTransformer();
        //设置输出采用的编码方式
        transformer.setOutputProperty(OutputKeys.ENCODING,"UTF-8");
        //设置自动添加额外的空白
        transformer.setOutputProperty(OutputKeys.INDENT,"yes");
        //设置忽略xml声明
        transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION,"no");

        StringWriter writer = new StringWriter();

        //表明文档来源是doc
        Source source = new DOMSource(doc);
        //表明目标结果为writer
        Result result = new StreamResult(writer);
        //开始转换
        transformer.transform(source,result);
        return writer.toString();
    }
}

activity： 

parserXmlByDOMButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                try {
                    InputStream is = getAssets().open("books.xml");
                    //创建SaxBookParser实例
                    parserDOM = new BookDomParser();
                    //解析输入流
                    books = parserDOM.parse(is);
                    StringBuilder stringBuilder = new StringBuilder();
                    for (Book book : books) {
                        stringBuilder.append(book.toString());
                    }
                    XMLContent.setText(stringBuilder.toString());
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        writerXmlByDOMButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                try {
                    String xml = parserDOM.serialize(books);
                    FileOutputStream fos = openFileOutput("books.xml", Context.MODE_PRIVATE);
                    fos.write(xml.getBytes("UTF-8"));
                    Toast.makeText(SAXParserXmlActivity.this, "写入成功",Toast.LENGTH_LONG).show();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

四、PULL解析器

工具类： 

package com.mfc.xmlutils;

import android.util.Xml;

import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlSerializer;

import java.io.InputStream;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.List;

/**
 * Created by Administrator on 2017/8/12.
 */

public class BookPullParser implements BookParser {
    @Override
    public List<Book> parse(InputStream is) throws Exception {
        List<Book> books = null;
        Book book = null;
        //从android.util.Xml创建一个XmlPullParser实例
        XmlPullParser parser = Xml.newPullParser();
        //设置输入流，并指明编码方式
        parser.setInput(is,"UTF-8");

        int eventType = parser.getEventType();
        while(eventType != XmlPullParser.END_DOCUMENT){
            switch (eventType){
                case XmlPullParser.START_DOCUMENT:
                    books = new ArrayList<Book>();
                    break;
                case XmlPullParser.START_TAG:
                    if (parser.getName().equals("book")) {
                        book = new Book();
                    }else if (parser.getName().equals("id")){
                        eventType = parser.next();
                        book.setId(Integer.parseInt(parser.getText()));
                    }else if (parser.getName().equals("name")){
                        eventType = parser.next();
                        book.setName(parser.getText());
                    }else if (parser.getName().equals("price")){
                        eventType = parser.next();
                        book.setPrice(Float.parseFloat(parser.getText()));
                    }
                    break;
                case XmlPullParser.END_TAG:
                    if (parser.getName().equals("book")){
                        books.add(book);
                        book = null;
                    }
                    break;
            }
            eventType = parser.next();
        }
        return books;
    }

    @Override
    public String serialize(List<Book> books) throws Exception {
        //由android.util.Xml创建一个XmlSerializer实例
        XmlSerializer serializer = Xml.newSerializer();
        StringWriter writer = new StringWriter();
        //设置输出方式为writer
        serializer.setOutput(writer);
        serializer.startDocument("UTF-8",true);
        serializer.startTag("","books");
        for (Book book : books) {
            serializer.startTag("","book");
            serializer.attribute("","id",book.getId()+"");

            serializer.startTag("","name");
            serializer.text(book.getName());
            serializer.endTag("","name");

            serializer.startTag("", "price");
            serializer.text(book.getPrice() + "");
            serializer.endTag("", "price");

            serializer.endTag("", "book");
        }

        serializer.endTag("", "books");
        serializer.endDocument();

        return writer.toString();
    }
}

activity： 

parserXmlByPULLButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                try {
                    InputStream is = getAssets().open("books.xml");
                    //创建SaxBookParser实例
                    parserPULL = new BookDomParser();
                    //解析输入流
                    books = parserPULL.parse(is);
                    StringBuilder stringBuilder = new StringBuilder();
                    for (Book book : books) {
                        stringBuilder.append(book.toString());
                    }
                    XMLContent.setText(stringBuilder.toString());
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        writerXmlByPULLButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                try {
                    String xml = parserPULL.serialize(books);
                    FileOutputStream fos = openFileOutput("books.xml", Context.MODE_PRIVATE);
                    fos.write(xml.getBytes("UTF-8"));
                    Toast.makeText(SAXParserXmlActivity.this, "写入成功",Toast.LENGTH_LONG).show();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

效果图（这里由于使用的真机，所以看不到写入的文件）：


对于这几种解析器各有优点，更倾向于PULL解析器，因为SAX解析器操作起来太笨重，DOM不适合文档较大，内存较小的场景，唯有PULL轻巧灵活，速度快，占用内存小，使用非常顺手。


源码下载：http://download.csdn.net/download/fancheng614/9931088

下半夜的雨
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
XML解析工具
04-16
读取和设置xml配置文件是最常用的操作，试用了几个C++的XML解析器，个人感觉TinyXML是使用起来最舒服的，因为它的API接口和Java的十分类似，面向对象性很好。 TinyXML是一个开源的解析XML的解析库，能够用于C++，...
XML文档中的空白字符解决办法（DOM解析）
m0_64416846的博客
11-26 1056
1,xml文档中的空白字符也会被作为对象映射在DOM中，因而，直接调用Node对象的getChildNodes方法有时候会有些问题，有时不能够反射所期望的NodeList元素对象列表 解决办法： （1）使用Element的getElementByTagName(String name)返回的NodeList就是所期待的对象。然后用item（）方法提取想要的元素 （2）调用Node的getChildNodes()方法得到Node List对象，每次通过item（）方法提取Node对象后判断node.ge
Android的xml文件编写空格的方法大全！
weixin_51766963的博客
12-21 1453
xml中写空格 原文：源文章 在Android中，用户往往会把所有的字符串保存在string.xml中，目的是方便统一管理，并且利于国际化，但是在这些字符串中直接输入一些符号是不起任何效果的，比如空格，换行，大于号小于号等，这就需要使用转义字符来进行转移，这样才能在使用时正确显示字符。 常用的XML转义字符记录如下： 空格： 出 库 其中的 就代表空格 换行： 你好！n世界！ 其中的n就代表换行 缩进： 你好！t世界！ 其中的t就代表按一次Tab键的几个空格 应当注意，由于系统定义的基本的缩进的格数不同，
Mybatis当xml里面传入的参数为0，自动转化为空字符
爱折腾的Albert
10-29 1746
mapper List&lt;listByConditionDTO&gt; listByCondition(@Param("workType") Integer workType); 对应xml &lt;select id="listByCondition" resultType="com.komlin.modular.smart.pojo.dto.listByConditionDTO"&gt...
Mybatis中xml判断字符串不为空和null简单方法
huahuahua0809的博客
08-03 4万+
Mybatis中xml判断字符串不为空和null简单方法今天犯了一个很丢人的事情，值得自己在这做一记录。 我们以前在xml中进行null和空的判断如下图所示： 这样有一个坏处就是我今天所犯的，一开始我只做了null的判断，可发现空串忘记判断了，程序出了大bug，需要我修改，但是这样的判断有很多个，我修改起来还费了一段时间。这样显得很不专业，还被领导训。 我做了如下修改： util工具类 该中判断只
易语言 xml解析 易语言 xml解析 教程 带源码
11-22
易语言 xml解析 易语言 xml解析 易语言 xml解析 易语言 xml解析 易语言 xml解析 易语言 xml解析 易语言 xml解析 教程 带源码
多层镶嵌xml解析.zip
11-19
使用dom4j解析XML，用于解析复杂XML，多层镶嵌XML，多层循环xml解析，解析完保存到实体类
xml解析
01-20
XML： 概念：Extensible Markup Language 可扩展标记语言 可扩展：标签都是自定义的。 功能 ...告知解析引擎当前文档使用的字符集，默认值：ISO-8859-1 standalone：是否独立 取值： yes：不依赖其
XAML中的空格、换行、Tab
weixin_33688840的博客
11-14 1988
由于XAML是一种XML，在里面写段文字都经常会遇到问题。 * 空格 关于XAML中是如何处理空格的，MSDN上给出了详细的描述：http://msdn.microsoft.com/en-us/library/cc189036%28v=VS.95%29.aspx#whitespace 摘重要的简单说一下： 空格、回车、制表符都被当做空格。 连续的空格会被合并为一个空格。 <tag>后...
java xml 空节点成对_如何创建一个带有空字符串值的XML文本节点(在Java中)
weixin_34096605的博客
02-16 841
我正在使用一个Transform对象来保存我的XML文件,但是似乎丢弃了空文本节点.有没有办法创建(并保留)一个空字符串的文本节点,即“”.这是我如何创建节点：Element type = doc.createElement("TYPE");type.appendChild(doc.createTextNode(value));只是有时,值为空字符串“”.当我用文本编辑器查看XML时,我看到代替在...
Mybatis之在mapper.xml中提前判断好字段是Not Null或非空字符串
tree_ifconfig的博客
07-30 1万+
①二者在一起写，&lt;if test="channelId != null and channelId != '' "&gt;字段名=#{xxx，jdbcType=VARCHAR}&lt;/if&gt;，这种是最常用的。 ②这个取决于数据库中，该字段的约束。否则会报错。 1、 如果为NOT NULL，那么mapper.xml中必须要验证&lt;if test=" 字段名！=null  "&g...
android中string.xml中%1$s、%1$d等的用法,空字符串在string.xml中转义字符
疾风剑豪
09-12 908
今天在研究前辈写的代码的时候，突然发现string里面出现了&lt;stringname="item_recent_photo"&gt;最近拍摄%1$s&lt;/string&gt; 有点蒙圈，这个不是c语音里面的表示方式，就百度了一下，记。。。   在TextView中想要动态的显示某些值，用到%1$s，%1$d，先介绍一下： %n$ms：代表输出的是字符串，n代表是第几个参数，设置m的值...
XML 特殊字符处理
热门推荐
东亮博客
12-01 5万+
在ＸＭＬ中,有一些符号作为XML 的标记符号，一些特定情况下，属性值必须带有这些特殊符号。　下面主要是讲解一些常用的特殊符号的处理 例一：　双引号的使用。 双引号作为XML 属性值的开始结束符号，因此无法在值中直接使用"".　处理方式可以分为两种。 a: 属性值中没有'(单引号) ，那么可以用单引号'' 作为属性值的开始结束符号 add key="IPhone" value="ap
XML中的属性：attribute
Heihei 's note
03-09 1万+
在.XSD文件中添加属性约束必须是在&lt;complex&gt;&lt;/complex&gt; 中间添加属性约束代码：&lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified
如何在XML序列化时隐藏可为null的的字段(XmlElement和XmlAttribute)
weixin_30786617的博客
01-26 1586
使用XmlSerializer可以方便的将对象序列化为xml，实现应用之间的数据交互。但是XmlSerializer却不能很好地序列化类型中的可为null的字段。 例如，有如下定义的类Person： C#代码 [Serializable] [XmlRoot(ElementName="Person")] publicclassPerson { ...
java xml解析
最新发布
09-29
引用内容中提到，使用dom4j库可以进行Java XML解析。在引用中，代码展示了如何使用dom4j库来解析XML文件。首先，创建一个InputStream对象来读取XML文件。然后，使用SAXReader对象来创建一个Document对象，该对象表示...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值