JAVA生成XML文件
java中四种生成和解析XML文档的方法详解(介绍+优缺点比较+示例)
java中四种⽣成和解析XML⽂档的⽅法详解(介绍+优缺点⽐较+⽰例)众所周知,现在解析XML的⽅法越来越多,但主流的⽅法也就四种,即:DOM、SAX、JDOM和DOM4J下⾯⾸先给出这四种⽅法的jar包下载地址DOM:在现在的Java JDK⾥都⾃带了,在xml-apis.jar包⾥⼀、介绍及优缺点分析1. DOM(Document Object Model)DOM是⽤与平台和语⾔⽆关的⽅式表⽰XML⽂档的官⽅W3C标准。
DOM是以层次结构组织的节点或信息⽚断的集合。
这个层次结构允许开发⼈员在树中寻找特定信息。
分析该结构通常需要加载整个⽂档和构造层次结构,然后才能做任何⼯作。
由于它是基于信息层次的,因⽽DOM被认为是基于树或基于对象的。
【优点】①允许应⽤程序对数据和结构做出更改。
②访问是双向的,可以在任何时候在树中上下导航,获取和操作任意部分的数据。
【缺点】①通常需要加载整个XML⽂档来构造层次结构,消耗资源⼤。
2. SAX(Simple API for XML)SAX处理的优点⾮常类似于流媒体的优点。
分析能够⽴即开始,⽽不是等待所有的数据被处理。
⽽且,由于应⽤程序只是在读取数据时检查数据,因此不需要将数据存储在内存中。
这对于⼤型⽂档来说是个巨⼤的优点。
事实上,应⽤程序甚⾄不必解析整个⽂档;它可以在某个条件得到满⾜时停⽌解析。
⼀般来说,SAX还⽐它的替代者DOM快许多。
选择DOM还是选择SAX?对于需要⾃⼰编写代码来处理XML⽂档的开发⼈员来说,选择DOM还是SAX解析模型是⼀个⾮常重要的设计决策。
DOM采⽤建⽴树形结构的⽅式访问XML⽂档,⽽SAX采⽤的是事件模型。
DOM解析器把XML⽂档转化为⼀个包含其内容的树,并可以对树进⾏遍历。
⽤DOM解析模型的优点是编程容易,开发⼈员只需要调⽤建树的指令,然后利⽤navigation APIs访问所需的树节点来完成任务。
可以很容易的添加和修改树中的元素。
java注解生成xml和包含CDATA问题
java注解⽣成xml和包含CDATA问题百度java⽣成xml,有⼀⼤推的⽂章,主要的⽣成⽅式⼀种使⽤Dom4J ,还有⼀种使⽤Jdk⾃带注解类!下⾯主要整理我注解类的使⽤,(可以参考这篇⽂章)和xml中CDATA 问题的解决⽅法!1:要⽣成的xml原始⽂件!<?xml version="1.0" encoding="utf-8"?><item><id>35399645973</id><title><![CDATA[补⽔⾸选⽔密码⽔保湿美⽩护洗护组合三件]]> </title><category><![CDATA[美妆>保湿>洗护]]></category><url><![CDATA[/detail-35399645973]]> </url><url_wap><![CDATA[/de99645973]]> </url_wap><price>310</price><promotion_price>93.8</promotion_price><wap_price>85</wap_price><sub_item_ids><sub_item_id>35399645973_1</sub_item_id><sub_item_id>35399645973_2</sub_item_id><sub_item_id>35399645973_3</sub_item_id>……</sub_item_ids><detail><![CDATA[商品详情,⽀持html图⽂混排]]> </detail><status>1<status><pic_main><img><url><![CDATA[/10777829/T_400x400.jpg]]> </url><size>400x400</size></img></pic_main><pic_extra><img><url><![CDATA[/10777821_400x400.jpg]]> </url><size>400x400</size></img><img><url><![CDATA[/10777822_400x400.jpg]]> </url><size>400x400</size></img></pic_extra ></item>2:xml对应的model类!(1):FanLiProductInofMsg.javaimport java.util.List;import javax.xml.bind.annotation.XmlAttribute;import javax.xml.bind.annotation.XmlElement;import javax.xml.bind.annotation.XmlElementWrapper;import javax.xml.bind.annotation.XmlRootElement;/**** @author aflyun* @date 2016.06.12**/@XmlRootElement(name="item")public class FanLiProductInofMsg {@XmlAttributeprivate String version;@XmlElementprivate String id;@XmlElementprivate String title;@XmlElementprivate String category;@XmlElementprivate String url;//Pc商品的url@XmlElement(name="url_wap")private String urlWap;//Wap商品的url url_wap@XmlElementprivate String price;@XmlElement(name="promotion_price")private String promotionPrice;//promotion_price@XmlElement(name="wap_price")private String wapPrice;//wap_price@XmlElementWrapper(name="sub_item_ids")@XmlElement(name="sub_item_id")private List<String> subItemIds;//sub_item_ids@XmlElementprivate String detail;//detail@XmlElementprivate String status;//status@XmlElementWrapper(name="pic_main")@XmlElement(name="img")private List<Img> mainImg;//pic_main@XmlElementWrapper(name="pic_extra")@XmlElement(name="img")private List<Img> extraImg;//pic_extrapublic void setVersion(String version) {this.version = version;}public void setId(String id) {this.id = id;}public void setTitle(String title) {this.title = title;}public void setCategory(String category) {this.category = category;}public void setUrl(String url) {this.url = url;}public void setUrlWap(String urlWap) {this.urlWap = urlWap;}public void setPrice(String price) {this.price = price;}public void setPromotionPrice(String promotionPrice) { this.promotionPrice = promotionPrice;}public void setWapPrice(String wapPrice) {this.wapPrice = wapPrice;}public void setSubItemIds(List<String> subItemIds) { this.subItemIds = subItemIds;}public void setDetail(String detail) {this.detail = detail;}public void setStatus(String status) {this.status = status;}public void setMainImg(List<Img> mainImg) {this.mainImg = mainImg;}public void setExtraImg(List<Img> extraImg) {this.extraImg = extraImg;}}(2):Img .javaimport javax.xml.bind.annotation.XmlElement;import javax.xml.bind.annotation.XmlRootElement;/**** @author aflyun* @date 2016.06.12**/@XmlRootElementpublic class Img {@XmlElement(name="url")private String url;@XmlElement(name="size")private String size;public void setUrl(String url) {this.url = url;}public void setSize(String size) {this.size = size;}}3:⽣成过程,已经CDATA问题处理!package com.dufy.test.xml;import java.io.ByteArrayOutputStream;import java.io.File;import java.io.FileWriter;import java.io.PrintWriter;import java.util.ArrayList;import java.util.List;import javax.xml.bind.JAXBContext;import javax.xml.bind.Marshaller;import javax.xml.transform.sax.SAXResult;import org.apache.xml.serialize.OutputFormat;import org.apache.xml.serialize.XMLSerializer;import org.junit.Test;import com.kuyu.b2b2c.product.fanli.vo.FanLiProductInofMsg; import com.kuyu.b2b2c.product.fanli.vo.Img;public class JuintXmlTest {private static Marshaller marshal;@Testpublic void testXml() throws Exception {List<String> list = new ArrayList<String>();list.add("11_11_11");list.add("22_22_22");list.add("33_33_33");List<Img> imgList = new ArrayList<Img>();Img img = null;for (int i = 0; i < 2; i++) {img = new Img();img.setUrl("-" + i + "-");img.setSize("40×40");imgList.add(img);}FanLiProductInofMsg fps = new FanLiProductInofMsg();fps.setVersion("1.0");fps.setId("110");fps.setTitle("4K ⾼清");fps.setCategory("电视>4K>⾼清");fps.setUrl("");fps.setUrlWap("");fps.setPrice("100");fps.setPromotionPrice("111");fps.setWapPrice("113");fps.setSubItemIds(list);fps.setDetail("wwwwwwwwwwwwwwwwwwwwwww");fps.setStatus("1");fps.setMainImg(imgList);fps.setExtraImg(imgList);PrintWriter pw = new PrintWriter(new File("D:/test.xml"));String ojbectToXmlWithCDATA = ojbectToXmlWithCDATA(FanLiProductInofMsg.class, fps);System.out.println(ojbectToXmlWithCDATA);pw.println(ojbectToXmlWithCDATA);pw.close();}public static String ojbectToXmlWithCDATA(Class clazz, Object obj) throws Exception {JAXBContext context = JAXBContext.newInstance(clazz);// configure an OutputFormat to handle CDATAOutputFormat of = new OutputFormat();of.setCDataElements(new String[] { "^title", //"^category","^url","^url_wap","^detail"}); //// set any other options you'd likeof.setPreserveSpace(true);of.setIndenting(true);// create the serializerByteArrayOutputStream op = new ByteArrayOutputStream();XMLSerializer serializer = new XMLSerializer(op, of);SAXResult result = new SAXResult(serializer.asContentHandler());Marshaller mar = context.createMarshaller();mar.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);mar.marshal(obj, result);return op.toString("utf-8");}}setCDataElements 这⾥⾯你标注需CDATA 的字段!上⾯的这个例⼦可以直接拷贝运⾏,⽹上还⼀些其他的⽅法⽣成xml和CDATA,如果你有好的⽅法,欢迎分享给我,谢谢!4:参考⽂章(1):(2):(3):欢迎访问我的csdn博客,我们⼀同成长!。
JAVA写xml文件
JAVA写xml文件随着计算机技术的飞速发展,需要在程序中存储和管理大量的信息,并用众多的语言和工具进行交互。
为了解决这个问题,以及为不同的程序语言提供一致的格式来实现数据交换,XML(超文本标记语言)应运而生,并在软件开发中得到广泛运用。
XML用来描述数据的一种文本语言,它可以存储比如用户及其信息,设置,排列,及其他数据的内容。
XML在许多计算机程序中被广泛使用,它可以被用来传递数据,或者以XML标记格式存储信息。
尽管XML可以使用任何编程语言来解析,但是其最常见的用法是使用Java来写。
接下来我们就使用Java来写XML文件,具体步骤如下:第一步:准备好XML文件所需要的相关信息。
第二步:导入Java标准包(javax.xml.parsers.*)。
第三步:实例化DocumentBuilderFactory。
DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();第四步:使用builderFactory来实例化DocumentBuilder。
DocumentBuilder builder =builderFactory.newDocumentBuilder();第五步:使用DocumentBuilder来创建文档并且添加元素。
Document document = builder.newDocument();Element rootElement = document.createElement(rootdocument.appendChild(rootElement);第六步:添加属性并写入XML文件。
Element nameElement = document.createElement(amenameElement.setTextContent(EarthrootElement.appendChild(nameElement);Element sizeElement = document.createElement(sizesizeElement.setTextContent(largerootElement.appendChild(sizeElement);TransformerFactory transformerFactory = TransformerFactory.newInstance();Transformer transformer =transformerFactory.newTransformer();DOMSource source = new DOMSource(document);StreamResult result = new StreamResult(newFile(file.xml);transformer.transform(source, result);以上是Java写入XML文件的实例,从上面可以看出JAVA语言是一种非常强大的程序语言,它结合XML技术,可以用来实现大量复杂的数据存储和交互。
java解析想xml生成xml步骤原理
使用要导入dom4j-1.6.1.jar文件我的dom4j文件在讲解生成xml 1:先通过DocumentHelper类的.createDocument()方法生成Document文件2:接着通过DocumentHelper类的createElement("根节点字符串形式")创建根节点3:通过通过生成的Document的实例的setRootElement(根节点)设置根节点4:接着可以通过Document的实例的getRootElement()方法得到根节点5:接着通过根节点(Element类的实例)的.addElement("子节点的字符串形式")添加子节点6:通过节点类(Element类的实例)的setText("字符串“)设置节点对应的值7:通过Document类的实例的.asXML();的方式的得到xml字符串;(注意:xml 是字符串String的形式。
可以设置几个同名的根节点(<user>username1<user><<user>username2<user>)解析时通过Elment的.elementIterator("user");方法得到迭代器)解析xml 1:通过new SAXReader();得到SAXReader的一个实例2:通过StringReader(参数是字符串)将xml字符串转化为一个Reader字符输入流3:通过SAXReader的实例.read(参数是个Reader)得到得到Document4:通过Document的getRootElement()方法得到根节点(Element类的实例)5:通过根节点的element("子节点的字符串形式")方法得到子节点(若有多个同名子节点通过根节点的.elementIterator("user")得到同名节点迭代器)6:通过节点的getTxt();方法得到节点的值生成xml 例子:private static Document constructDocument()//此处会被下面调用{Document document = DocumentHelper.createDocument();Element root = DocumentHelper.createElement("message");document.setRootElement(root);return document;}document文件。
Java XML处理解析和生成XML数据
Java XML处理解析和生成XML数据Java作为一种广泛使用的编程语言,提供了丰富的API和工具来处理和操作XML数据。
本文将介绍Java中处理和解析XML数据的基本方法,并探讨如何使用Java生成XML数据。
一、XML简介XML(可扩展标记语言)是一种用于描述数据的标记语言,它的设计目标是传输数据而不仅仅是显示数据。
XML以一种结构化的方式存储数据,使得数据具有良好的可读性和可扩展性。
二、XML解析XML解析是指将XML数据转换为Java程序可以理解和处理的格式。
Java提供了几种XML解析方法,包括DOM(文档对象模型)、SAX(简单API for XML)和StAX(流API for XML)。
1. DOM解析DOM解析是最常用和最常见的XML解析方法之一。
DOM将XML文档视为一个树形结构,通过解析整个文档并将其加载到内存中,以方便对数据的操作和访问。
使用DOM解析XML的基本步骤如下:(1)创建一个DocumentBuilder对象。
(2)使用DocumentBuilder对象的parse()方法解析XML文件,返回一个Document对象。
(3)通过Document对象获取XML文件中的节点和元素。
以下是一个使用DOM解析XML的示例代码:```DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();DocumentBuilder builder = factory.newDocumentBuilder();Document document = builder.parse(new File("example.xml"));// 获取根节点Element rootElement = document.getDocumentElement();// 获取子节点NodeList nodeList = rootElement.getElementsByTagName("book");for (int i = 0; i < nodeList.getLength(); i++) {Element bookElement = (Element) nodeList.item(i);String title =bookElement.getElementsByTagName("title").item(0).getTextContent( );String author =bookElement.getElementsByTagName("author").item(0).getTextContent();System.out.println("Title: " + title + ", Author: " + author);}```2. SAX解析SAX解析是一种基于事件驱动的解析方法。
Java生成和解析XML格式文件和字符串的实例代码
Java⽣成和解析XML格式⽂件和字符串的实例代码1、基础知识:Java解析XML⼀般有四种⽅法:DOM、SAX、JDOM、DOM4J。
2、使⽤介绍1)、DOM(1)简介由W3C(org.w3c.dom)提供的接⼝,它将整个XML⽂档读⼊内存,构建⼀个DOM树来对各个节点(Node)进⾏操作。
优点就是整个⽂档都⼀直在内存中,我们可以随时访问任何节点,并且对树的遍历也是⽐较熟悉的操作;缺点则是耗内存,并且必须等到所有的⽂档都读⼊内存才能进⾏处理。
(2)⽰例代码:复制代码代码如下:<?xml version="1.0" encoding="UTF-8" standalone="no"?><root><TelePhone><type name="nokia"><price>599</price><operator>CMCC</operator></type><type name="xiaomi"><price>699</price><operator>ChinaNet</operator></type></TelePhone></root>复制代码代码如下:import java.io.ByteArrayOutputStream;import java.io.File;import java.io.FileOutputStream;import java.io.IOException;import java.io.StringReader;import javax.xml.parsers.DocumentBuilder;import javax.xml.parsers.DocumentBuilderFactory;import javax.xml.parsers.ParserConfigurationException;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;import org.w3c.dom.Node;import org.w3c.dom.NodeList;import org.xml.sax.InputSource;import org.xml.sax.SAXException;public class XMLHandler {public XMLHandler(){}public String createXML(){String xmlStr = null;DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); try {DocumentBuilder builder = factory.newDocumentBuilder();Document document = builder.newDocument();document.setXmlVersion("1.0");Element root = document.createElement("root");document.appendChild(root);Element telephone = document.createElement("TelePhone");Element nokia = document.createElement("type");nokia.setAttribute("name", "nokia");Element priceNokia = document.createElement("price");priceNokia.setTextContent("599");nokia.appendChild(priceNokia);Element operatorNokia = document.createElement("operator");operatorNokia.setTextContent("CMCC");nokia.appendChild(operatorNokia);telephone.appendChild(nokia);Element xiaomi = document.createElement("type");xiaomi.setAttribute("name", "xiaomi");Element priceXiaoMi = document.createElement("price");priceXiaoMi.setTextContent("699");xiaomi.appendChild(priceXiaoMi);Element operatorXiaoMi = document.createElement("operator");operatorXiaoMi.setTextContent("ChinaNet");xiaomi.appendChild(operatorXiaoMi);telephone.appendChild(xiaomi);root.appendChild(telephone);TransformerFactory transFactory = TransformerFactory.newInstance(); Transformer transFormer = transFactory.newTransformer();DOMSource domSource = new DOMSource(document);//export stringByteArrayOutputStream bos = new ByteArrayOutputStream();transFormer.transform(domSource, new StreamResult(bos));xmlStr = bos.toString();//-------//save as fileFile file = new File("TelePhone.xml");if(!file.exists()){file.createNewFile();}FileOutputStream out = new FileOutputStream(file);StreamResult xmlResult = new StreamResult(out);transFormer.transform(domSource, xmlResult);//--------} catch (ParserConfigurationException e) {// TODO Auto-generated catch blocke.printStackTrace();}catch (TransformerConfigurationException e) {// TODO Auto-generated catch blocke.printStackTrace();}catch (TransformerException e) {// TODO Auto-generated catch blocke.printStackTrace();}catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}return xmlStr;}public void parserXML(String strXML){DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();try {DocumentBuilder builder = factory.newDocumentBuilder();StringReader sr = new StringReader(strXML);InputSource is = new InputSource(sr);Document doc = builder.parse(is);Element rootElement = doc.getDocumentElement();NodeList phones = rootElement.getElementsByTagName("type");for (int i = 0; i < phones.getLength(); i++) {Node type = phones.item(i);String phoneName = ((Element)type).getAttribute("name");System.out.println("Phone name = "+phoneName);NodeList properties = type.getChildNodes();for (int j = 0; j < properties.getLength(); j++) {Node property = properties.item(j);String nodeName = property.getNodeName();if (nodeName.equals("price")) {String price=property.getFirstChild().getNodeValue();System.out.println("price="+price);} else if (nodeName.equals("operator")) {String operator=property.getFirstChild().getNodeValue();System.out.println("operator="+operator);}}}} catch (ParserConfigurationException e) {// TODO Auto-generated catch blocke.printStackTrace();}catch (SAXException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}public static void main(String[] args) {XMLHandler handler = new XMLHandler();String xml = handler.createXML();System.out.println(xml);handler.parserXML(xml);}}(3)元素(Element)和结点(Node)的区别(org.w3c.dom)Node对象是整个⽂档对象模型的主要数据类型,是DOM中最基本的对象,代表了⽂档树中的抽象节点。
java生成和解析xml
java⽣成和解析xml 本⽂主要使⽤的是Jdom.jar包(包的下载百度⼀下)实现了⽣成xml⽂件和解析xml⽂件下⾯是⽣成xml的实现说明:stuLists集合是⼀个存放着Student对象的集合1import java.io.File;2import java.io.FileNotFoundException;3import java.io.FileOutputStream;4import java.io.IOException;5import java.util.ArrayList;67import org.jdom.Document;8import org.jdom.Element;9import org.jdom.input.SAXBuilder;10import org.jdom.output.Format;11import org.jdom.output.XMLOutputter;1213public class AddXml {14public static void main(String[] args) {15new AddXml().changeXml();16 }17public void changeXml(){18 Jdbc jdbc = new Jdbc();19 jdbc.addList();20 ArrayList<Student> stuLists = Jdbc.getStuList();2122 Document docu = new Document();23 Element root = new Element("root");24 docu.addContent(root);25for (int i = 0; i < stuLists.size(); i++) {26// System.out.println(stuLists.get(i));27 Student s = stuLists.get(i);2829 Element info = new Element("info");30 Element student = new Element("student");31 Element id = new Element("id");32 Element name = new Element("name");33 Element sex = new Element("sex");34 Element age = new Element("age");3536 Element book = new Element("book");37 Element bid = new Element("bid");38 Element bname = new Element("bname");39 Element bprice = new Element("bprice");40 Element bautor = new Element("bautor");41 book.addContent(bid);42 book.addContent(bname);43 book.addContent(bprice);44 book.addContent(bautor);4546 student.addContent(id);47 student.addContent(name);48 student.addContent(sex);49 student.addContent(age);50 info.addContent(student);51 info.addContent(book);5253 root.addContent(info);54int a = i+1;55 String No = "000"+a;56 student.setAttribute("No", No);57 id.setText(s.getId());58 name.setText(s.getName());59 sex.setText(s.getSex());60 age.setText(s.getAge());6162 String b="0"+a;63 bid.setText(b);64 bname.setText("java核⼼");65 bprice.setText("1334.0");66 bautor.setText("star");6768 }69//格式化⽣成的xml⽂件,如果不进⾏格式化的话,⽣成的xml⽂件将会是很长的⼀⾏...70 Format format = Format.getCompactFormat();71 format.setEncoding("utf-8");72 format.setIndent(" ");73 XMLOutputter xo = new XMLOutputter(format);74try {75 xo.output(docu, new FileOutputStream(new File("e:/io/stu.xml")));76 } catch (FileNotFoundException e) {77// TODO Auto-generated catch block78 e.printStackTrace();79 } catch (IOException e) {80// TODO Auto-generated catch block81 e.printStackTrace();82 }83 System.out.println("⽣成xml⽂件成功!!!");84 }85 }结果如图所⽰:下⾯是⽤java解析上⾯所写的xml⽂件简写版package com.direct.demo;import java.io.IOException;import java.util.List;import org.jdom.Document;import org.jdom.Element;import org.jdom.JDOMException;import org.jdom.input.SAXBuilder;public class Saxxml {public static void main(String[] args) {//解析xml⽂档SAXBuilder builder = new SAXBuilder();Document docu = null;try {docu = builder.build("e:/io/student.xml");} catch (JDOMException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}Element root = docu.getRootElement();//得到根⽬录List stulist = root.getChildren();System.out.println(stulist.size()+"-----------");System.out.println("------------------读取xml⽂档的信息---------------------"); for (int i = 0; i < stulist.size(); i++) {Element e = (Element) stulist.get(i);String stuid;String stuname ;String stusex ;String stuage;/*String stuValues = e.getAttribute("No").getValue();//属性值 String stuValues1 = e.getAttributeValue("No");if (stuValues.equals("102")) {//修改姓名System.out.println(stuValues);e.getChild("stuname").setText("砖⽯王⽼五");//删除元素root.removeContent(e);break;}*/if (i==0) {stuid = e.getChildText("stuid");stuname = e.getChildText("stuname");stusex = e.getChildText("stusex");stuage = e.getChildText("stuage");}else {stuid = e.getChildText("stuid"+i);stuname = e.getChildText("stuname"+i);stusex = e.getChildText("stusex"+i);stuage = e.getChildText("stuage"+i);}System.out.println("属性:"+e.getAttributeValue("No"));System.out.println("学号:"+stuid);System.out.println("姓名:"+stuname);System.out.println("年龄:"+stuage);System.out.println("性别:"+stusex);System.out.println("--------------------");}}}。
JavaDOM4J方式生成XML的方法
JavaDOM4J⽅式⽣成XML的⽅法使⽤DOM4J⽅式⽣成XML⽂件的步骤如下:引⼊JAR包通过DocumentHelper类的createDocument()创建Document对象通过Document的addElement()⽅法创建节点通过Element的addAttribute()⽅法为节点添加属性通过Element的setText()⽅法为节点设置内容通过OutputFormat的createPrettyPrint()⽅法创建OutputFormat对象(会⾃动缩进、换⾏)创建XMLWriter对象,将⽬的⽂件包装成OutputStream传⼊构造⽅法中,并将OutputFormat对象⼀并传⼊其中通过XMLWriter的write()⽅法⽣成XML⽂件,并将Document对象作为参数传⼊关闭XMLWriter对象下⾯给出完整代码:package util;import java.io.File;import java.io.FileOutputStream;import java.io.IOException;import org.dom4j.Document;import org.dom4j.DocumentHelper;import org.dom4j.Element;import org.dom4j.io.OutputFormat;import org.dom4j.io.XMLWriter;public class XMLUtils {public void CreateXMLByDOM4J(File dest) {// 创建Document对象Document document = DocumentHelper.createDocument();// 创建根节点Element rss = document.addElement("rss");//为rss根节点添加属性rss.addAttribute("version", "2.0");// 创建channel⼦节点Element channel = rss.addElement("channel");// 创建title⼦节点Element title = channel.addElement("title");// 设置title节点的值title.setText("<![CDATA[上海移动互联⽹产业促进中⼼正式揭牌 ]]>");// 创建输出格式(OutputFormat对象)OutputFormat format = OutputFormat.createPrettyPrint();///设置输出⽂件的编码// format.setEncoding("GBK");try {// 创建XMLWriter对象XMLWriter writer = new XMLWriter(new FileOutputStream(dest), format);//设置不⾃动进⾏转义writer.setEscapeText(false);// ⽣成XML⽂件writer.write(document);//关闭XMLWriter对象writer.close();} catch (IOException e) {e.printStackTrace();}}}若想⾃定义XML⽂件的编码⽅式,可使⽤OutputFormat对象的setEncoding()⽅法设置:///设置输出⽂件的编码format.setEncoding("GBK");DOM4J会对某些特殊字符进⾏⾃动转义,若不想让DOM4J进⾏⾃动转义,我们可以通过XMLWriter的setEscapeText()⽅法进⾏设置。
Java中使用DOM4J来生成xml文件和解析xml文件
Java中使⽤DOM4J来⽣成xml⽂件和解析xml⽂件⼀、前⾔现在有不少需求,是需要我们解析xml⽂件中的数据,然后导⼊到数据库中,当然解析xml⽂件也有好多种⽅法,⼩编觉得还是DOM4J⽤的最多最⼴泛也最好理解的吧.⼩编也是最近需求⾥遇到了,就来整理⼀下⾃⼰的理解,只适合刚刚学习的,⼀起理解!今天我们把解析xml⽂件和⽣成xml⽂件在⼀起来展⽰.⼆、准备依赖<dependency><groupId>dom4j</groupId><artifactId>dom4j</artifactId><version>1.6.1</version></dependency>三、⽣成xml⽂件⽣成标准展⽰⽣成xml代码/*** 使⽤DOM4J⽣成xml⽅法*/public static void createXml(){try {// 创建document对象Document document = DocumentHelper.createDocument();// 创建根节点bookRootElement StudentRoot = document.addElement("StudentRoot");// 向根节点中添加第⼀个节点Element book1 = StudentRoot.addElement("student");// 向⼦节点中添加属性book1.addAttribute("id","1");// 向节点中添加⼦节点Element name = book1.addElement("name");// 向⼦节点赋值name.setText("⼩乔");Element price = book1.addElement("age");price.setText("18");// 向根节点中添加第⼆个节点Element book2 = StudentRoot.addElement("student");book2.addAttribute("id","2").addElement("name").setText("⼤桥");book2.addElement("age").setText("20");// 向根节点中添加第三个节点Element book3 = StudentRoot.addElement("student");book3.addAttribute("id","3").addElement("name").setText("孙策");book3.addElement("age").setText("21");// 设置⽣成xml的格式OutputFormat of = OutputFormat.createPrettyPrint();// 设置编码格式of.setEncoding("UTF-8");// ⽣成xml⽂件File file = new File("E:\\student.xml");if (file.exists()){file.delete();}//创建⼀个xml⽂档编辑器XMLWriter writer = new XMLWriter(new FileOutputStream(file), of);//把刚刚创建的document放到⽂档编辑器中writer.write(document);writer.close();} catch (Exception e) {e.printStackTrace();}}四、解析xml⽂件解析xml的⽂件就是刚刚导出的那个样⼦,我们展⽰两种情况,⼀个是知道属性名字和⼦元素名字的我们把解析的xml ⽂件数据放到实体类中.不知道的就直接打印到控制台.实体类展⽰import lombok.Data;@Datapublic class Student {private int id;private String name;private int age;}解析xml⽂件⽅法public static void analysis(){// 把要解析的xml变成file⽂件File file = new File("E:\\student.xml");// 获取解析器对象SAXReader reader = new SAXReader();// 把⽂件解析成document树Document document = null;try {document = reader.read(file);} catch (DocumentException e) {e.printStackTrace();}// 获取根节点Element studentRoot = document.getRootElement();// 获取根节点中所有节点List<Element> elements = studentRoot.elements();// 存放xml中节点的数据集合List<Student> list = new ArrayList<>();// 便利所有节点for (Element child : elements) {Student student = new Student();//已知属性名情况下student.setId(Integer.parseInt(child.attributeValue("id")));//获取属性的数据//已知⼦元素名的情况下student.setName(child.elementText("name"));//获取元素中值student.setAge(Integer.parseInt(child.elementText("age")));//获取元素中值list.add(student);//未知属性名情况下List<Attribute> attributes = child.attributes();for (Attribute attribute : attributes) {System.out.println(attribute.getName() + "---> " + attribute.getValue());}//未知⼦元素名情况下List<Element> elementList = child.elements();for (Element ele : elementList) {System.out.println(ele.getName() + "--->" + ele.getText());}}//把解析xml出来的数据集合打印list.forEach(x-> System.out.println(x));}解析结果展⽰五、总结这样我们就把DOM4J来⽣成xml⽂件和解析xml⽂件就都操作完成了,有什么问题留⾔哦!!谢谢⼤家。
java将表的一条数据转为xml文件的方法
在Java中,将表的一条数据转为XML文件是一个常见的操作。
本文将介绍如何使用Java来实现这一功能,并提供了详细的代码示例。
1. 确定需要转换的数据我们需要确定需要转换为XML文件的数据。
通常情况下,这些数据来自于数据库中的某张表的一条记录。
在本文的示例中,我们假设我们需要将一条学生的记录转为XML文件。
2. 创建数据模型在Java中,我们通常会使用对象来表示数据。
我们首先需要创建一个学生对象,并为该对象添加相应的属性,如学生的尊称、芳龄、性别等。
```javapublic class Student {private String name;private int age;private String gender;// 省略了getter和setter方法}```3. 将数据转为XML在Java中,我们通常会使用第三方库来帮助我们将数据转为XML文件。
在本文的示例中,我们将使用dom4j这个开源的XML解析库来实现数据到XML的转换。
```javapublic class XMLConverter {public String convertToXML(Student student) {Document document =DocumentHelper.createDocument();Element root = document.addElement("student");root.addElement("name").addText(student.getName());root.addElement("age").addText(String.valueOf(student.getAge( )));root.addElement("gender").addText(student.getGender());return document.asXML();}}```4. 测试转换结果我们需要编写一个测试类来验证我们的转换是否成功。
Java——SAX生成XML文件
Java——SAX⽣成XML⽂件SAX⽣成XML⽂件准备⼯作创建⼀个SAXTransformerFactory 类对象//创建⼀个 SAXTransformerFactory 类对象SAXTransformerFactory tff = (SAXTransformerFactory)SAXTransformerFactory.newInstance();通过SAXTransformerFactory 对象创建⼀个 Transformer 对象//通过 SAXTransformerFactory 对象创建⼀个 TransformerHandler 对象TransformerHandler handler = tff.newTransformerHandler();设置 xml ⽂件编码格式和⾃动换⾏//设置⽣成的 XML ⽂件编码格式tr.setOutputProperty(OutputKeys.ENCODING, "utf-8");//设置⽣成的 XML ⽂件⾃动换⾏tr.setOutputProperty(OutputKeys.INDENT, "yes");判断⽣成的 xml ⽂件是否存在,不存在就创建⼀个新的//如果不存在,就创建⼀个新的 XML ⽂件File file = new File("newSchool.xml");if (!file.exists()) {file.createNewFile();}创建⼀个 Result 对象,并且使其与 TransformerHandler对象关联//创建⼀个Result 对象,并且使其与 TransformerHandler 对象关联Result result = new StreamResult(new FileOutputStream(file));handler.setResult(result);利⽤ handler 对象进⾏ xml ⽂件内容的编写打开 document//打开 documenthandler.startDocument();⽣成根节点标签AttributesImpl atts = new AttributesImpl();//根节点开始标签handler.startElement("", "", "School", atts);设置字节点的属性和属性值并创建⼦节点的开始标签//设置属性和属性值atts.addAttribute("", "", "id", "", "1");//⼦节点开始标签handler.startElement("", "", "student", atts);创建⼦节点下的 name 节点并给其添加内容atts.clear(); //清空⼦节点设的值//字节点下name节点开始标签handler.startElement("", "", "name", atts);String name="⼩王";handler.characters(name.toCharArray(), 0, name.length());//字节点下name节点结束标签handler.endElement("", "", "name");有开始就结束,在 XML 当中标签都是成对出现的,下⾯就是结束标签,以及关闭 document对象//⼦节点结束标签handler.endElement("", "", "student");//根节点结束标签handler.endElement("", "", "School");//关闭 documenthandler.endDocument();运⾏结果:<?xml version="1.0" encoding="utf-8"?><School><student id="1"><name>⼩王</name></student></School>完整代码: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 CreateXMLBySAX {public static void main(String[] args) {//创建⼀个 SAXTransformerFactory 类对象SAXTransformerFactory tff = (SAXTransformerFactory)SAXTransformerFactory.newInstance();try {//通过 SAXTransformerFactory 对象创建⼀个 TransformerHandler 对象TransformerHandler handler = tff.newTransformerHandler();//通过 TransformerHandler 对象创建⼀个 Transformer 对象Transformer tr = handler.getTransformer();//设置⽣成的 XML ⽂件编码格式tr.setOutputProperty(OutputKeys.ENCODING, "utf-8");//设置⽣成的 XML ⽂件⾃动换⾏tr.setOutputProperty(OutputKeys.INDENT, "yes");//如果不存在,就创建⼀个新的 XML ⽂件File file = new File("newSchool.xml");if (!file.exists()) {file.createNewFile();}//创建⼀个Result 对象,并且使其与 TransformerHandler 对象关联Result result = new StreamResult(new FileOutputStream(file));handler.setResult(result);//利⽤ handler 对象进⾏ XML ⽂件内容的编写//打开 documenthandler.startDocument();//为了创建节点属性和属性值AttributesImpl atts = new AttributesImpl();//根节点开始标签handler.startElement("", "", "School", atts);//atts.clear(); //清空 atts 的值//设置属性和属性值atts.addAttribute("", "", "id", "", "1");//⼦节点开始标签handler.startElement("", "", "student", atts);atts.clear(); //清空⼦节点设的值//字节点下name节点开始标签handler.startElement("", "", "name", atts);String name="⼩王";handler.characters(name.toCharArray(), 0, name.length());//字节点下name节点结束标签handler.endElement("", "", "name");//⼦节点结束标签handler.endElement("", "", "student");//根节点结束标签handler.endElement("", "", "School");//关闭 documenthandler.endDocument();} catch (TransformerConfigurationException e) { e.printStackTrace();} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} catch (SAXException e) {e.printStackTrace();}}}。
Java创建XML的三种方式
Java创建XML的三种⽅式1.使⽤Document创建XML⽂档:注意:导包时导⼊org.w3c.dom的包:创建图书列表:Book book1 = new Book(1, "001", "魔戒");book1.addAuthor("托尔⾦");Book book2 = new Book(2, "002", "哈利波特");book2.addAuthor("JK 罗琳");Book book3 = new Book(3, "004", "冰与⽕之歌");book3.addAuthor("乔治马丁");Book book4 = new Book(4, "009", "三体");book4.addAuthor("刘慈欣");book4.addAuthor("杨宇昆");List<Book> list = new ArrayList<>();list.add(book1);list.add(book2);list.add(book3);list.add(book4);使⽤Document创建XML⽂档:Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();Element bookList = doc.createElement("book-list");for (Book b : list) {Element book = doc.createElement("book");Attr attr = doc.createAttribute("id");attr.setValue(String.valueOf(b.getId()));//为Book标签添加属性IDbook.setAttributeNode(attr);Element title = doc.createElement("title");title.appendChild(doc.createTextNode(b.getTitle()));Element isbn = doc.createElement("isbn");isbn.appendChild(doc.createTextNode(b.getIsbn()));Element authorList = doc.createElement("author-list");for (String string : b.getAuthors()) {Element author = doc.createElement("author");author.appendChild(doc.createTextNode(string));authorList.appendChild(author);}book.appendChild(title);book.appendChild(isbn);book.appendChild(authorList);bookList.appendChild(book);}doc.appendChild(bookList);Transformer transformer = TransformerFactory.newInstance().newTransformer();transformer.transform(new DOMSource(doc), new StreamResult(new File("doc.xml")));输出结果:使⽤Document解析XML⽂档:String file = "doc.xml";List<Book>list = new ArrayList<Book>();Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new File(file));NodeList books = doc.getElementsByTagName("book");for(int i=0;i<books.getLength();i++) {Book b = new Book();Element book = (Element) books.item(i);String id = book.getAttribute("id");Element title = (Element) book.getElementsByTagName("title").item(0); Element isbn = (Element) book.getElementsByTagName("isbn").item(0); NodeList authors = book.getElementsByTagName("author-list");for(int j=0;j<authors.getLength();j++) {Element author = (Element) authors.item(j);b.addAuthor(author.getTextContent());}b.setId(Integer.valueOf(id));b.setTitle(title.getTextContent());b.setIsbn(isbn.getTextContent());list.add(b);}for (Book book : list) {System.out.println(book);}转换后输出结果:2.使⽤SAXParse解析XML⽂档:注意:导⼊包时需注意,导⼊simple的包:main⽅法:SAXParser parser = SAXParserFactory.newInstance().newSAXParser();BookHandler bookHandler = new BookHandler();parser.parse(new File("doc.xml"), bookHandler);List<Book>list = bookHandler.list;for (Book book : list) {System.out.println(book);}System.out.println("完成");bookHandler类()@Overridepublic void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException { super.startElement(uri, localName, qName, attributes);if(qName.equals("book")) {book = new Book();book.setId(Integer.valueOf(attributes.getValue("id")));}}@Overridepublic void endElement(String uri, String localName, String qName) throws SAXException {super.endElement(uri, localName, qName);if(qName.equals("book")) {list.add(book);}if(qName.equals("title")) {book.setTitle(text);}if(qName.equals("isbn")) {book.setIsbn(text);}if(qName.equals("author")) { book.addAuthor(text);}}@Overridepublic void characters(char[] ch, int start, int length) throws SAXException {super.characters(ch, start, length);text = String.valueOf(ch,start,length);}测试结果:Book [id=1, isbn=001, title=魔戒, authors=[托尔⾦]]Book [id=2, isbn=002, title=哈利波特, authors=[JK 罗琳]]Book [id=3, isbn=004, title=冰与⽕之歌, authors=[乔治马丁]]Book [id=4, isbn=009, title=三体, authors=[刘慈欣, 杨宇昆]]完成3.使⽤Simple解析XML⽂档:main⽅法:Book book1 = new Book(1, "001", "魔戒");book1.addAuthor("托尔⾦");Book book2 = new Book(2, "002", "哈利波特");book2.addAuthor("JK 罗琳");Book book3 = new Book(3, "004", "冰与⽕之歌");book3.addAuthor("乔治马丁");Book book4 = new Book(4, "009", "三体");book4.addAuthor("刘慈欣");book4.addAuthor("杨宇昆");BookList list = new BookList();list.add(book1);list.add(book2);list.add(book3);list.add(book4);//持久化Persister persister = new Persister();try {persister.write(list, System.out);} catch (Exception e) {e.printStackTrace();}使⽤注解为Book实体标注:@Attributeprivate int id;@Element(required = false)private String isbn;@Element(required = false)private String title;@ElementList(name = "author-list")private ArrayList<String>authors = new ArrayList<String>();上述注解含义:Attribute:标注该字段为标签中的属性Element:标注该字段为元素ElementList:标注为元素列表required:标注是否为可选属性(true:必须有(默认为true);false:可有可⽆)name:修改字段在标签中的名字root:标注该字段为XML的根BookList类(为ArrayList做了⼀下包装)@Root(name = "book-list")public class BookList {@ElementList(name = "book",inline = true)ArrayList<Book>bookList;public BookList() {bookList = new ArrayList<Book>();}public void add(Book book) {bookList.add(book);}}注意:ArrayList为官⽅写好的,我们是不可以改变的,也就不可以为其添加注解,所以采⽤⼀个包装的⽅式,给BookList写注解即可 在实体中,如果都不写注解将都会显⽰,如果有写注解的,那么将只会显⽰写了注解的,其他的将不会显⽰. 在转换成XML时,推荐使⽤simple和SAX,⽽Document限于理解XML解析原理,(simple和SAX的容错效果更好),推荐使⽤常见的两种数据传输的格式:XML和JSON,但是JSON更简单⼀些;可以看上⼀篇博客。
java生成xml文件
java生成xml文件(转)2009-12-03 16:32jdom下载/这里有最新的jdom下载。
安装配置//=====================java 生成xml//----生成的xml在工程目录下---//-----java文件------package javaapplication2;import java.io.*;import org.jdom.*;import org.jdom.input.*;import org.jdom.input.*;import org.jdom.output.*;public class test1 {public void BuildXMLDoc() throws IOException, JDOMException { Element eeeRoot, eee1, eee2;Document Doc;eeeRoot = new Element("employees_information");Doc = new Document(eeeRoot);eeeRoot = Doc.getRootElement();eee1 = new Element("name");eee2 = eee1.setText("C.Y. Shen");//eee2 = eee1.addAttribute("emp_id", "001");eee1 = eeeRoot.addContent(eee2);eee1 = new Element("age");eee2 = eee1.setText("43");eee1 = eeeRoot.addContent(eee2);eee1 = new Element("sex");eee2 = eee1.setText("Male");eee1 = eeeRoot.addContent(eee2);// XMLOut.setEncoding("gb2312");XMLOutputter XMLOut = new XMLOutputter();XMLOut.output(Doc, new FileOutputStream("test1.xml"));}public static void main(String[] args) {try {test1 s1 = new test1();System.out.println("Now we build an XML document ....."); s1.BuildXMLDoc();} catch (Exception e) {System.out.println(e.getMessage());}}}//========生成的xml文件=============<?xml version="1.0" encoding="UTF-8"?><employees_information><name>C.Y. Shen</name><age>43</age><sex>Male</sex></employees_information>++++++++++++++++++++++++++++++++++++++++++++++++ ++++++生成一个xml文件,包括雇员信息,文件个数。
在JAVA生成XML文件
在JAVA⽣成XML⽂件使⽤的所有⼯具和软件⼀、导⼊⼆、创建Test测试类三、导⼊各种需要使⽤的包 import org.dom4j.Document; import org.dom4j.DocumentHelper; import org.dom4j.Element; import org.dom4j.io.OutputFormat; import org.dom4j.io.XMLWriter; import java.io.File; import java.io.FileWriter; import java.io.IOException;---1.通过DocumentHelper 的 createDocument⽅法创建⼀个---2.添加并得到根节点---3.为books根节点添加⼦节点---4.为book节点添加属性id 值为---5.为book节点添加⼦节点 Element name = book.addElement("name"); Element author = book.addElement("author");---6.为name,author,price name.addText("测试1"); author.addText("测试2");---7.实例化写⼊器,新建⼀个File名为books2.xml 此时可以分两种写⼊⽅式(1)直接使⽤wtire写⼊器,输⼊到books2.xml中, 但是格式会⽐较僵硬如下 //将doc输出到 books2.xml ⽂件中 Writer writer = new FileWriter(new File("src/com/com/test/xml/domain/books2.xml")); document.write(writer); //关闭资源(2)使⽤OutputFormat类美化输出结构,使⽤XMLWriter美化缩进结构 --使⽤OutputFormat.createPrettyPrint() 构造⼀个OutputFormat --nwe XMLWriter(nwe FileWrite(File("⽂件名")),OutputFormat对象名);//7.美化输出结构OutputFormat of = OutputFormat.createPrettyPrint();XMLWriter xmlWriter = new XMLWriter(new FileWriter(new File("src/com/com/test/xml/domain/books2.xml")), of); xmlWriter.write(document);//8.xmlWriter.close();五、总体代码回顾//1.通过DocumentHelper 的 createDocument⽅法创建⼀个DocumentDocument document = DocumentHelper.createDocument();//document.addElement("books").addElement("book").addAttribute("id","1");//2.添加并得到根元素Element books = document.addElement("books");//3.为根节点添加⼦元素Element book = books.addElement("book");//4.为⼦元素添加属性Element id = book.addAttribute("id", "1");//5.为book的添加⼦节点Element name = book.addElement("name");Element author = book.addElement("author");Element price = book.addElement("price");//6.为book添加⽂本信息name.addText("测试1");author.addText("测试2");price.addText("25.50");/**// 7.将doc输出到 books2.xml ⽂件中Writer writer = new FileWriter(new File("src/com/com/test/xml/domain/books2.xml"));document.write(writer);//8.关闭资源writer.close();*///7.美化输出结构OutputFormat of = OutputFormat.createPrettyPrint();XMLWriter xmlWriter = new XMLWriter(new FileWriter(new File("src/com/com/test/xml/domain/books2.xml")), of); xmlWriter.write(document);//8.关闭资源xmlWriter.close();。
java生成xml
java⽣成xml⽣成xml@Testpublic void parseApplicationConfigXML(){try {SAXReader sax = new SAXReader();Document xmlDoc = sax.read(new File("d://test.xml"));Element root = xmlDoc.getRootElement();//根节点Iterator it = root.elementIterator("request");while(it.hasNext()){Element request = (Element)it.next();System.out.println(request.getName());System.out.println(request.attributeValue("type"));System.out.println(request.attributeValue("flow"));System.out.println(request.attributeValue("time"));}System.out.println("-------------------------------------------");List list = root.selectNodes("//pro");for(int i = 0; i < list.size(); i++){Element pro = (Element)list.get(i);System.out.println(pro.getName());System.out.println(pro.attributeValue("type"));System.out.println(pro.attributeValue("name"));System.out.println(pro.getText());System.out.println("+++++++++++++++++++++++++++++++++");}List paramList = root.selectNodes("//wsdd/wsd");Iterator Iterator = paramList.iterator();while (Iterator.hasNext()) {Element paramE = (Element) Iterator.next();String t = paramE.attributeValue("type");System.out.println(t);String t1 =paramE.getText();System.out.println(t1);}} catch (DocumentException e) {// TODO Auto-generated catch blocke.printStackTrace();}}解析该xml@Testpublic void parseApplicationConfigXML(){try {SAXReader sax = new SAXReader();Document xmlDoc = sax.read(new File("d://test.xml"));Element root = xmlDoc.getRootElement();//根节点Iterator it = root.elementIterator("request");while(it.hasNext()){Element request = (Element)it.next();System.out.println(request.getName());System.out.println(request.attributeValue("type"));System.out.println(request.attributeValue("flow"));System.out.println(request.attributeValue("time"));}System.out.println("-------------------------------------------");List list = root.selectNodes("//pro");for(int i = 0; i < list.size(); i++){Element pro = (Element)list.get(i);System.out.println(pro.getName());System.out.println(pro.attributeValue("type"));System.out.println(pro.attributeValue("name"));System.out.println(pro.getText());System.out.println("+++++++++++++++++++++++++++++++++");}List paramList = root.selectNodes("//wsdd/wsd");//取到根节点的⼦节点Iterator Iterator = paramList.iterator();while (Iterator.hasNext()) {Element paramE = (Element) Iterator.next();String t = paramE.attributeValue("type");System.out.println(t);String t1 =paramE.getText();System.out.println(t1);}} catch (DocumentException e) {// TODO Auto-generated catch blocke.printStackTrace();}}。
JAVA生成XML文件
formOid.setText("工单编号");
//将工单编号节点添加到基本信息节点下
baseinfo.addContent(formOid);
//创建任务名称节点
Element taskName=newElement("taskName");
//添加任务名称内容
taskName.setText("任务名称");
e.printStackTrace();
}
}
try{
file.createNewFile();
}catch(IOException e) {
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
//创建根节点
Element root=newElement("ObjFlow");
* @since 2008-12-1
* @version
*/
public class ReflectionUtil {
//所有的系统类型
private static String[] allSysDefinedType = new String[] {
"ng.String", "ng.Long", "long", "ng.Integer",
applicant.setText("申请人");
baseinfo.addContent(applicant);
//申请时间
Element applyTime=newElement("applyTime");
java动态生成XML文件
9.impo rt ja va.io.File Outpu tStre am; 10.impo rt ja va.io.IOEx cepti on; 11.impo rt or g.jdo m.Doc ument; 12.i mport org.jdom.Eleme nt; 13.impo rt or g.jdo m.JDO MExce ption; 14.i mport org.jdom.outpu t.XML Outpu tter;15. 16.pub lic c lassJava2XML {17. 18. publ ic vo id Bu ildXM LDoc() thr ows I OExce ption, JDO MExce ption { 19.20. // 创建根节点list;21. Elem ent r oot = newEleme nt("l ist"); 22.23. // 根节点添加到文档中;24. Docum ent D oc =new D ocume nt(ro ot);25. 26. //此处f or 循环可替换成遍历数据库表的结果集操作;27. f or (i nt i= 0;i < 5; i++) { 28. 29. // 创建节点u ser;30. El ement elem ents= new Elem ent("user"); 31.32.// 给user节点添加属性 id;33. e lemen ts.se tAttr ibute("id", ""+ i);34. 35. //给 us er 节点添加子节点并赋值;36. // newEleme nt("n ame")中的 "n ame"替换成表中相应字段,setTe xt("x uehui")中"xuehu i 替换成表中记录值;37.eleme nts.a ddCon tent(new E lemen t("na me").setTe xt("x uehui"));38. ele ments.addC onten t(new Elem ent("age").setT ext("28")); 39. e lemen ts.ad dCont ent(n ew El ement("sex").se tText("Mal e"));40. 41. // 给父节点li st添加u ser子节点; 42.root.addCo ntent(elem ents); 43. 44. }45. X MLOut putte r XML Out = newXMLOu tputt er();46. 47. //输出u ser.x ml 文件;48. XMLO ut.ou tput(Doc,new F ileOu tputS tream("use r.xml"));49. } 50. 51. publi c sta tic v oid m ain(S tring[] ar gs) {52. t ry {53. Jav a2XML j2x= new Java2XML(); 54.Syste m.out.prin tln("生成 mx l 文件...");55. j2x.Bui ldXML Doc(); 56. } cat ch (E xcept ion e) { 57. e.pr intSt ackTr ace(); 58. } 59. } 60.61.}62. 63.64.生成的 user.xml文件65.66.<?xml v ersio n="1.0" en codin g="UT F-8"?> 67.<l ist>68. <user id="0"> 69. <n ame>x uehui</nam e> 70. <ag e>28</age>71. <sex>Male</sex>72. </us er> 73.<userid="1"> 74. <na me>xu ehui</name> 75. <age>28</age>76. <sex>M ale</sex>77. </use r> 78. <u ser i d="2"> 79. <nam e>xue hui</name>80. <age>28</a ge> 81. <s ex>Ma le</s ex> 82.</user> 83. <us er id="3">84. <name>xueh ui</n ame>85. <age>28</ag e> 86. <se x>Mal e</se x> 87. </user>88. <use r id="4">89. <name>xueh ui</n ame>90. <age>28</a ge> 91. <sex>M ale</sex>92. </us er> 。
java生成xml格式文件的方法
java生成xml格式文件的方法java⽣成xml格式⽣件的⽣法本⽣实例讲述了java⽣成xml格式⽣件的⽣法。
分享给⽣家供⽣家参考,具体如下:这⽣演⽣利⽣Java⽣成xml格式⽣件Demo中所⽣到的jar包。
为了⽣便理解,我写了个Demoimport java.io.FileOutputStream;import java.io.IOException;import org.jdom.Document;import org.jdom.Element;import org.jdom.JDOMException;import org.jdom.output.Format;import org.jdom.output.XMLOutputter;public class Java2XML {Book[] books = new Book[]{new Book("1","唐诗三百⽣"),new Book("2","Think in Java"),new Book("3","神雕侠侣"),new Book("4","葵花宝典")};public void BuildXMLDoc() throws IOException, JDOMException {// 创建根节点并设置它的属性 ;Element root = new Element("books").setAttribute("count", "4");// 将根节点添加到⽣档中;Document Doc = new Document(root);for (int i = 0; i < books.length; i++) {// 创建节点 book;Element elements = new Element("book");// 给 book 节点添加⽣节点并赋值;elements.addContent(newElement("id").setText(books[i].getBook_id()));elements.addContent(newElement("name").setText(books[i].getBook_name()));//root.addContent(elements);}// 输出 books.xml ⽣件;// 使xml⽣件缩进效果Format format = Format.getPrettyFormat();XMLOutputter XMLOut = new XMLOutputter(format);XMLOut.output(Doc, new FileOutputStream("c:/books.xml"));}public static void main(String[] args) {try {Java2XML j2x = new Java2XML();System.out.println("正在⽣成 books.xml ⽣件...");j2x.BuildXMLDoc();} catch (Exception e) {e.printStackTrace();}System.out.println("c:/books.xml ⽣件已⽣成");}}运⽣效果是在本⽣电脑c盘有个books.xml⽣件(此前是没有这个⽣件)简单Demo ⽣看就清楚希望本⽣所述对⽣家java程序设计有所帮助。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
package com.creawor.cbsms.client.xml.util;
import ng.reflect.Field;
import ng.reflect.InvocationTargetException;
import ng.reflect.Method;
"boolean", "java.sql.Timestamp" };
private static String dateFormatString = "yyyy-MM-dd HH:mm:ss";
//使用不可以是属性名前缀的*作为标识是否是用户自定义的类型
private static String userDefiendTypePrefix = "*";
//TODOAuto-generatedmethodstub
String filename="c:\\text.xml";
File file=newFile(filename);
/**
*判断文件是否存在.如果文件不存在则生成一个文件
*则生成一个文件;反之则先删除原有文件,生成一个新的文件
*/
if(file.exists()){
item.addContent(devicetype);
//问题时间
Element problemtime=newElement("problemtime");
problemtime.setText("问题时间");
item.addContent(problemtime);
//指标或参数名
Element parametername=newElement("parametername");
item.addContent(parametervalues);
items.addContent(item);
AdjustReason.addContent(items);
baseinfo.addContent(AdjustReason);
//将工单编号节点添加到根节点下
root.addContent(baseinfo);
import java.text.SimpleDateFormat;
import java.util.HashMap;
import java.util.Map;
/**
* <p>
* Description:反射机制工具类,根据传入的Obj,
*为生成xml文件提取所有属性和属性对应的值
* </p>
*
*
* @author Administrator
//创建工单编号节点
Element formOid=newElement("formOid");
//添加工单编号节点内容
formOid.setText("工单编号");
//将工单编号节点添加到基本信息节点下
baseinfo.addContent(formOid);
//创建任务名称节点
Element taskName=newElement("taskName");
//行政区域
Element canton=newElement("canton");
canton.setText("canton");
item.addContent(canton);
//设备类型
Element devicetype=newElement("devicetype");
devicetype.setText("设备类型");
try{
file.delete();
}catch(Exception e) {
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}
try{
file.createNewFile();
}catch(IOException e) {
//TODOAuto-generatedcatchblock
baseinfo.addContent(leafletType);
//涉及网元
Element metadataName=newElement("metadataName");
metadataName.setText("涉及网元");
baseinfo.addContent(metadataName);
//创建调整原因的根节点
Element items=newElement("items");
//创建一个原因信息
Element item=newElement("item");
//小区名
Element villagename=newElement("villagename");
villagename.setText("小区名");
//添加任务名称内容
taskName.setText("任务名称");
//将任务名称添加到基本信息中
baseinfo.addContent(taskName);
//创建工单类型
Element leafletType=newElement("leafletType");
leafletType.setText("工单类型");
//附件
Element accessory=newElement("accessory");
accessory.setText("附件");
baseinfo.addContent(accessory);
//调整原因
Element AdjustReason=newElement("AdjustReason");
*/
public Map<String, Object> transformObjData2Map(Object obj,
String[] unReflectProp) {
Map<String, Object> rootMap = new HashMap<String, Object>();
Map<String, Object> dataMap = new HashMap<String, Object>();
parametername.setText("指标或参数名");
item.addContent(parametername);
//指标或参数值
Element parametervalues=newElement("parametervalues");
parametervalues.setText("指标或参数值");
"int", "ng.Short", "short", "ng.Byte", "byte",
"ng.Float", "float", "ng.Double", "double",
"java.util.Date", "ng,Char", "char", "ng.Boolean",
* @since 2008-12-1
* @version
*/
public class ReflectionUtil {
//所有的系统类型
private static String[] allSysDefinedType = new String[] {
"ng.String", "ng.Long", "long", "ng.Integer",
//将内容写到文件中
xmlout.output(document, out);
}catch(Exception e) {
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}
}推荐群组: JSF更 Nhomakorabea相关推荐
最近的项目中用到了XML,所以就写了个对象转换为XML文件的通用类。
*
* @return Map
* key = property name ; value = property value;
* (如果属性为一个用户自定义类型的对象那么
* key = '*' + 'user defined type';
* value = map;map中key是属性,value是值,依次循环)
applyTime.setText("申请时间");
baseinfo.addContent(applyTime);
//问题描述
Element problemDesc=newElement("problemDesc");
problemDesc.setText("申请时间");
baseinfo.addContent(problemDesc);
return rootMap;
}
/**
*得到传入对象的每个属性域,