XML的四种写入方式

最新推荐文章于 2023-05-11 15:00:00 发布
最新推荐文章于 2023-05-11 15:00:00 发布
阅读量524 收藏 2
点赞数 1
文章标签： java 人工智能
原文链接：http://www.cnblogs.com/9513-/p/7466805.html
版权

DOM方式生成XML：

<?xml version="1.0" encoding="UTF-8"?><bookStore>
<book id="1">
<name>冰与火之歌</name>
<author>乔治马丁</author>
<year>2014</year>
<price>89</price>
</book>
<book id="2">
<name>安徒生童话</name>
<year>2004</year>
<price>77</price>
<language>English</language>
</book>
</bookStore>

 

import java.io.File;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

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

public class Demo {
    /**
     * 创建DocumentBuilder
     * @return
     */
    public DocumentBuilder getDocuementBuilder() {
        // 创建一个DocumentBuilderFactory的对象
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        // 创建DocumentBuilder对象
        DocumentBuilder db = null;
        try {
            db = dbf.newDocumentBuilder();
        } catch (ParserConfigurationException e) {
            e.printStackTrace();
        }
        return db;
    }
    /**
     * 生成xml
     */
    public void createXML() {
        DocumentBuilder db = getDocuementBuilder();
        Document doc = db.newDocument(); // 创建DOM树
        doc.setXmlStandalone(true); // 设置xml文件声明中的standalone="yes"并不显示
        Element bookstore = doc.createElement("bookStore"); //创建根节点
        //向bookstore根节点中添加子节点book
        //**************************添加第一个book节点***********************************
        Element book = doc.createElement("book");
        book.setAttribute("id", "1");
        // 设置name节点的值并添加到book节点下
        Element name = doc.createElement("name");
        name.setTextContent("冰与火之歌");
        book.appendChild(name);
        // 设置author节点的值并添加到book节点下
        Element author = doc.createElement("author");
        author.setTextContent("乔治马丁");
        book.appendChild(author);
        // 设置year节点的值并添加到book节点下
        Element year = doc.createElement("year");
        year.setTextContent("2014");
        book.appendChild(year);
        // 设置price节点的值并添加到book节点下
        Element price = doc.createElement("price");
        price.setTextContent("89");
        book.appendChild(price);
        //将book节点添加到bookstore中
        bookstore.appendChild(book); 
        
        //**************************添加第二个book节点***********************************
        
        // 向bookstore根节点中添加第二个book子节点
        Element book2 = doc.createElement("book");
        book2.setAttribute("id", "2");
        Element name2 = doc.createElement("name");
        name2.setTextContent("安徒生童话");
        book2.appendChild(name2);
        Element year2 = doc.createElement("year");
        year2.setTextContent("2004");
        book2.appendChild(year2);
        Element price2 = doc.createElement("price");
        price2.setTextContent("77");
        book2.appendChild(price2);
        Element language = doc.createElement("language");
        language.setTextContent("English");
        book2.appendChild(language);
        bookstore.appendChild(book2);
        
        //将根节点bookstore添加到DOM树中
        doc.appendChild(bookstore); 
        
        //创建TransformerFactory对象
        TransformerFactory tff = TransformerFactory.newInstance();
        try {
            //创建Transformer对象
            Transformer tf = tff.newTransformer();
            tf.setOutputProperty(OutputKeys.INDENT, "yes"); // 设置生成的xml文件格式（换行）
            tf.transform(new DOMSource(doc), new StreamResult(new File("books1.xml")));
        } catch (TransformerConfigurationException e) {
            e.printStackTrace();
        } catch (TransformerException e) {
            e.printStackTrace();
        }
    }
    /**
     * main
     */
    public static void main(String[] args) {
        Demo demo = new Demo();
        // 调用createXML()方法
        demo.createXML();
    }
}

 

SAX方式生成XML：

import java.util.ArrayList;

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



