java操作word(利用xml模板)

java操作word(利用xml模板)
java操作word(利用xml模板)

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.InputStream;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

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.NodeList;

import org.w3c.dom.Node;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

public class OperateXml {

/**

* @param args

*/

public static void main(String[] args) {

// TODO Auto-generated method stub

OperateXml ox = new OperateXml();

ox.operateXml();

}

public void operateXml() {

try {

DocumentBuilderFactory factory = DocumentBuilderFactory

.newInstance();

DocumentBuilder builder = factory.newDocumentBuilder();

Document document = builder.parse(new File("D:/贷前核查输出模板.xml"));

Element element = document.getDocumentElement();

// 得到所有表格集合

NodeList tblList = element.getElementsByTagName("w:tbl");// w:t标签组

// 得到第一张表

Element tbl1 = (Element) tblList.item(0);

// 得到第一张表中所有行

NodeList rowList = tbl1.getElementsByTagName("w:tr");

for (int i = 1; i < rowList.getLength(); i++) {

Element rowNode = (Element) rowList.item(i);

// 得到这行的所有单元格

NodeList cellList = rowNode.getElementsByTagName("w:tc");

// 基于这次模版开始从每行的第二个单元格操作

for (int j = 1; j < cellList.getLength(); j++) {

if (j == 1) {

Element cellNode = (Element) cellList.item(j);

// 得到单元格底下的文本(p节点)

Element pNode = (Element) cellNode

.getElementsByTagName("w:p").item(0);

// 得到文本行

Element rNode = (Element) pNode.getElementsByTagName(

"w:r").item(0);

//如果有文本值,那么修改,没有则给p节点追加r节点

if (rNode != null) {

Node tNode = rNode.getElementsByTagName("w:t")

.item(0);

tNode.setTextContent(i+"-"+j);

} else {

Document parent = pNode.getOwnerDocument();

Element r = null;

Element t = null;

r = parent.createElement("w:r");

t = parent.createElement("w:t");

t.setTextContent(i+"-"+j);

pNode.appendChild(r);

r.appendChild(t);

}

}

}

}

saveXml("D:/贷前核查输出模板1.doc",document);

} catch (Exception ex) {

System.out.println("有误");

}

}

public static void saveXml(String fileName, Document doc) {//将Document输出到文件TransformerFactory transFactory=TransformerFactory.newInstance();

try {

Transformer transformer = transFactory.newTransformer();

transformer.setOutputProperty("indent", "yes");

DOMSource source=new DOMSource();

source.setNode(doc);

StreamResult result=new StreamResult();

result.setOutputStream(new FileOutputStream(fileName));

transformer.transform(source, result);

} catch (TransformerConfigurationException e){

e.printStackTrace();

} catch (TransformerException e) {

e.printStackTrace();

} catch (FileNotFoundException e){

e.printStackTrace();

}

}

}

java利用xml导出word(占位符替换)

