java生成xml字符串和创建xml本地文件

Java 专栏收录该内容
2 篇文章 0 订阅

这是我第一次写博客,所以可能写得不太好,请大家见谅!!
之前在网上看到了很多java生成xml字符串和创建xml本地文件的文章,但是感觉不太完整和解释不太详细(可能是我没有找到。。。)!
所以我自己总结了一下知识,希望对大家有用,也方便自己查阅!!
这篇博客的思路:
1. 关键代码步骤
2. 代码设计思路
3. 运行的结果图片
4. 完整代码
5. 代码的使用 | 测试


关键代码块
Dom步骤
1. 创建DocumentBuilderFactory工厂对象: DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance():
2. 通过工厂对象,创建DocumentBuilder制作对象:DocumentBuilder builder = factory.newDocumentBuilder();
3. 通过制作对象,创建一个Document对象:Document document = builder.newDocument();
4. 创建节点:Element root = document.createElement(“节点名称”);
5. 添加节点:Element.appendChild(节点);
6. 节点添加属性:Element.setAttribute(“属性名”,”属性值“);
7. 节点间的内容:Element.setTextContent(“标签间内容”);
转换xml步骤
1. 创建TransformerFactory工厂对象:TransformerFactory transFactory = TransformerFactory.newInstance();
2. 通过工厂对象, 创建Transformer对象:Transformer transformer = transFactory.newTransformer();
3. 创建DOMSource对象:DOMSource domSource = new DOMSource(document);
4. 创建字节流:ByteArrayOutputStream bos = new ByteArrayOutputStream();
5. Transformer的transform()方法将DOM树转换成XML:Transformer对象.transform(DOMSource对象, new StreamResult(bos));

以上为关键代码,如果大家已经有了自己的思路和想法的话,可以不用再往下看了!!


下面为我自己的代码设计思路(可能不一定很好,所以大家也可用自己的设计)
代码设计思路:
1. 创建类XmlFormat:为xml的格式类,一个XmlFormat代表一个层级
(包含:根节点,层级节点,属性节点,设置节点的内容方法)
2. 创建类XmlHandler:用于生成xml字符串 和 生成xml文件
(包含:XmlFormat的集合,创建dom树的方法,生成xml字符串的方法,生成xml文件的方法,重载两个接口方法)


运行的结果图片:
这是第一种格式的xml图(生成的xml并没有换行,我是手动换的,方便图片制作)
第一种格式的xml图(生成的xml并没有换行,我是手动换的,方便图片制作)
这是第二种格式的xml图(生成的xml并没有换行,我是手动换的,方便图片制作)
第二种格式的xml图(生成的xml并没有换行,我是手动换的,方便图片制作)
这是本地生成的xml
这是本地生成的xml这里写图片描述


完整代码
XmlFormat类:xml的格式类

import java.util.HashMap;

public class XmlFormat {

    //根节点名称
    private String rootName;
    //层级节点 名称/值 (值可为空。当值为空时,代表节点下带有属性节点。 当值不等于空时,代表该节点直接包含内容,没有属性节点)
    private HashMap<String, Object> multiplyNames;
    //属性节点 名称/值
    private HashMap<String, Object> propertyNames;

    /**构造函数
     * 参数: 根节点名称
     * */
    public XmlFormat(String rootName){
        this.rootName = rootName;
        this.multiplyNames = new HashMap<String, Object>();
        this.propertyNames = new HashMap<String, Object>();
    }

    /**(重载)用于xml层级节点键/值(没有属性节点)
     * 参数: 层级节点名称, 层级节点的值
     * */
    public void setElement(String multiplyName, String multiplyValue) {
        this.multiplyNames.put(multiplyName, multiplyValue);
    }

    /**(重载)用于xml层级节点,属性节点
     * 参数: 层级节点名称, 属性节点键/值
     * */
    public void setElement(String multiplyName, HashMap<String, Object> propertyNames) {
        this.multiplyNames.put(multiplyName, null);
        this.propertyNames = propertyNames;
    }