public class SAXParserHandler extends DefaultHandler {
    String value = null;
    Book book = null;
    private ArrayList<Book> bookList = new ArrayList<Book>();
    public ArrayList<Book> getBookList() {
        return bookList;
    }
    int bookIndex = 0;
    /**
     * 用来遍历xml文件的开始标签
     */
    public void startElement(String uri, String localName, String qName,
            Attributes attributes) throws SAXException {
        //调用DefaultHandler类的startElement方法
        super.startElement(uri, localName, qName, attributes);
        //开始解析book元素的属性
        if(qName.equals("book")){
            //创建一个Book对象
            book = new Book();
            bookIndex++;
            //已知book元素下属性名称，根据属性名获取属性值
            System.out.println("***********开始遍历第"+bookIndex+"本书的内容***********");
            /*String value = attributes.getValue("id");
            System.out.println("book的属性值是："+value);*/
            int num = attributes.getLength();
            for(int i=0;i<num;i++){
                System.out.print("book元素的第"+(i+1)+"属性名是："+attributes.getQName(i));
                System.out.println("==>属性值是："+attributes.getValue(i));
                if(attributes.getQName(i).equals("id")){
                    book.setId(attributes.getValue(i));
                }
            }
        }else if(!qName.equals("book") && !qName.equals("bookstore")){
            System.out.print("节点名是："+qName+"==>");
        }    
    }
    /**
     * 用来遍历xml文件的结束标签
     */
    public void endElement(String uri, String localName, String qName)
            throws SAXException {
        //调用DefaultHandler类的endElement方法
        super.endElement(uri, localName, qName);
        //判断是否针对一本书已经遍历结束
        if(qName.equals("book")){
            bookList.add(book);
            book = null;
            System.out.println("***********结束遍历第"+bookIndex+"本书的内容***********");
        }else if(qName.equals("name")){
            book.setName(value);
        }else if(qName.equals("author")){
            book.setAuthor(value);
        }else if(qName.equals("year")){
            book.setYear(value);
        }else if(qName.equals("price")){
            book.setPrice(value);
        }else if(qName.equals("language")){
            book.setLanguage(value);
        }
    }
    /**
     * 用来标识解析开始
     */
    public void startDocument() throws SAXException {
        super.startDocument();
        System.out.println("SAX解析开始");
    }
    /**
     * 用来标识解析结束
     */
    public void endDocument() throws SAXException {
        super.endDocument();
        System.out.println("SAX解析结束");
    }
    /**
     * 
     */
    public void characters(char[] ch, int start, int length)
            throws SAXException {
        super.characters(ch, start, length);
        value = new String(ch, start, length);
        if(!value.trim().equals("")){
            System.out.println("节点值是："+value);
        }
    }
}
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;

import javax.xml.parsers.ParserConfigurationException;
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.TransformerConfigurationException;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.sax.TransformerHandler;
import javax.xml.transform.stream.StreamResult;

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