package cn.action; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.util.ArrayList; import java.util.Date; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.transform.Transformer; 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.NodeList; import sun.misc.BASE64Encoder; public class XmlWord { private Map dataMap = new HashMap(); public Map getDataMap() { return dataMap; } public void setDataMap(Map dataMap) { this.dataMap = dataMap; } /** * 设置标识值 * @param tagList 标识 * @param dataList 数据 * @param dataMap */ public void setData(List tagList,List dataList){

Dom4j遍历解析XML测试

Dom4j遍历解析XML测试 近来老和XML打交道,不深挖不行了。。 这是一个Dom4j解析XML的例子,为做复杂递归处理前期所写的例子。涵盖了XML的解析方面大部分核心API。 环境: Dom4j-1.6.1 Dom4j解析需要XML需要的最小类库为: dom4j-1.6.1.jar jaxen-1.1-beta-6.jar 目标: 解析一个xml,输出所有的属性和元素值。 测试代码: XML文件: zhangsan 32 home add com add lisi 22 home add com add com add

解析代码: package com.topsoft.test; import org.dom4j.io.SAXReader; import org.dom4j.Document; import org.dom4j.DocumentException; import org.dom4j.Element; import org.dom4j.Node; import java.util.Iterator; import java.util.List; import java.io.InputStream; /** * Created by IntelliJ IDEA.
* User: leizhimin
* Date: 2008-3-26 15:53:51
* Note: Dom4j遍历解析XML测试 */ public class TestDom4j { /** * 获取指定xml文档的Docum ent对象,xml文件必须在classpath中可以找到 * * @param xmlFilePath xml文件路径 * @return Document对象 */ public static Docum ent parse2Document(String xmlFilePath) { SAXReader reader = new SAXReader(); Docum ent docum ent = null; try { InputStream in =TestDom4j.class.getResourceAsStream(xmlFilePath); docum ent =reader.read(in); } catch (Docum entException e) { System.out.println(e.getMessage()); System.out.println("读取classpath下xmlFileName文件发生异常,请检查CL ASSPATH和文件名是否存在!"); e.printStackTrace(); }

JaxbContext生成xml文件或java类对象转化注解

JAXB(Java API for XML Binding),提供了一个快速便捷的方式将Java对象与XML进行转换。在JAX-WS(Java的WebService规范之一)中,JDK1.6 自带的版本JAX-WS2.1,其底层支持就是JAXB。 JAXB 可以实现Java对象与XML的相互转换,在JAXB中,将一个Java对象转换为XML 的过程称之为Marshal,将XML转换为Java对象的过程称之为UnMarshal。我们可以通过在Java 类中标注注解的方式将一个Java对象绑定到一段XML,也就是说,在Java类中标注一些注解,这些注解定义了如何将这个类转换为XML,怎么转换,以及一段XML如何被解析成这个类所定义的对象;也可以使用JAXB的XJC工具,通过定义schema的方式实现Java 对象与XML的绑定(这个下次研究)。 下面来了解一下如何通过标注注解来完成 Marshal 和 UnMarshal 的过程。我用的是JAXB2_20101209.jar ,可以到[url]https://www.360docs.net/doc/5012329146.html,/[/url] 下载最新版本。 首先看个小例子 定义一个java类 Java代码 package com.why.jaxb; import javax.xml.bind.annotation.XmlRootElement; @XmlRootElement public class People { public String id = "001"; public String name = "灰太狼"; public int age = 26; } Java To XML(Marshal) Java代码 package com.why.jaxb; import javax.xml.bind.JAXBContext; import javax.xml.bind.JAXBException; import javax.xml.bind.Marshaller; public class Java2XML { /** * @param args * @throws JAXBException */ public static void main(String[] args) throws JAXBException { JAXBContext context = JAXBContext.newInstance(People.class);

java_Dom4j解析XML详解

学习:Dom4j 1、DOM4J简介 DOM4J是https://www.360docs.net/doc/5012329146.html, 出品的一个开源XML 解析包。DOM4J应用于Java 平台,采用了Java 集合框架并完全支持DOM,SAX 和JAXP。 DOM4J 使用起来非常简单。只要你了解基本的XML-DOM 模型,就能使用。 Dom:把整个文档作为一个对象。 DOM4J 最大的特色是使用大量的接口。它的主要接口都在org.dom4j里面定义:

接口之间的继承关系如下: interface https://www.360docs.net/doc/5012329146.html,ng.Cloneable interface org.dom4j.Node interface org.dom4j.Attribute interface org.dom4j.Branch interface org.dom4j.Document interface org.dom4j.Element interface org.dom4j.CharacterData interface org.dom4j.CDATA interface https://www.360docs.net/doc/5012329146.html,ment interface org.dom4j.Text interface org.dom4j.DocumentType interface org.dom4j.Entity interface org.dom4j.ProcessingInstruction 2、XML文档操作1 2.1、读取XML文档: 读写XML文档主要依赖于org.dom4j.io包,有DOMReader和SAXReader两种方式。因为利用了相同的接口,它们的调用方式是一样的。 public static Docum ent load(String filenam e) { Document docum ent =null; try { SAXReader saxReader = new SAXReader(); docum ent =saxReader.read(new File(filename)); //读取XML文件,获得docum ent 对象 } catch (Exception ex) { ex.printStackTrace();

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的形式。 可以设置几个同名的根节点(username1<username2) 解析时通过Elment的.elementIterator("user");方法得到迭代器 ) 解析xml 1:通过new SAXReader();得到SAXReader的一个实例 2:通过StringReader(参数是字符串)将xml字符串转化为一个Reader字符输入流 3:通过SAXReader的实例.read(参数是个Reader)得到得到Document 4:通过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文件。结果是下面的形式

JavaXML绑定技术样本

Java XML绑定技术 --- 快速操作XML文档 注: 本文系原创, 转载请注明作者 -------- 叶瑞金 /06/10 在开发中, 我们常见XML来存储一些数据。相对于普通的文本文件, XML具 有开放性、支持多语言编码、支持结构性数据等优越性, 我们常见它存储配置 信息, 甚至直接使用它当作数据库使用。 最近由于项目需要, 我对Java XML绑定技术作了些研究, 现在把一些心得 与大家分享一下。 其实用Java读写XML的技术由来已久, 比如Apache的XML API、 xalan、 xerces都是很出名的项目, 都有将近十多年历史了吧。这些API对XML的操作 都是基于XML最底层的DOM和SAX模式, 原来也不算很复杂。我在以前项目中很 多关于配置文件的管理部分都是用这些API来完成的。但不论是用DOM还是SAX, 都要求XML的格式是预先定义好的。也就是说, 如果你已经写好了一份读写XML 的程序, 之后如果这个XML的格式作了修改, 那么你必须修改程序, 以保证能 够正确地从修改后的XML中读写数据。如果XML的格式很复杂, 或者牵涉的XML 文件类型众多, 那么这种修改将是一个浩大的工程。 如果我们能找到一种自动适应XML格式的方法, 能够根据当前XML的格式定 义, 自动地读写XML中的数据, 那么就能够节省我们很多精力和时间。能够把这 种技术称为XML绑定技术(XML Binding), 或者称为Object XML。真的有这样的 程序或框架吗? 我们能够用下面的图示来描述Java XML绑定技术: Person <----------------------------> |----- id<----------------------------> 123 |___ name<----------------------------> tom

XML的四种解析器(dom,sax,jdom,dom4j)原理及性能比较[收藏]

1)DOM(JAXP Crimson解析器) DOM是用与平台和语言无关的方式表示XML文档的官方W3C标准。DOM 是以层次结构组织的节点或信息片断的集合。这个层次结构允许开发人员在树中寻找特定信息。分析该结构通常需要加载整个文档和构造层次结构,然后才能做任何工作。由于它是基于信息层次的,因而DOM被认为是基于树或基于对象的。DOM以及广义的基于树的处理具有几个优点。首先,由于树在内存中是持久的,因此可以修改它以便应用程序能对数据和结构作出更改。它还可以在任何时候在树中上下导航,而不是像SAX那样是一次性的处理。DOM使用起来也要简单得多。 2)SAX SAX处理的优点非常类似于流媒体的优点。分析能够立即开始,而不是等待所有的数据被处理。而且,由于应用程序只是在读取数据时检查数据,因此不需要将数据存储在内存中。这对于大型文档来说是个巨大的优点。事实上,应用程序甚至不必解析整个文档;它可以在某个条件得到满足时停止解析。一般来说,SAX还比它的替代者DOM快许多。 选择DOM还是选择SAX?对于需要自己编写代码来处理XML文档的开发人员来说,选择DOM还是SAX解析模型是一个非常重要的设计决策。DOM 采用建立树形结构的方式访问XML文档,而SAX采用的事件模型。 DOM解析器把XML文档转化为一个包含其内容的树,并可以对树进行遍历。用DOM解析模型的优点是编程容易,开发人员只需要调用建树的指令,然

后利用navigation APIs访问所需的树节点来完成任务。可以很容易的添加和修改树中的元素。然而由于使用DOM解析器的时候需要处理整个XML文档,所以对性能和内存的要求比较高,尤其是遇到很大的XML文件的时候。由于它的遍历能力,DOM解析器常用于XML文档需要频繁的改变的服务中。 SAX解析器采用了基于事件的模型,它在解析XML文档的时候可以触发一系列的事件,当发现给定的tag的时候,它可以激活一个回调方法,告诉该方法制定的标签已经找到。SAX对内存的要求通常会比较低,因为它让开发人员自己来决定所要处理的tag。特别是当开发人员只需要处理文档中所包含的部分数据时,SAX这种扩展能力得到了更好的体现。但用SAX解析器的时候编码工作会比较困难,而且很难同时访问同一个文档中的多处不同数据。 3)JDOM https://www.360docs.net/doc/5012329146.html,/ JDOM的目的是成为Java特定文档模型,它简化与XML的交互并且比使用DOM实现更快。由于是第一个Java特定模型,JDOM一直得到大力推广和促进。正在考虑通过“Java规范请求JSR-102”将它最终用作“Java标准扩展”。从2000年初就已经开始了JDOM开发。 JDOM与DOM主要有两方面不同。首先,JDOM仅使用具体类而不使用接口。这在某些方面简化了API,但是也限制了灵活性。第二,API大量使用了Collections类,简化了那些已经熟悉这些类的Java开发者的使用。