    /**
     * getter / setter
     * */
    ......
}

XmlHandler类:用于生成xml字符串 和 生成xml文件

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Map.Entry;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
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 XmlHandler {

    //整个xml的节点数据(把设置的每个层级XmlFormat都添加到这个集合中)
    public List<XmlFormat> documentElements = new ArrayList<XmlFormat>();

    /** 生成Dom树
     *  返回Document(整个Dom Tree)
     * */
    private Document createDom(){
        DocumentBuilderFactory factory = null;
        DocumentBuilder builder = null;
        Document document = null;
        try {
            factory = DocumentBuilderFactory.newInstance();  //创建DocumentBuilderFactory工厂对象
            builder = factory.newDocumentBuilder();          //通过工厂对象, 创建DocumentBuilder制作对象
            document = builder.newDocument();                //通过制作对象, 创建一个Document对象,该对象代表一个XML文件
            document.setXmlStandalone(true);                 //设置XMLstandalone, true为没有dtd和schema作为该XML的说明文档

            //创建根节点
            Element root = document.createElement(documentElements.get(0).getRootName());
            document.appendChild(root);     

            //循环创建整个DOM树
            for(int i = 0; i < documentElements.size(); i++){   
                XmlFormat format = documentElements.get(i);   //获取xml的一个完整层级
                //循环创建层级节点
                for(Entry<String, Object> entryMultiply : format.getMultiplyNames().entrySet()){
                    if(entryMultiply.getValue() != null && !entryMultiply.getValue().toString().equalsIgnoreCase("")){ // 层级节点键/值(没有属性节点)
                        Element multiplyNode = document.createElement(entryMultiply.getKey());      // 创建一个层级节点
                        multiplyNode.setTextContent(entryMultiply.getValue().toString());           // 设置该层级节点的值
                        root.appendChild(multiplyNode);
                    } else {                                                                        // 层级节点键(带有属性节点)
                        Element multiplyNode = document.createElement(entryMultiply.getKey());      // 创建一个层级节点
                        root.appendChild(multiplyNode);
                        //循环创建属性节点
                        for(Entry<String, Object> entryProperty : format.getPropertyNames().entrySet()){
                            Element propertyNode = document.createElement(entryProperty.getKey());  // 创建一个属性节点
                            propertyNode.setTextContent(entryProperty.getValue().toString());       // 设置该属性节点的值
                            multiplyNode.appendChild(propertyNode);
                        }
                        root.appendChild(multiplyNode);         //设置层级节点到根节点
                    }
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        } 
        return document;
    }


    /** 生成xml字符串
     *  参数: Document树对象
     *  返回String: 整个xml字符串
     * */
    private String createXmlToString(Document document){
        String xmlString = null;
        try {
            // 创建TransformerFactory工厂对象
            TransformerFactory transFactory = TransformerFactory.newInstance();     
            // 通过工厂对象, 创建Transformer对象
            Transformer transformer = transFactory.newTransformer();                
            transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8"); 
            //使Xml自动换行, 并自动缩进
            transformer.setOutputProperty(OutputKeys.DOCTYPE_PUBLIC, "");           
            transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");  //中间的参数网址固定写法(这里还没搞懂)
            transformer.setOutputProperty(OutputKeys.INDENT, "yes");                          //是否设置缩进(indent: yes|no)
            // 创建DOMSource对象并将Document加载到其中
            DOMSource domSource = new DOMSource(document); 
            ByteArrayOutputStream bos = new ByteArrayOutputStream(); 
            // 使用Transformer的transform()方法将DOM树转换成XML
            transformer.transform(domSource, new StreamResult(bos));
            xmlString = bos.toString();  
        } catch (TransformerException e) {
            e.printStackTrace();
        }
        return xmlString;
    }


    /** 生成xml文件
     *  参数: url存放文件路径, Document树对象
     *  返回String: 反馈信息
     * */
    private String createXmlToFile(String url, Document document){
        String message = null;
        try{
            // 创建TransformerFactory对象
            TransformerFactory transFactory = TransformerFactory.newInstance();
            // 创建Transformer对象
            Transformer transformer = transFactory.newTransformer();
            //使Xml自动换行, 并自动缩进
            transformer.setOutputProperty(OutputKeys.DOCTYPE_PUBLIC, "");
            transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");  //中间的参数网址固定写法(这里还没搞懂)
            transformer.setOutputProperty(OutputKeys.INDENT, "yes");                          //是否设置缩进(indent: yes|no)
            // 建DOMSource对象并将Document加载到其中
            DOMSource domSource = new DOMSource(document); 
            //生成xml文件
            File file = new File(url); 
            if (!file.exists()) {       //判断文件是否存在
                file.createNewFile();   //不存在生存文件
            }
            FileOutputStream out = new FileOutputStream(file);     //文件输出流            
            StreamResult xmlResult = new StreamResult(out);        //设置输入源   
            // 使用Transformer的transform()方法将DOM树转换成XML(参数:DOMSource, 输入源)
            transformer.transform(domSource, xmlResult);
            message = "生成本地XML成功!";
        }catch(Exception e){
            e.printStackTrace();
            message = "生成本地XML失败!";
        }
        return message;
    }

    /** 接口方法(重载)
     *  创建Xml字符串
     *  返回String: xml字符串
     * */
    public String createXml(){
        String xmlString = null;
        if(documentElements != null && documentElements.size() > 0){    //判断是否存在xml格式和内容
            Document document = createDom();                //调用 生成Dom树 的方法
            xmlString = createXmlToString(document);        //调用 生成xml字符串 的方法
        }
        return xmlString;
    }

    /** 接口方法(重载)
     *  创建Xml本地文件(参数: 路径)
     *  返回String: 成功/失败消息
     * */
    public String createXml(String url){
        String xmlMessage = null;
        if(documentElements != null && documentElements.size() > 0){    //判断是否存在xml格式和内容
            Document document = createDom();                //调用 生成Dom树 的方法
            xmlMessage =  createXmlToFile(url, document);   //调用 生成xml文件 的方法
        }
        return xmlMessage;
    }
}

代码的使用 | 测试

    //方法使用1(该方法为第一张结果截图,每个层级节点下,带有属性节点)
    public static void main(String[] args) {
        //创建数据(这里大家可以从数据库读出)
        String rootName = "rootXml";                    //根节点名称

        String multiplyOne = "multiply";                //层级节点名称
        HashMap<String, Object> propertyOnes = new HashMap<String, Object>();   //属性节点集合
        propertyOnes.put("name", "chuck");
        propertyOnes.put("age", 20);

        String multiplyTwo = "multiply2";               //层级节点名称
        HashMap<String, Object> propertyTwos = new HashMap<String, Object>();   //属性节点集合
        propertyTwos.put("name", "Jack");
        propertyTwos.put("age", 50);

        //创建Xmlformat格式类: 一个Xmlformat为一个层级(以下有两个层级,大家可以回到上面看结果截图)
        XmlFormat xmlformatOne = new XmlFormat(rootName);   //创建xml格式,并传入 根节点名称
        xmlformatOne.setElement(multiplyOne, propertyOnes); //设置层级节点名称 和 属性节点的集合 (setElement为重载方法)

        XmlFormat xmlformatTwo = new XmlFormat(rootName);   //创建xml格式,并传入 根节点名称
        xmlformatTwo.setElement(multiplyTwo, propertyTwos); //设置层级节点名称 和 属性节点的集合(setElement为重载方法)

        //创建XmlHandler
        XmlHandler xmlhandler = new XmlHandler();
        xmlhandler.documentElements.add(xmlformatOne);      //把格式XmlFormat, 设置xmlhandler里面的集合
        xmlhandler.documentElements.add(xmlformatTwo);      //把格式XmlFormat, 设置xmlhandler里面的集合

        String xmlString = xmlhandler.createXml();  //调用xmlHandler的接口方法, 获取xml字符串
        System.out.println(xmlString);
    }
//方法使用2(该方法为第二张结果截图,有一个层级节点下,直接带有内容,没有属性节点)
public static void main(String[] args) {
        //创建数据(这里大家可以从数据库读出)
        String rootName = "rootXml";                    //根节点名称

        String multiplyOne = "multiply";                //层级节点名称
        String multiplyOneValue = "hello multiply!";    //层级节点内容(没有属性节点)

        String multiplyTwo = "multiply2";               //层级节点名称
        HashMap<String, Object> propertyTwos = new HashMap<String, Object>();   //属性节点集合
        propertyTwos.put("name", "Jack");
        propertyTwos.put("age", 50);

        //创建Xmlformat格式类: 一个Xmlformat为一个层级(以下有两个层级,大家可以回到上面看结果截图)
        XmlFormat xmlformatOne = new XmlFormat(rootName);        //创建xml格式,并传入 根节点名称
        xmlformatOne.setElement(multiplyOne, multiplyOneValue);  //设置层级节点名称 和 层级节点内容 (setElement为重载方法)

        XmlFormat xmlformatTwo = new XmlFormat(rootName);        //创建xml格式,并传入 根节点名称
        xmlformatTwo.setElement(multiplyTwo, propertyTwos);      //设置层级节点名称 和 属性节点的集合(setElement为重载方法)

        //创建XmlHandler
        XmlHandler xmlhandler = new XmlHandler();
        xmlhandler.documentElements.add(xmlformatOne);      //把格式XmlFormat, 设置xmlhandler里面的集合
        xmlhandler.documentElements.add(xmlformatTwo);      //把格式XmlFormat, 设置xmlhandler里面的集合

        String xmlString = xmlhandler.createXml();          //调用xmlHandler的接口方法, 获取xml字符串
        System.out.println(xmlString);
    }
//方法使用3(该方法为最后两张结果截图,生成xml本地文件)
public static void main(String[] args) {
        //创建数据(这里大家可以从数据库读出)
        String rootName = "rootXml";                    //根节点名称

        String multiplyOne = "multiply";                //层级节点名称
        String multiplyOneValue = "hello multiply!";    //层级节点内容(没有属性节点)

        String multiplyTwo = "multiply2";               //层级节点名称
        HashMap<String, Object> propertyTwos = new HashMap<String, Object>();   //属性节点集合
        propertyTwos.put("name", "Jack");
        propertyTwos.put("age", 50);

        //创建Xmlformat格式类
        XmlFormat xmlformatOne = new XmlFormat(rootName);        //创建xml格式,并传入 根节点名称
        xmlformatOne.setElement(multiplyOne, multiplyOneValue);  //设置层级节点名称 和 层级节点内容 (setElement为重载方法)

        XmlFormat xmlformatTwo = new XmlFormat(rootName);        //创建xml格式,并传入 根节点名称
        xmlformatTwo.setElement(multiplyTwo, propertyTwos);      //设置层级节点名称 和 属性节点的集合

        //创建XmlHandler
        XmlHandler xmlhandler = new XmlHandler();
        xmlhandler.documentElements.add(xmlformatOne);      //把格式XmlFormat, 设置xmlhandler里面的集合
        xmlhandler.documentElements.add(xmlformatTwo);      //把格式XmlFormat, 设置xmlhandler里面的集合
        //调用xmlHandler的接口方法, 获取xml字符串(createXml重载方法,参数传入url)
        String xmlString = xmlhandler.createXml("D:\\Learn\\abc.xml");  
        System.out.println(xmlString);
    }
  • 7
    点赞
  • 8
    评论
  • 13
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值