public class Demo {
    public ArrayList<Book> parserXML() {
        // 获取一个SAXParserFactory对象
        SAXParserFactory factory = SAXParserFactory.newInstance();
        // 通过factory获取SAXParser对象
        SAXParserHandler handler = null;
        try {
            SAXParser parser = factory.newSAXParser();
            // 创建SAXParserHandler对象
            handler = new SAXParserHandler();
            parser.parse("books1.xml", handler);
        } catch (ParserConfigurationException e) {
            e.printStackTrace();
        } catch (SAXException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return handler.getBookList();
    }
    /**
     * 生成XML文件
     */
    public void createXML(){
        ArrayList<Book> bookList = parserXML();
        // 生成xml
        // 1.创建一个SAXTransformerfactory类的对象
        SAXTransformerFactory tff = (SAXTransformerFactory) SAXTransformerFactory.newInstance();
        try {
            // 2.通过SAXTransformerFactory对象创建一个TransformerHandler对象
            TransformerHandler handler = tff.newTransformerHandler();
            // 3.通过handler对象创建一个Transformer对象
            Transformer tf = handler.getTransformer();
            // 4.通过Transformer对象对生成的xml文件进行设置
            // 设置xml的编码格式
            tf.setOutputProperty(OutputKeys.ENCODING, "gb2312");
            // 设置xml“是否换行”
            tf.setOutputProperty(OutputKeys.INDENT, "yes");
            // 5.创建一个Result对象
            File file = new File("sax_books.xml");
            if(!file.exists()){
                file.createNewFile();
            }
            // 6.创建Result对象，并且使其与handler关联
            Result result = new StreamResult(new FileOutputStream(file));
            handler.setResult(result);
            // 7.利用handler进行xml文件内容的编写
            // 打开document
            handler.startDocument();
            AttributesImpl attr = new AttributesImpl();
            handler.startElement("", "", "bookstore", attr);
            for (Book book : bookList) {
                attr.clear();
                attr.addAttribute("", "", "id", "", "1");
                handler.startElement("", "", "book", attr);
                if(book.getName() != null && !book.getName().trim().equals("")){
                    attr.clear();
                    handler.startElement("", "", "name", attr);
                    handler.characters(book.getName().toCharArray(), 0, book.getName().length());
                    handler.endElement("", "", "name");
                }
                if(book.getAuthor() != null && !book.getAuthor().trim().equals("")){
                    attr.clear();
                    handler.startElement("", "", "author", attr);
                    handler.characters(book.getAuthor().toCharArray(), 0, book.getAuthor().length());
                    handler.endElement("", "", "author");
                }
                if(book.getYear() != null && !book.getYear().trim().equals("")){
                    attr.clear();
                    handler.startElement("", "", "year", attr);
                    handler.characters(book.getYear().toCharArray(), 0, book.getYear().length());
                    handler.endElement("", "", "year");
                }
                if(book.getPrice() != null && !book.getPrice().trim().equals("")){
                    attr.clear();
                    handler.startElement("", "", "price", attr);
                    handler.characters(book.getPrice().toCharArray(), 0, book.getPrice().length());
                    handler.endElement("", "", "price");
                }
                if(book.getLanguage() != null && !book.getLanguage().trim().equals("")){
                    attr.clear();
                    handler.startElement("", "", "language", attr);
                    handler.characters(book.getLanguage().toCharArray(), 0, book.getLanguage().length());
                    handler.endElement("", "", "language");
                }
                handler.endElement("", "", "book");
            }
            handler.endElement("", "", "bookstore");
            // 关闭document
            handler.endDocument();
        } catch (TransformerConfigurationException e) {
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (SAXException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    /**
     * main
     */
    public static void main(String[] args) {
        Demo demo = new Demo();
        demo.createXML();
    }    
}

 

JDOM方式生成XML：

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

import org.jdom2.CDATA;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.output.Format;
import org.jdom2.output.XMLOutputter;

public class Demo {
    private void createXML(){
        // 1.生成一个根节点
        Element rss = new Element("rss");
        // 2.为节点添加属性
        rss.setAttribute("version", "2.0");
        // 3.生成一个document对象
        Document doc = new Document(rss);
        Element channel = new Element("channel");
        rss.addContent(channel);
        Element title = new Element("title");
        title.setText("<![CDATA[上海移动互联网产业促进中心正式揭牌 ]]>");
        
        //CDATA text = new CDATA("<![CDATA[上海移动互联网产业促进中心正式揭牌 ]]>");
        //title.addContent(text);
        channel.addContent(title);
        Format format = Format.getPrettyFormat();
        //format.setEncoding("UTF-8");
        //设置换行
        format.setIndent("");
        // 4.创建XMLOutputter对象
        XMLOutputter outputter = new XMLOutputter(format);
        try {
            // 5.利用outputter将doc对象转换成xml文件
            outputter.output(doc, new FileOutputStream(new File("jdom_rssnews.xml")));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    /**
     * main
     */
    public static void main(String[] args) {
        new Demo().createXML();
    }
}

 

DOM4J方式生成XML：

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;

import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;

public class Demo {
    private void createXML() {
        // 1.创建document对象，代表整个xml文档
        Document doc = DocumentHelper.createDocument();
        // 2.创建根节点rss
        Element rss = doc.addElement("rss");
        // 3.向rss节点中添加version属性
        rss.addAttribute("version", "2.0");
        // 4.生成子节点及节点内容
        Element channel = rss.addElement("channel");
        Element title = channel.addElement("title");
        title.setText("<![CDATA[上海移动互联网产业促进中心正式揭牌 ]]>");
        // 5.设置生成xml文件格式
        OutputFormat format = OutputFormat.createPrettyPrint();
        //format.setEncoding("UTF-8");
        // 6.生成xml文件
        File file = new File("dom4j_rssnews.xml");
        XMLWriter writer = null;
        try {
            writer = new XMLWriter(new FileOutputStream(file), format);
            // 设置是否转义，默认值时true，代表转义
            writer.setEscapeText(false);
            writer.write(doc);
            writer.close();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    /**
     * main
     */
    public static void main(String[] args) {
        new Demo().createXML();
    }
}

 

转载于:https://www.cnblogs.com/9513-/p/7466805.html

weixin_30691871
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Unity实现读取XML和数据写入到XML
07-09
在Unity中，数据管理是非常关键的一部分，而XML（可扩展标记语言）则是一种常用的结构化数据存储格式，尤其适合于保存和传输游戏中的配置信息、角色属性等非结构化数据。本项目实现了在Unity中对XML文件的读取和写入...
XML的编写
qq56hm的博客
08-03 4997
文章目录XML什么是XML如何编写格式良好的XML XML 什么是XML XML是一个可扩展标记语言。XML和操作系统编程语言的开发平台无关，可以实现不同系统之间的数据交换。 XML的规范 XML文档内容是由一系列标签元素组成的。 <元素名 属性名=“属性值”>元素内容</元素名> 属性值用引号包裹 一个元素可以有多个属性 属性值不可以直接包含< & 不建议使用的字符" ’ > 使用IDEA新建一个XML文件，先尝试编写一个XML文件: <?xml
XML基础知识，写入数据到XML文件
qq_22981003的博客
03-24 857
XML基础知识，写入数据到XML文件一、写入数据到XML文件中二、写入数据总结 原文链接：https://blog.csdn.net/spring_model/article/details/54378312 一、写入数据到XML文件中 往XML文件中写入数据，特别要注意编码问题，这里写入数据采用了两种不同的编码。一般情况下如果xml文件时gb2312,就采用第一种方式，如果为UTF-8，就使用第...
创建XML的三种方式（二）
最新发布
weixin_40314351的博客
05-11 4164
本文介绍了在winform中使用C#开发语言来创建XML文档的三种方式，并介绍了各自的优缺点。 方法1是使用`XmlDocument`创建XML文档，方法2是使用`XmlTextWriter`编写XML文档，方法3是使用`LINQ to XML`的Document类生成XML文档。
【XML学习笔记】
_闪闪发光的博客
04-04 243
一、什么是XML？ 二、XML数据格式的主要用途有哪些？ 程序之间的数据传输通讯 可作为配置文件 config.xml config →PHP语言、java语言、Python语言 存储数据，充当小型数据库 哎嘿，说了这么多，用一句话来概括呢，就是规范数据格式，使数据具有结构性，易读易处理 ......
C# 写入XML文档三种方法详细介绍
weixin_34191734的博客
08-26 199
  三个类将同样的xml内容写入文档，介绍了如何使用XmlDocument类对XML进行操作，以及如何使用LINQ to XML对XML进行操作。 它们分别使用了XmlDocument类和XDocument类。 在本文中，我再介绍一个类，XmlTextWriter。我们分别用这三个类将同样的xml内容写入文档，看一看哪种写法最直观、简便。  我们要写...
python写入xml文件的方法
09-22
主要介绍了python写入xml文件的方法,涉及Python操作XML模块实现针对XML文件操作的相关技巧,需要的朋友可以参考下
Android XML 解析 写入
03-22
XML写入通常使用`TransformerFactory`和`Transformer`类完成。以下是一个简单的例子： ```java TransformerFactory transformerFactory = TransformerFactory.newInstance(); Transformer transformer = ...
C#简单写入xml文件的方法
09-03
XML（Extensible Markup Language）是一种用于存储和传输结构化数据的标准格式，广泛应用于配置文件、数据交换和存储等领域。本篇将详细介绍如何使用C#简单地向XML文件写入数据。 首先，要理解XML文件的基本结构。...
xml文件的写入写出
08-16
将数据写出到XML文件中去，或者是读取XML文件中的数据并进行操作
XML读取和写入C#
星河队长
12-02 648
1.写入xml（用户填写留言） 复制代码 ```csharp public void WriteXml() { //创建一个数据集，将其写入xml文件 string optime = DateTime.Now.ToString("yyyyMMddHHmmss") + ".xml"; System.Data.DataSet ds = new System.Data.DataSet("MESSAGE"); System.Data.D
通过@Import注解把类注入容器的四种方式
qq_1149513559的博客
08-12 2078
文章目录准备工作方案一：导入普通类ConfigA方案二：导入`@Configuration`配置类ConfigB方案三：导入`ImportSelector`的实现类方式四：导入`ImportBeanDefinitionRegistrar`的实现类测试结果           @Import是spring中的一个注解，在其他框架与spring整合时应用广泛，比如redis的自动配置RedisAutoConfig
写入xml（XMLWriter ）
shp808的博客
11-04 121
当我们写入xml时（就是把我们的数据写入到xml对应的标签里）： 1.建立一个text.xml 2. package xml; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File;...
读取xml文件的四种方式
热门推荐
withawind的博客
05-17 1万+
#一、为什么使用XML 1、便于不同应用程序之间通信。 2、便于不同平台之间通信。 3、便于不同平台之间数据共享。 #二、Dom读取 xml文件内容 <?xml version="1.0" encoding="UTF-8"?> <bookstore> <book id="1"> <name>冰与火之歌</na...
c#下xml读取和写入
xcLeigh
05-13 2081
c#下xml读取和写入关于xml自定义xml文件读取XML代码写入XML代码 关于xml 。XML 指可扩展标记语言（EXtensible Markup Language） 。XML 是一种标记语言，很类似HTML 。XML 的设计宗旨是传输数据，而非显示数据 。XML 标签没有被预定义，您需要自行定义标签 。XML 被设计为具有自我描述性 。XML 是W3C 的推荐标准 //格式申明 <!--?xml version="1.0" --> 用encoding属性声明文档的编码 &lt
java编码笔记-生成xml
xie__jin__cheng的博客
11-04 244
1.概述 生成xml文档 1.创建节点： Element 节点对象=document.createElement("节点名"); 2.添加子节点：节点.appendChild(子节点); 3.给节点添加内容：节点.setTextContent("添加的内容"); 4.给节点添加属性：节点.setAttribute(属性名称, 属性值); 2.代码 package test.java.xmltest; import java.io.File; import javax.xml.pars..
XML文件写入
GSCurry的博客
10-24 810
xml文件写入
xml的写入
fanfan_hongyun的博客
05-23 233
写入配置文件 using UnityEngine; using System.Collections; using System.Xml; using System.Collections.Generic; using System.Reflection; using System.IO; using UnityEngine.UI; using System; //处理加载缓存 获取配置的管理器 ...
tinyxml实现xml读取和写入
05-11
TinyXML是一个轻量级的C++库，用于读取和写入XML文件。以下是一个简单的示例，演示如何使用TinyXML来读取和写入XML文件： 读取XML文件： ```c++ #include "tinyxml.h" int main() { TiXmlDocument doc("example....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值