java对象直接转换成xml格式

java对象直接转换成xml格式! import java.io.StringWriter;import javax.xml.bind.JAXBContext; import javax.xml.bind.JAXBException; import javax.xml.bind.Marshaller; import javax.xml.bind.annotation.XmlRootElement;@XmlRootEle ment(name = "Test") public class Test { private String id; private String name; public String getId() { return id; } public void setId(String id) {

this.id = id; } public String getName() { return name; } public void setName(String name) { https://www.360docs.net/doc/5012329146.html, = name; } public static void main(String[] args) throws JAXBException { Test re = new Test(); re.setId("id"); re.setName("name"); StringWriter sw = new StringWriter(); JAXBContext jAXBContext = JAXBContext.newInstance(re.getClass());

org.w3c.dom(java dom)解析XML文档

位于org.w3c.dom操作XML会比较简单,就是将XML看做是一颗树,DOM就是对这颗树的一个数据结构的描述,但对大型XML文件效果可能会不理想 首先来了解点Java DOM 的API: 1.解析器工厂类:DocumentBuilderFactory 创建的方法:DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); 2.解析器:DocumentBuilder 创建方法:通过解析器工厂类来获得DocumentBuilder db = dbf.newDocumentBuilder(); 3.文档树模型Document 创建方法:a.通过xml文档 Document doc = db.parse("bean.xml"); b.将需要解析的xml文档转化为输入流InputStream is = new FileInputStream("bean.xml"); Document doc = db.parse(is); Document对象代表了一个XML文档的模型树,所有的其他Node都以一定的顺序包含在Document对象之内,排列成一个树状结构,以后对XML文档的所有操作都与解析器无关, 直接在这个Document对象上进行操作即可; 包含的方法:

4.节点列表类NodeList NodeList代表了一个包含一个或者多个Node的列表,根据操作可以将其简化的看做为数组 5.节点类Node

Node对象是DOM中最基本的对象,代表了文档树中的抽象节点。但在实际使用中很少会直接使用Node对象,而是使用Node对象的子对象Element,Attr,Text等 6.元素类Element 是Node类最主要的子对象,在元素中可以包含属性,因而Element中有存取其属性的方法

XML创建与解析常用方法介绍

XML解析方式介绍 1.DOM4J(Document Object Model for Java) 虽然DOM4J代表了完全独立的开发结果,但最初,它是JDOM的一种智能分支。它合并了许多超出基本XML文档表示的功能,包括集成的XPath支持、XML Schema支持以及用于大文档或流化文档的基于事件的处理。它还提供了构建文档表示的选项,它通过DOM4J API和标准DOM接口具有并行访问功能。从2000下半年开始,它就一直处于开发之中。 为支持所有这些功能,DOM4J使用接口和抽象基本类方法。DOM4J大量使用了API中的Collections 类,但是在许多情况下,它还提供一些替代方法以允许更好的性能或更直接的编码方法。直接好处是,虽然DOM4J付出了更复杂的API的代价,但是它提供了比JDOM大得多的灵活性。 在添加灵活性、XPath集成和对大文档处理的目标时,DOM4J的目标与JDOM是一样的:针对Java 开发者的易用性和直观操作。它还致力于成为比JDOM更完整的解决方案,实现在本质上处理所有Java/XML问题的目标。在完成该目标时,它比JDOM更少强调防止不正确的应用程序行为。 DOM4J是一个非常非常优秀的Java XML API,具有性能优异、功能强大和极端易用使用的特点,同时它也是一个开放源代码的软件。如今你可以看到越来越多的Java软件都在使用DOM4J来读写XML,特别值得一提的是连Sun的JAXM也在用DOM4J. 【优点】 ①大量使用了Java集合类,方便Java开发人员,同时提供一些提高性能的替代方法。 ②支持XPath。 ③有很好的性能。 【缺点】 ①大量使用了接口,API较为复杂。 2.SAX(Simple API for XML) SAX处理的优点非常类似于流媒体的优点。分析能够立即开始,而不是等待所有的数据被处理。而且,由于应用程序只是在读取数据时检查数据,因此不需要将数据存储在内存中。这对于大型文档来说是个巨大的优点。事实上,应用程序甚至不必解析整个文档;它可以在某个条件得到满足时停止解析。一般来说,SAX还比它的替代者DOM快许多。 选择DOM还是选择SAX?对于需要自己编写代码来处理XML文档的开发人员来说,选择DOM还是SAX解析模型是一个非常重要的设计决策。 DOM采用建立树形结构的方式访问XML文档,而SAX 采用的是事件模型。

java读写xml文件的方法

在java环境下读取xml文件的方法主要有4种:DOM、SAX、JDOM、JAXB 1. DOM(Document Object Model) 此方法主要由W3C提供,它将xml文件全部读入内存中,然后将各个元素组成一棵数据树,以便快速的访问各个节点。因此非常消耗系统性能,对比较大的文档不适宜采用DOM方法来解析。 DOM API 直接沿袭了 XML 规范。每个结点都可以扩展的基于 Node 的接口,就多态性的观点来讲,它是优秀的,但是在Java 语言中的应用不方便,并且可读性不强。 实例: Java代码 1.import javax.xml.parsers.*; 2.//XML解析器接口 3.import org.w3c.dom.*; 4.//XML的DOM实现 5.import org.apache.crimson.tree.XmlDocument; 6.//写XML文件要用到 7.DocumentBuilderFactory factory = DocumentBuilderFactory.newInst ance(); 8. //允许名字空间 9. factory.setNamespaceAware(true); 10. //允许验证 11. factory.setValidating(true); 12. //获得DocumentBuilder的一个实例 13.try { 14. DocumentBuilder builder = factory.newDocumentBuilder(); 15.} catch (ParserConfigurationException pce) { 16.System.err.println(pce); 17.// 出异常时输出异常信息,然后退出,下同 18.System.exit(1); 19.} 20.//解析文档,并获得一个Document实例。 21.try { 22.Document doc = builder.parse(fileURI); 23.} catch (DOMException dom) { 24.System.err.println(dom.getMessage()); 25.System.exit(1); 26.} catch (IOException ioe) { 27.System.err.println(ioe); 28.System.exit(1); 29.}

JAVA生成XML文件

package com.inspur.test; import java.io.File; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.OutputStream; import org.jdom.Document; import org.jdom.Element; import org.jdom.output.Format; import org.jdom.output.XMLOutputter; public class FileDemo { /** *@param args */ public static void main(String[] args) { // TODO Auto-generated method stub String filename="c:\\text.xml"; File file=new File(filename); /** *判断文件是否存在.如果文件不存在则生成一个文件 *则生成一个文件;反之则先删除原有文件,生成一个新的文件 */ if(file.exists()){ try { file.delete(); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } try { file.createNewFile(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } //创建根节点 Element root=new Element("ObjFlow"); //根节点添加到文档中 Document document=new Document(root); //添加工单基本信息 //创建工单基本信息的节点 Element baseinfo=new Element("BaseInfo"); //创建工单编号节点 Element formOid=new Element("formOid"); //添加工单编号节点内容 formOid.setText("工单编号"); //将工单编号节点添加到基本信息节点下

使用DOM4j解析xml文件

Xml文件: studentname 78 78 98 studentname 77 68 88 JAVA文件: import java.io.File; import java.io.FileWriter; import java.io.IOException; import java.util.Iterator; import java.util.List; import org.dom4j.Attribute; import org.dom4j.Document; import org.dom4j.DocumentException; import org.dom4j.DocumentHelper; import org.dom4j.Element; import org.dom4j.io.OutputFormat; import org.dom4j.io.SAXReader; import org.dom4j.io.XMLWriter; /** *DOM4j对xml文件的操作 *操作DOM4j的时候注意要导入3个jar包,否则会报异常 *dom4j-1.6.1.jar *jaxen-1.1-beta-6.jar *saxpath.jar **/ public class ReaderDom4j {

Java解析XML文件

Java解析XML文件 ========================================== xml文件 <?xml version="1.0" encoding="GB2312"?> <RESULT> <VALUE> <NO>A1234</NO> <ADDR>四川省XX县XX镇XX路X段XX号</ADDR> </VALUE> <VALUE> <NO>B1234</NO> <ADDR>四川省XX市XX乡XX村XX组</ADDR> </VALUE> </RESULT> ========================================== 1)DOM(JAXP Crimson解析器) DOM是用与平台和语言无关的方式表示XML文档的官方W3C标准。DOM是以层次结构组织的节点或信息片断的集合。这个层次结构允许开发人员在树中寻找特定信息。分析该结构通常需要加载整个文档和构造层次结构,然后才能做任何工作。由于它是基于信息层次的,因而DOM被认为是基于树或基于对象的。DOM以及广义的基于树的处理具有几个优点。首先,由于树在内存中是持久的,因此可以修改它以便应用程序能对数据和结构作出更改。它还可以在任何时候在树中上下导航,而不是像SAX那样是一次性的处理。DOM使用起来也要简单得多。 import java.io.*; import java.util.*; import org.w3c.dom.*; import javax.xml.parsers.*; public class MyXMLReader{ public static void main(String arge[]){ long lasting =System.currentTimeMillis(); try{ File f=new File("data_10k.xml"); DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance(); DocumentBuilder builder=factory.newDocumentBuilder(); Document doc = builder.parse(f); NodeList nl = doc.getElementsByT agName("VALUE"); for (int i=0;i<nl.getLength();i++){ System.out.print("车牌号码:" +

java dom解析xml

java dom解析xml 010000 00000CC3 20100629173405 1 000001 import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import org.w3c.dom.Document; import org.w3c.dom.Element; import org.w3c.dom.NodeList; public class FileTest { /** * @param args */ public static void main(String[] args) { DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); try { DocumentBuilder db = dbf.newDocumentBuilder(); Document doc = db.parse("d:/test.xml"); //得到根节点 Element root = doc.getDocumentElement(); NodeList nl = root.getElementsByTagName("HLR"); Element e = (Element) nl.item(0); String hlrId=e.getAttribute("HlrId"); System.out.println(hlrId); }catch(Exception e){

java读取文件目录结构并生成xml树

java读取文件目录结构并生成xml树,具体实现代码如下: package org.wendong.file; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.InputStream; import java.io.Writer; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.GregorianCalendar; import org.dom4j.Document; import org.dom4j.DocumentHelper; import org.dom4j.Element; /** * 多线程读取本地文件中的所有文件目录结构及文件大小 * @author Administrator * */ public class ThreadReader extends Thread { @Override public void run() { try { Long start = System.currentTimeMillis(); String name = Thread.currentThread().getName(); System.err.println("当前线程名:"+name); File file = new File(name); Document doc = DocumentHelper.createDocument(); Element el = doc.addElement(file.getName()); el = getFile(file, el); File docFile = new File(name+"/目录结构.xml"); if(!docFile.exists()){ docFile.createNewFile(); FileOutputStream fos = new FileOutputStream(docFile); fos.write(doc.asXML().getBytes()); fos.flush(); fos.close(); } Long end = System.currentTimeMillis();

java解析XML详解

详解Java解析XML的四种方法 XML现在已经成为一种通用的数据交换格式,它的平台无关性,语言无关性,系统无关性,给数据集成与交互带来了极大的方便。对于XML本身的语法知识与技术细节,需要阅读相关的技术文献,这里面包括的内容有DOM(Document Object Model),DTD(Document Type Definition),SAX(Simple API for XML),XSD(Xml Schema Definition),XSLT(Extensible Stylesheet Language Transformations),具体可参阅w3c官方网站文档https://www.360docs.net/doc/5012329146.html,获取更多信息。 XML在不同的语言里解析方式都是一样的,只不过实现的语法不同而已。基本的解析方式有两种,一种叫SAX,另一种叫DOM。SAX是基于事件流的解析,DOM是基于XML文档树结构的解析。假设我们XML的内容和结构如下: ddviplinux m 30 本文使用JAVA语言来实现DOM与SAX的XML文档生成与解析。 首先定义一个操作XML文档的接口XmlDocument 它定义了XML文档的建立与解析的接口。 package com.alisoft.facepay.framework.bean; /** * * @author hongliang.dinghl * 定义XML文档建立与解析的接口 */ public interface XmlDocument { /** * 建立XML文档 * @param fileName 文件全路径名称 */ public void createXml(String fileName); /** * 解析XML文档 * @param fileName 文件全路径名称 */ public void parserXml(String fileName); } 1. DOM生成和解析XML文档 为 XML 文档的已解析版本定义了一组接口。解析器读入整个文档,然后构建一个驻留内存的树结构,然后代码就可以使用 DOM 接口来操作这个树结构。优点:整个文档树在内存中,便于操作;支持删除、修改、重新排列等多种功能;缺点:将整个文档调入内存(包括无用的节点),浪费时间和空间;使用场合:一旦解析了文档还需多次访问这些数据;硬件资源充足(内存、CPU)。 import java.io.FileInputStream; import java.io.FileNotFoundException;

JAVA对象转换成XML(CDATA)

JAVA对象转换成XML() 编者小结:将java对象转换成xml文件很简单,但是将java对象转换成输出结果不转义的形式就相当不易。大家都知道在XML 元素中,"<" 和"&" 是非法的。"<" 会产生错误,因为解析器会把该字符解释为新元素的开始。"&" 也会产生错误,因为解析器会把该字符解释为字符实体的开始。某些文本,比如JavaScript 代码,包含大量"<" 或"&" 字符。为了避免错误,可以将脚本代码定义为CDATA。 CDATA:在标记CDATA下,所有的标记、实体引用都被忽略,而被XML处理程序一视同仁地当作字符数据看待,CDATA的形式如下: CDATA的文本内容中不能出现字符串“]]>”,另外,CDATA不能嵌套。 具体实现过程如下: Java实体类: public class JavaDocu { private int id; private String text; public int getId() { return id; } public void setId(int id) { this.id = id; } public String getText() { return text; }

public void setText(String text) { this.text = text; } } MyXppDriver类: public class MyXppDriver extends XppDriver { public HierarchicalStreamWriter createWriter(Writer out){ return new MyPrettyPrintWriter(out); } } MyPrettyPrintWriter类: public class MyPrettyPrintWriter implements ExtendedHierarchicalStreamWriter { private final QuickWriter writer; private final FastStack elementStack = new FastStack(16); private final char[] lineIndenter; private boolean tagInProgress; private int depth; private boolean readyForNewLine; private boolean tagIsEmpty; private static final char[] AMP = "&".toCharArray(); private static final char[] LT = "<".toCharArray(); private static final char[] GT = ">".toCharArray(); private static final char[] SLASH_R = " ".toCharArray(); private static final char[] QUOT = """.toCharArray(); private static final char[] APOS = "'".toCharArray(); private static final char[] CLOSE = "

相关文档
最新文档