java读写xml文件的方法
xml基本写法和dtdschema的用法,JAVA读写XML
xml基本写法和dtdschema的⽤法,JAVA读写XML1. 标记语⾔ 标记语⾔,是⼀种⽂本(Text)以及⽂本相关的其他信息结合起来,展现出关于⽂档结构和数据处理细节的电脑⽂字编码.当今⼴泛使⽤的标记语⾔是超⽂本标记语⾔(Hyper Text Markup Language,HTML)和可扩展标记语⾔(eXtensible Markup Language,XML). 标记语⾔⼴泛应⽤于⽹页和⽹络应⽤程序.1) 超⽂本标记语⾔HTML(Hyper Text Markup Language)写法格式: <a href="link.html">link</a>关注数据的展⽰与⽤户体验标记是固定的,不可扩展(如<a></a>表⽰超连接)2) 可扩展的标记语⾔XML(eXtensible Markup Language)写法格式:同html样式<a>link</a>仅关注数据本⾝标记可扩展,可⾃定义3) Xml 和 Html语⾔由同⼀种⽗语⾔SGML(Standard Generalized Markup language,标准通⽤标记语⾔)发展出来.4)解析器专业解析器(⽐如:XML SPY 专⽤于解析XML⽂件)浏览器MyEclipse5)W3C(World Wide Web Consortium)W3C:开源的语⾔协会,万维⽹联盟(World Wide Web Consortium)HTML 和 XML 都是W3C制定的语⾔规则官⽹:学习⽹站:2.xml语法规则2.1 xml的声明:xml的声明必须写在⽂件第⼀⾏Encoding(字符集)属性可以省略,默认的字符集是utf-8例⼦:1<?xml version="1.0" encoding="UTF-8"?>2<书>3<武侠⼩说 isbn="1001">4<书名>天龙⼋部</书名>5<作者>⾦庸</作者>6<价格>50</价格>7<简介>⼀本好书</简介>8</武侠⼩说>9<计算机>10<书名>疯狂java</书名>11<作者>李刚</作者>12<价格>50</价格>13<简介>⼀本好书</简介>14</计算机>15</书>常见错误写法:1) "?"和xml之间不能有空格2) 声明必须顶头写,不能有空⾏或空格(⽤FireFox浏览器打开)3) 等号左右不要多写空格(java程序员的习惯)浏览器不会报错,但是在xml解析时会出问题2.2 标记1)诸如<书名></书名>,这样格式的被称为标记2)标记必须成对出现3)标记包含开始标记和结束标记<书名>天龙⼋部</书名>注意:标记⼤⼩写敏感2.3元素(Element)1) 元素: 元素= 标记 + 其中内容 ,如<书名>天龙⼋部</书名>2) 根元素: 最外层的元素 (如 <书></书>)3) 叶⼦元素: 最⾥层(没有⼦元素的)的元素 (如,<书名></书名>,<价格></价格>)4) 空元素: 没有内容的元素叫空元素,⽐如:<a></a> ,<br></br>,可以简写为<a/> <br/>5) 元素必须遵循的语法规则a. 所有的标记都必须有结束b.开始标记和结束标记必须成对出现c.元素必须正确嵌套<a><b>c</b></a> (正确)<a><b>c</a></b> (错误)d.标记的⼤⼩写敏感Hello 和 hello不是同⼀个标记e.有且只能有⼀个根元素2.4 实体引⽤(转义字符)1) ⼩于号(<) : less then --> <2) ⼤于号(>) : great than --> >3) And符号(&) : &4) 双引号 ( ") : "5) 单引号( ') : '注意这些转义字符都是以&开头,以 ; 结尾例如:想给天龙⼋部加上书名号<<天龙⼋部>><?xml version="1.0" encoding="UTF-8"?><书><武侠⼩说 isbn="1001"><书名><<天龙⼋部>></书名><作者>⾦庸</作者><价格>50</价格><简介>⼀本好书</简介></武侠⼩说></书>2.5属性(定义在开始标记中的键值对)1)格式: 属性="属性值"如<武侠⼩说 isbn="1234"></武侠⼩说>isbn是武侠⼩说的属性,值是12342)要求:属性必须有值属性值必须⽤引号引起来,单引号或双引号都可以,但必须⼀致2.6 CDATA 类型的数据:特殊标签1) 格式: <![CDATA[⽂本内容]]>2) 特殊标签中的实体引⽤都被忽略,所有内容被当成⼀整块⽂本数据对待例如<书><武侠⼩说 isbn="1235" lang="zh"><书名 hot="true">笑笑江湖</书名><作者>⾦庸</作者><价格>45</价格><简介><![CDATA[⼀本好书,没有<<笑傲江湖>>好看]]></简介></武侠⼩说></书>2.8 注释(xml和html相同)1)格式: <!-- 这是⼀段注释 -->2) 编译器将忽略注释3) Html和xml注释⽅式相同例⼦:1<?xml version="1.0" encoding="UTF-8"?>2<书>3<!-- 这是⼀段注释 -->4<武侠⼩说 isbn="1001">5<书名><<天龙⼋部>></书名>6<作者>⾦庸</作者>7<价格>50</价格>8<简介>⼀本好书</简介>9</武侠⼩说>10</书>2.8 规则⼩结1) 必须有唯⼀的根元素2) xml标记⼤⼩写敏感3) 标记必须配对出现,有开始有结束4) 元素必须被正确嵌套5) 属性必须有值,值必须⽤引号引起来6) 如果遵循全部上述规则,称作well-formed⽂件(格式良好的xml⽂件) 2.9 使⽤XML⽂件描述数据的例⼦1) 早期属性⽂件描述数据的⽅式url = jdbd:oracle:thin@192.168.0.205:1521:dbsiddbUser = openlabdbPwd = open1232) 现在使⽤xml表⽰⽅式<?xml version="1.0" encoding="UTF-8"?><书><!-- 这是⼀段注释 --><武侠⼩说 isbn="1001"><书名><<天龙⼋部>></书名><作者>⾦庸</作者><价格>50</价格><简介>⼀本好书</简介></武侠⼩说></书>3. DTD/Schema1) DTD/Schema:⽤来规范XML的标记规则2)有效的xml⽂件(valid xml file) = 格式良好的xml⽂件 + 有DTD或Schema规则 + 遵循DTD或Schema规则3.1 DTD/Schema的作⽤⾏业交换数据时要求xml⽂件格式相同,所以需要⼤家遵守规范的xml⽂件格式,⽐如两份xml⽂件要有相同的元素嵌套关系,相同的属性定义,相同的元素顺序,元素出现相同次数等3.2⽂档类型定义DTD(Document Type Difinition)1) DTD⽂档⽤来定义XML⽂件的格式,约束XML⽂件中的标记规则2) DTD类型PUBLIC(⾏业共⽤的)SYSTEM(⼩范围⾃定义的)3.2.1 DTD中的定义规则必须列出所有节点,⼀个都不能少1)元素"*"星号表⽰可以出现0-n次"+"加号表⽰可以出现1-n次"|" 表⽰或(只能出现⼀个)如(phone|mobile)表⽰固话或⼿机⼆选⼀"?"问号: 表⽰出现0或1此#PCDATA 表⽰字符串2)属性:定义在开始标记中的键值对dtd 规则_属性1) <!ATTLIST 标记名称属性名称属性类型>2) isbn CDATA #REQUIRED: 表⽰isbn属性是必须的3) isbn CDATA #IMPLIED: 表⽰isbn属性不是必须的4) hot CDATA"false" :表⽰hot默认值是false例⼦3.2.1⾸先是dtd⽂件book.dtd<!ELEMENT 书 (武侠⼩说, br)*><!ELEMENT 武侠⼩说 (书名,作者+,价格,简介)><!ELEMENT 书名 (#PCDATA)><!ELEMENT 作者 (#PCDATA)><!ELEMENT 价格 (#PCDATA)><!ELEMENT 简介 (#PCDATA)><!ELEMENT br EMPTY><!ATTLIST 武侠⼩说 isbn CDATA #REQUIREDlang CDATA #IMPLIED><!ATTLIST 书名 hot CDATA #IMPLIED>在XML中使⽤<?xml version="1.0"?><!DOCTYPE 书 SYSTEM "book.dtd"><书><武侠⼩说 isbn="1234" lang="zh"><书名 hot="false"><<天龙⼋部>></书名><作者>⾦庸</作者><作者>古龙</作者><价格>45</价格><简介>⼀本好书</简介></武侠⼩说><br></br><武侠⼩说 isbn="1235" lang="zh"><书名 hot="true">笑笑江湖</书名><作者>⾦庸</作者><价格>45</价格><简介><!-- 这是⼀段注释 --><![CDATA[⼀本好书,没有<<笑傲江湖>>好看CDATA中的所有特殊字符都不解释(原样显⽰)]]></简介></武侠⼩说><br></br></书>3.3 Schema ,DTD的升级版与DTD的区别1)命名空间(NameSpace)XML⽂件允许⾃定义标记,所以可能出现来⾃不同源DTD或Schema⽂件的同名标记,为了区分这些标记,就需要使⽤命名空间.命名空间的⽬的是有效的区分来⾃不同DTD的相同标记⽐如xml中⽂件中使⽤了命名空间区分开"表格"和"桌则":<html:table><line><column>这是⼀个表格</column></line></html;table><product:table><type>coff table</type><product:table>2) 因为DTD⽆法解决命名冲突,所以出现Schema,它是DTD 的替代者,dtd和Schema的功能都是描述xml结构的3) Schema使⽤xml语法实现(Schema本⾝就是xml⽂件)因为⽤于规范和描述xml⽂件的定义⽂件(schema)本⾝也是xml⽂件,所也xml也被称为⾃描述的语⾔4) Schema ⽂件的扩展名xds: XML Schema Difinition(简称XSD,遵循W3C标准)5) Schema中的名词:复杂元素(有⼦元素的元素)简单元素(叶⼦元素)例⼦:email.xsd<?xml version="1.0" encoding="UTF-8"?><schema xmlns="/2001/XMLSchema" targetNamespace="/email" xmlns:tns="/email" elementFormDefault="qualified"> <element name="email"><complexType><sequence><element name="from" type="string"/><element name="to" type="string"/><element name="subject" type="string"/><element name="body" type="string"/></sequence></complexType></element></schema>被规范的⽂件email.xml<?xml version="1.0" encoding="UTF-8"?><tns:email xmlns:tns="/email" xmlns:xsi="/2001/XMLSchema-instance" xsi:schemaLocation="/email email.xsd "><tns:from>赵敏</tns:from><tns:to>张⽆忌</tns:to><tns:subject>HIHI</tns:subject><tns:body>看泰坦尼克号</tns:body></tns:email>3.4 根据DTD或者Schema来写xml⽂件的⽅法在MyEclipse中右键New --> xml (Basic Templates) -->输⼊⽂件名-->next-->选择是DTD还是Schema4. java API 解析XML⽂件(读xml⽂件)1) Java 与xml有很多共同点(⽐如跨平台,与⼚商⽆关),⽬前位置java对xml的解析较其他语⾔更完善2) 两种解析⽅式:DOM(Document Object Model ⽂档对象模型)关键字:树(Document)优点: 把xml⽂件在内存中构造树形结构,可以遍历和修改节点缺点: 如果⽂件⽐较⼤,内存有压⼒,解析的时间会⽐较长SAX(Simple API for Xml基于XML的简单API)关键字:流(Stream)把xml⽂件作为输⼊流,触发标记开始,内容开始,标记结束等动作优点:解析可以⽴即开始,速度快,没有内存压⼒缺点:不能对节点做修改3) JDOM/DOM4J : ⽬前市场上常⽤的两种解析XML⽂件的API dom4j-1.6.1.jar 结合了DOM和SAX两种解析⽅式的优点DOM4j解析xml⽂件步骤1) 创建项⽬XMLDemo2) 加⼊dom4j的jar包(dom4j-1.6-1.jar)3) 将要解析的xml⽂件放在路径src/下4) 新建ReadXMLDemo.java4-1)构造document对象SAXReader reader = new SAXReader();Document doc = reader.read(file);4-2)取根元素:Element root = doc.getRootElement();4-3)常⽤⽅法Element elmt;elmt.elements("标记名称"):取出所有指定标记名称的元素elmt.element("标记名称"):取出第⼀个指定标记名称元素elmt.elementText("标记名称"):取elmt指定名字的⼦元素elmt.getText();取当前元素的内容Iterator it = elmt.elementsIterator("标记名称") 返回⼀个Iterator String 属性值 = elmt.attattributeValue("属性名")例⼦:ReadBookdemo源代码package day1;import java.io.*;import java.util.*;import org.dom4j.*;import org.dom4j.io.*;/*** 读⼊book.xml⽂件,取出数据并打印* @author soft01**/public class ReadBookdemo {public static void main(String[] args) {readBook("book.xml");}/*** 读⼊指定的xml⽂件,取出数据并打印* @param string*/private static void readBook(String filename) {//1..读⼊指定的⽂件,构造Document对象File file = new File(filename);SAXReader reader = new SAXReader();//XML⽂件解析器try {Document doc = reader.read(file);//解析器开始解析xml⽂件//2.获得根元素Element root = doc.getRootElement();//3.递归搜索⼦元素/* List<Element> list = root.elements("武侠⼩说");//迭代武侠⼩说的元素集合Iterator<Element> it = list.iterator(); */Iterator<Element> it = root.elementIterator("武侠⼩说");while(it.hasNext()){Element bookElmt = it.next(); //bookEmlt是武侠⼩说元素//取武侠⼩说的⼦元素System.out.println(bookElmt.elementText("书名"));//取⼦元素书名的内容 List<Element> authorList = bookElmt.elements("作者");for (Element element : authorList) {//打印作者元素内容System.out.println(element.getText());}System.out.println(bookElmt.elementText("价格"));System.out.println(bookElmt.elementText("简介"));//取武侠⼩说的属性String isbnValue = bookElmt.attributeValue("isbn");//取武侠⼩说的 lang元素String langValue = bookElmt.attributeValue("lang");System.out.println("isbn="+isbnValue);System.out.println("lang="+langValue);//取⼦元素中的属性Element nameElmt = bookElmt.element("书名");System.out.println(nameElmt.attributeValue("hot"));System.out.println("-----------------");}} catch (DocumentException e) {e.printStackTrace();}}}book.xml如下<?xml version="1.0"?><书><武侠⼩说 isbn="1234" lang="zh"><书名 hot="false"><<天龙⼋部>></书名><作者>⾦庸</作者><作者>古龙</作者><价格>45</价格><简介>⼀本好书</简介></武侠⼩说><br></br><武侠⼩说 isbn="1235" lang="zh"><书名 hot="true">笑笑江湖</书名><作者>⾦庸</作者><价格>45</价格><简介><!-- 这是⼀段注释 --><![CDATA[⼀本好书,没有<<笑傲江湖>>好看CDATA中的所有特殊字符都不解释(原样显⽰)]]></简介></武侠⼩说><br></br></书>5 DOM4j API解析XML⽂件(⽣成)1)常⽤API⽅法:给元素增加⼦元素: elmt.addElement("标记名称");给元素增加属性: elmt.addAttribute("属性名","属性值");给叶⼦元素设值: elmt.setText("元素值");例如:要⽣成以下xml⽂件<book isbn="1001" catalog = "科幻"><name>阿⾥波特</name><author>罗林</author><price>60</price><year>2005</year></book>步骤:1.构造空的Document2.构造根元素3.递归构造⼦元素4.输出WriteBookDemo源代码package day1;import java.io.*;import org.dom4j.*;import org.dom4j.io.*;/*** 利⽤DOM4J写出xml⽂件* @author soft01**/public class WriteBookDemo {static String [][] data={{"1001", "科幻", "阿⾥波特", "罗林","60", "2005","en"},{"1002", "迷幻", "⼩波特", "罗4林","60", "2005","zh"},{"1003", "⽞幻", "中波特", "罗3林","60", "2005","en"},{"1004", "奇幻", "⼤波特", "罗2林","60", "2005","zh"}};public static void main(String[] args) {writeBook("mybook.xml");}/*** 把书的数据⽣成到指定名字的xml⽂件中* @param filename*/public static void writeBook(String filename){// 1.构造空的DocumentDocument doc = DocumentHelper.createDocument();// 2.构造根元素Element rootElmt = doc.addElement("booklist");// 3.递归构造⼦元素for(String[] book:data){Element bookElmt = rootElmt.addElement("book");//book 元素增加属性bookElmt.addAttribute("isbn", book[0]);bookElmt.addAttribute("catalog", book[1]);Element nameElmt = bookElmt.addElement("name");nameElmt.setText(book[2]);//给name 加属性nameElmt.addAttribute("lang", book[6]);Element authorElmt = bookElmt.addElement("author");authorElmt.setText(book[3]);Element priceElmt = bookElmt.addElement("price");priceElmt.setText(book[4]);Element yearElmt = bookElmt.addElement("year");yearElmt.setText(book[5]);}// 4.输出outputXml(doc,filename);}public static void outputXml(Document doc,String filename){try {//定义输出流的⽬的地FileWriter fw = new FileWriter(filename);//定义输出格式和字符集OutputFormat format = OutputFormat.createPrettyPrint();format.setEncoding("UTF-8");//定义⽤于输出xml⽂件的XMLWriter对象XMLWriter xmlWriter = new XMLWriter(fw,format);xmlWriter.write(doc);xmlWriter.close();} catch (IOException e) {e.printStackTrace();}}}注意:运⾏程序⽣成的mybooks.xmlpackage day1;不⾃动装载,需要刷新⼀下程序运⾏通过后,在项⽬上点击右键"refreash"(或F5)如果是从别的⼯作区导⼊的项⽬,需要去别的⼯作区⽬录下找⽣成的XML⽂件6XPath(w3c的标准)1) XPath:在XML⽂件中查找或定位信息的语⾔,相当于SQL中的 selectXPath 可以通过元素/属性/值来定位或导航2) 节点(Node):相当于xml⽂件中的元素3) 指定条件定位元素的⽅式例⼦:package day1;import java.io.*;import java.util.*;import org.dom4j.*;import org.dom4j.io.*;/*** 测试XPath的功能* @author soft01**/public class XPathDemo {public static void main(String[] args) {findBook("mybook.xml");}public static void findBook(String filename){SAXReader reader = new SAXReader();try {//获得⽂档对象Document doc = reader.read(new File(filename));Node node =doc.selectSingleNode("/booklist");//查找所有的catalog="奇幻"的书2//String sql = "book[@catalog ='奇幻']";//价格>50的书//String sql = "book[price>50]";//作者等于罗林的书,并且价格⼤于50//String sql ="book[author='罗林' and price>50]";//价格⼤于50,且语⾔是zhString sql = "book[price>50 and name[@lang='zh']]"; List<Element> books = node.selectNodes(sql);for(Element e:books){System.out.println(e.getStringValue());}} catch (DocumentException e) {e.printStackTrace();}}}。
java读取xml文件内容
java读取xml⽂件内容xml⽂件<?xml version="1.0" encoding="UTF-8"?><Object><student><stuName>张三</stuName><stuAddress>郑州</stuAddress><stuTel>111</stuTel></student><user><userName>aaa</userName><userAge>100</userAge><userSex>男</userSex></user><book><bookName>语⽂</bookName><bookAuthor>XXX</bookAuthor><bookPrice>100</bookPrice></book></Object>操作⽅法package com.xml;import java.io.File;import .URL;import java.util.List;import org.dom4j.Document;import org.dom4j.DocumentException;import org.dom4j.Element;import org.dom4j.io.SAXReader;import com.bean.Book;import com.bean.Student;import er;public class SaxXml {public static void main(String[] args) throws Exception {//File file=new File("config/student.xml");//获取dom树URL url=SaxDbXml.class.getClassLoader().getResource("student.xml");SAXReader sax=new SAXReader();//Document dom=sax.read(file);Document dom = sax.read(url);//获取dom树⾥⾯的根节点Element rootEle=dom.getRootElement();//获取根节点下的节点元素List<Element> eleList=rootEle.elements();//System.out.println(eleList.size());a//循环获取每个节点元素for(int i=0;i<eleList.size();i++){Element childEle=eleList.get(i);String name=childEle.getName();if(name.equalsIgnoreCase("student")){Student stu=new Student();//获取节点下⾯的⼦节点List<Element> childList=childEle.elements();for(int j=0;j<childList.size();j++){Element ele=childList.get(j);String eleName=ele.getName();if(eleName.equalsIgnoreCase("stuName")){stu.setStuName(ele.getText());//System.out.println(ele.getText());}else if(eleName.equalsIgnoreCase("stuAddress")){stu.setStuAddress(ele.getText());}else if(eleName.equalsIgnoreCase("stuTel")){stu.setStuTel(ele.getText());}}}else if(name.equalsIgnoreCase("user")){User user=new User();//获取⼦节点元素List<Element> userList=childEle.elements();for(int k=0;k<userList.size();k++){Element userEle=userList.get(k);//判断⼦节点元素的名称,进⾏相应的存值if(userEle.getName().equalsIgnoreCase("userName")){user.setUserName(userEle.getText());}else if(userEle.getName().equalsIgnoreCase("userSex")){ user.setUserSex(userEle.getText());}else if(userEle.getName().equalsIgnoreCase("userAge")){ user.setUserAge(userEle.getText());}}}else if(name.equalsIgnoreCase("book")){Book book=new Book();List<Element> bookList=childEle.elements();for(int k=0;k<bookList.size();k++){Element bookEle=bookList.get(k);String eleName=bookEle.getName();if(eleName.equalsIgnoreCase("bookName")){book.setBookName(bookEle.getText());}else if(eleName.equalsIgnoreCase("bookAuthor")){book.setBookAuthor(bookEle.getText());}else if(eleName.equalsIgnoreCase("bookPrice")){book.setBookPrice(bookEle.getText());}}}}}}。
java实现利用String类的简单方法读取xml文件中某个标签中的内容
java实现利⽤String类的简单⽅法读取xml⽂件中某个标签中的内容1、利⽤String类提供的indexOf()和substring()快速的获得某个⽂件中的特定内容public static void main(String[] args) {// 测试某个词出现的位置String reqMessage = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>" + "<in>" + "<head>" + "<Version>1.0.1</Version>"+ "<InstId>100000000000032</InstId>" + "<AnsTranCode>BJCEBQBIReq</AnsTranCode>" + "<TrmSeqNum>2012082008200931036344</TrmSeqNum>" + "</head>" + "</in>";int indexbegin = reqMessage.indexOf("<TrmSeqNum>");int indexend = reqMessage.indexOf("</TrmSeqNum>");System.out.println("<TrmSeqNum>的位置===" + indexbegin);System.out.println("</TrmSeqNum>的位置===" + indexend);System.out.println(reqMessage.substring(indexbegin + 11, indexend)); // 11是<TrmSeqNum>这个字符串的长度}以上这篇java实现利⽤String类的简单⽅法读取xml⽂件中某个标签中的内容就是⼩编分享给⼤家的全部内容了,希望能给⼤家⼀个参考,也希望⼤家多多⽀持。
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技术,可以用来实现大量复杂的数据存储和交互。
读写XML的四种方法
读写XML的四种方法XML(eXtensible Markup Language)是一种用于表示和传输数据的标记语言。
它具有良好的可读性和扩展性,被广泛应用于Web开发、数据交换和配置文件等领域。
在读写和处理XML数据时,有许多方法可供选择。
本文将介绍四种常见的读写XML的方法:DOM、SAX、JDOM、和XMLStreamReader/XMLStreamWriter。
1. DOM(Document Object Model):DOM是一种基于树形结构的解析器,它将整个XML文档加载到内存中,并将其表示为一个对象树。
在DOM中,每个XML元素都被表示为一个节点(Node),可以通过节点的属性和方法对其进行操作。
读取XML文档时,可以使用DOM解析器将其转换为一个DOM树,然后通过节点的方法访问和修改树结构。
写入XML文档时,可以通过创建和修改节点来构建DOM树,并使用DOM解析器将其保存为XML文档。
使用DOM读取XML文档的基本步骤如下:- 创建一个DocumentBuilderFactory对象。
- 根据DocumentBuilderFactory对象创建一个DocumentBuilder对象。
- 使用DocumentBuilder对象解析XML文档,并返回一个Document对象。
- 通过Document对象的方法遍历和操作XML文档的节点。
使用DOM写入XML文档的基本步骤如下:- 创建一个DocumentBuilderFactory对象。
- 根据DocumentBuilderFactory对象创建一个DocumentBuilder对象。
- 使用DocumentBuilder对象创建一个Document对象。
- 通过Document对象的方法创建和添加元素节点、属性节点等。
- 使用TransformerFactory和Transformer对象将Document对象保存为XML文档。
DOM的优点是易于使用和理解,可以方便地遍历和修改XML文档。
java 通过浏览器读取客户端文件的方法
java 通过浏览器读取客户端文件的方法Java通过浏览器读取客户端文件的方法介绍在Web开发中,经常需要从浏览器读取客户端文件,Java提供了多种方法来实现这一功能。
本文将详细介绍几种常用的方法。
方法一:使用HTML表单上传文件1.在HTML中,使用<input type="file">元素创建一个文件上传表单。
2.在Java中,使用HttpServletRequest对象的getPart方法获取上传的文件。
3.使用Part对象的getInputStream方法获取文件的输入流,进而读取文件的内容。
方法二:使用Apache Commons FileUpload库1.引入Apache Commons FileUpload库的依赖。
2.在Java中,使用ServletFileUpload类解析上传的文件。
3.使用FileItem类获取文件的输入流,进而读取文件的内容。
方法三:使用Spring MVC框架的MultipartResolver1.在Spring MVC配置文件中配置MultipartResolver,例如使用CommonsMultipartResolver。
2.在Java中,使用MultipartFile对象获取上传的文件。
3.使用MultipartFile对象的getInputStream方法获取文件的输入流,进而读取文件的内容。
方法四:使用Servlet的InputStream获取请求体1.在Java中,使用HttpServletRequest对象的getInputStream方法获取请求体的输入流。
2.使用输入流读取请求体的内容。
3.根据请求体的格式解析文件的内容,例如使用multipart/form-data格式。
方法五:使用WebSocket传输文件1.在Java中,使用WebSocket处理客户端的请求。
2.在WebSocket中,使用ByteBuffer对象接收和发送文件的内容。
java 调用返回xml文件 实例
一、介绍在Java编程中,经常会碰到需要调用返回XML文件的情况。
XML (可扩展标记语言)是一种包含标签数据的文本格式,常用于数据交换和存储。
本文将通过实例演示在Java中如何调用返回XML文件的过程,以帮助读者更好地理解和应用相关知识。
二、准备工作在进行实例演示之前,我们需要做一些准备工作:1. 确保已安装Java开发工具包(JDK),并配置好环境变量。
2. 准备一个返回XML文件的API接口或全球信息湾,以便进行调用和获取数据。
三、示例代码下面是一个简单的Java程序,演示了如何调用返回XML文件的过程:```javaimport java.io.BufferedReader;import java.io.InputStreamReader;import .HttpURLConnection;import .URL;public class XMLParser {public static void main(String[] args) {try {// 创建URL对象URL url = new URL("");// 打开连接HttpURLConnection connection = (HttpURLConnection)url.openConnection();// 设置请求方法connection.setRequestMethod("GET");// 读取返回数据BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));String line;StringBuffer response = new StringBuffer();while ((line = reader.readLine()) != null) {response.append(line);}reader.close();// 输出XML数据System.out.println(response.toString());} catch (Exception e) {e.printStackTrace();}}}```在这段示例代码中,我们首先创建了一个URL对象,指定了需要调用的返回XML文件的位置区域。
java mybatis 读取xml的方法
java mybatis 读取xml的方法在使用Java开发中,Mybatis是一个强大的ORM框架,能够帮助我们简化操作数据库的过程。
在Mybatis中,我们可以使用xml文件来定义SQL语句,然后通过Java代码来读取这些xml文件。
要读取Mybatis的xml文件,我们首先需要配置Mybatis的环境和数据源。
这可以通过在代码中使用Mybatis的Configuration类来实现。
接着,我们需要创建一个SqlSessionFactory对象,该对象可以通过SqlSessionFactoryBuilder类的实例来构建。
然后,我们可以通过SqlSessionFactory对象来创建一个SqlSession,SqlSession 是Mybatis提供的一个用于执行SQL操作的接口。
一旦我们获取了SqlSession对象,我们就可以通过它来执行数据库的操作。
在执行查询操作时,我们可以使用SqlSession的selectOne或selectList方法,这些方法可以接受一个SQL语句的ID作为参数,从而读取对应的xml文件中定义的SQL 语句。
例如:```javaSqlSession sqlSession = sqlSessionFactory.openSession();List<User> userList =sqlSession.selectList("erMapper.findAllUsers");```在上面的代码中,我们通过SqlSession的selectList方法读取了名为"findAllUsers"的SQL语句。
这个SQL语句对应于一个xml文件中的标签。
返回的结果是一个包含用户信息的列表。
除了查询操作之外,我们还可以通过SqlSession执行插入、更新和删除等操作。
同样地,我们可以在xml文件中定义相应的SQL语句来执行这些操作。
读取xml的五种方法
124 * @throws SAXException */
125 public void endElement(String namespaceURI, String localName,String qName) throws SAXException{
28 System.exit(1);
29 }
30 //获得根节点StuInfo
31 Element elmtStuInfo = doc.getDocumentElement();
32 //得到所有student节点
33 NodeList nlStudent = elmtStuInfo.getElementsByTagNameNS(
23 } catch (DOMException dom) {
24Message());
25 System.exit(1);
26 } catch (IOException ioe) {
27 System.err.println(ioe);
在java环境下读取xml文件的方法主要有5种:DOM、SAX、JDOM、JAXB、dom4j
最常用、最好用的dom4j
1. DOM(Document Object Model)
此 方法主要由W3C提供,它将xml文件全部读入内存中,然后将各个元素组成一棵数据树,以便快速的访问各个节点 。 因此非常消耗系统性能 ,对比较大的文档不适宜采用DOM方法来解析。 DOM API 直接沿袭了 XML 规范。每个结点都可以扩展的基于 Node 的接口,就多态性的观点来讲,它是优秀的,但是在 Java 语言中的应用不方便,并且可读性不强。
java hultool xmlutil用法
java hultool xmlutil用法在Java中,Hutool是一个轻量级的Java工具库,提供了丰富的工具方法和简化开发的功能。
其中,Hutool的XmlUtil类提供了操作XML的方法。
XmlUtil提供了以下一些常用的方法:1. `format(XmlStr)`:格式化XML字符串,将XML字符串进行缩进和换行处理,使其更易读。
2. `parseXml(XmlStr)`:解析XML字符串,将XML字符串解析为Document对象。
可以通过Document对象进行对XML的操作。
3. `getByXPath(Node, xPath)`:通过XPath表达式获取符合条件的节点列表,返回的是一个NodeList对象,可以通过遍历NodeList 获取具体的节点。
4. `elementText(Element, tagName)`:获取指定标签名的节点的文本内容。
5. `addElement(Element, tagName, text)`:在指定的Element节点下面添加新的子节点,可以设置子节点的标签名和文本内容。
6. `removeElement(Element, tagName)`:移除指定标签名的子节点。
除了上述的方法,XmlUtil还提供了其他一些方法来完成对XML的操作,比如添加属性、设置属性值、移除属性等。
同时,Hutool的XmlUtil还提供了对XML和Java Bean之间的转换功能,例如`BeanUtil.xmlToBean()`和`BeanUtil.beanToXml()`方法,可以方便地将XML转换为Java对象,以及将Java对象转换为XML。
需要注意的是,Hutool的XmlUtil对于大型的XML文件可能不适用,它更适用于处理小型的XML文件或者XML数据的简单操作。
对于大型的XML文件,最好使用更高效的XML处理库,如JAXP、DOM4J或者XStream等。
java xml格式返回报文解析
java xml格式返回报文解析Java中可以使用多种方式解析XML格式的返回报文,常见的方式有DOM解析、SAX解析以及基于XML绑定技术的解析。
每种方式都有不同的特点和适用场景,下面将详细介绍这三种解析方式。
1. DOM解析:DOM(Document Object Model)解析是将整个XML文档加载到内存中,构建成一个树形结构,并提供API来操作这个树。
DOM解析提供了许多API,可以通过节点遍历和搜索、属性读取和设置、节点创建和删除等方式来处理XML文档。
DOM解析适用于对XML文档进行多次读写操作,如增删改查等复杂的操作。
使用Java的DOM解析,可以通过以下几个步骤实现:1)使用DocumentBuilderFactory创建一个DocumentBuilder对象。
2)调用DocumentBuilder的parse方法,传入XML文件的输入流,将XML文档解析为一个Document对象。
3)通过Document对象可以获取XML文档的根元素,从而开始对XML文档进行遍历和操作。
DOM解析的优点是能够将整个XML文档加载到内存中,便于操作和修改。
但是对于较大的XML文件,DOM解析会消耗大量的内存空间。
2. SAX解析:SAX(Simple API for XML)解析是一种基于事件驱动的解析方式,它逐行读取XML文档并触发相应的事件,应用程序根据事件的发生来处理XML文档。
SAX解析的特点是速度快、内存消耗小,适用于对XML文档进行单次顺序读取的操作。
使用Java的SAX解析,可以通过以下几个步骤实现:1)定义一个继承自DefaultHandler的处理器类,重写相应的事件回调方法。
2)使用SAXParserFactory创建一个SAXParser对象。
3)调用SAXParser的parse方法,传入XML文件的输入流和处理器对象,开始解析XML文档。
SAX解析的优点是速度快,内存消耗小,适用于大型XML文件的解析。
JAVA 解析XML 文件的三种解析方法
创建解析XML文件的三种解析方法1、第一种用w3c解析package w3c;import java.io.File;import java.io.FileOutputStream;import java.util.Random;import javax.xml.parsers.DocumentBuilder;import javax.xml.parsers.DocumentBuilderFactory;import javax.xml.transform.OutputKeys;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;public class w3c {public static void main(String[] args) throws Exception{ createXml();}//创建XML文档并创建节点public static void createXml() throws Exception{//获取XML解析器工厂类DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();//获取XML解析器DocumentBuilder db = dbf.newDocumentBuilder();//获取操作的document对象Document document = db.newDocument();//设置XML文件的版本document.setXmlVersion("1.0");//创建根节点Element root = document.createElement("students");//将根节点添加到document对象中document.appendChild(root);//声明一个姓名的数组String nameList[] = {"吕布","赵云","马超","张飞","关羽","许褚","孙策","周瑜","夏侯渊","张颌","于禁","黄忠","典韦","曹仁","程普"};String sexList[] = {"男","女"};//循环添加数据for(int i = 0 ;i < 20 ; i++){//创建根元素节点Element rootelement = document.createElement("student");//声明参数IDString id ="";//循环生成一个9为的随机ID数for(int j = 0; j< 9 ; j ++ ){id += new Random().nextInt(8)+1;}//设置根元素节点的属性rootelement.setAttribute("id",id);//将根元素节点添加到根节点中root.appendChild(rootelement);//设置元素节点Element name = document.createElement("name");Element sex = document.createElement("sex");Element age = document.createElement("age");Element phone = document.createElement("phone");//给元素节点赋值name.setTextContent(nameList[newRandom().nextInt(nameList.length)]);sex.setTextContent(sexList[newRandom().nextInt(sexList.length)]);age.setTextContent(new Random().nextInt(20)+20+"");String tel ="";for(int k = 0; k< 7 ; k++ ){tel += new Random().nextInt(9);}phone.setTextContent("0756-"+tel);//将元素节点添加到根元素节点中rootelement.appendChild(name);rootelement.appendChild(sex);rootelement.appendChild(age);rootelement.appendChild(phone);}//开始把Document映射到文件TransformerFactory transFactory =TransformerFactory.newInstance();Transformer transFormer = transFactory.newTransformer();//生成的XML文件File file = new File("w3c.xml");//判断XML文件存不存在,如果不存在则创建if(file.exists()){file.createNewFile();}//设置是否添加空格transFormer.setOutputProperty(OutputKeys.INDENT, "yes");//设置输出文件的格式transFormer.setOutputProperty(OutputKeys.ENCODING, "utf-8");//输出XML文件transFormer.transform(new DOMSource(document), newStreamResult(new FileOutputStream(file)));//输出XML文件的路径System.out.println(file.getAbsolutePath());}//解析XML文档public static void resolving() throws Exception{//获取XML解析器工厂类DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();//获取XML解析器DocumentBuilder db = dbf.newDocumentBuilder();//获取操作的document对象Document document = db.parse(new File("w3c.xml"));//获取XML文件的根元素节点NodeList root = document.getElementsByTagName("student");//循环根元素节点信息for(int i = 0 ; i < root.getLength() ;i++){Element student = (Element)root.item(i);System.err.println("id = "+student.getAttribute("id")+" name = "+student.getElementsByTagName("name").item(0).getTextContent()+" sex = "+student.getElementsByTagName("sex").item(0).getTextContent()+" age = "+student.getElementsByTagName("age").item(0).getTextContent()+" phone = "+student.getElementsByTagName("phone").item(0).getTextContent());}}}2、第二种用jdom解析package jdom;import java.io.FileOutputStream;import java.util.Iterator;import java.util.List;import java.util.Random;import org.jdom.Document;import org.jdom.Element;import org.jdom.input.SAXBuilder;import org.jdom.output.Format;import org.jdom.output.XMLOutputter;public class jdom {private static String xmlpath = "jdom.xml";public static void main(String[] args) throws Exception{ //resolving();createXml();}//创建XML文件并添加节点public static void createXml() throws Exception{ //创建document对象Document document = new Document();//创建根节点Element root = new Element("students");//将根节点添加到document对象中document.addContent(root);for(int i = 0 ;i < 20 ; i++){//创建根元素节点Element student = new Element("student");//声明参数IDString id ="";//循环生成一个9为的随机ID数for(int j = 0; j< 9 ; j ++ ){id += new Random().nextInt(8)+1;}//设置跟元素节点的属性student.setAttribute("id",id);//将根元素节点添加到根节点中root.addContent(student);//声明一个姓名的数组String nameList[] = {"吕布","赵云","马超","张飞","关羽","许褚","孙策","周瑜","夏侯渊","张颌","于禁","黄忠","典韦","曹仁","程普"};String sexList[] = {"男","女"};//创建元素节点Element name = new Element("name");Element sex = new Element("sex");Element age =new Element("age");Element phone = new Element("phone");//设置根元素节点的文本值name.setText(nameList[newRandom().nextInt(nameList.length)]);sex.setText(sexList[new Random().nextInt(sexList.length)]);age.setText(new Random().nextInt(20)+20+"");String tel ="";for(int k = 0; k< 7 ; k++ ){tel += new Random().nextInt(9);}phone.setText("0756-"+tel);//将元素节点添加到根元素节点中student.addContent(name);student.addContent(sex);student.addContent(age);student.addContent(phone);}//设置XML输出排版Format format = Format.getPrettyFormat();XMLOutputter out = new XMLOutputter(format);//输出XML文件out.output(document, new FileOutputStream(xmlpath));}//解析XML文档@SuppressWarnings("rawtypes")public static void resolving() throws Exception{//获取XML解析器SAXBuilder builder = new SAXBuilder();//获取document对象Document doucment = builder.build(xmlpath);//获取根节点Element students = doucment.getRootElement();//获取根元素节点List studentList = students.getChildren("student");//循环获取元素文本值,第一种方法for(int i = 0 ; i< studentList.size() ; i++ ){Element student = (Element)studentList.get(i);System.out.println("id ="+student.getAttributeValue("id")+" name = "+student.getChildText("name")+" sex = "+student.getChildText("sex")+" age = "+student.getChildText("age")+" phone = "+student.getChildText("phone"));}System.err.println("\n---------------------------------------------------------------------");//循环获取元素文本值,第二种方法for(Iterator iter=studentList.iterator();iter.hasNext();){ Element student = (Element)iter.next();System.out.println("id ="+student.getAttributeValue("id")+" name = "+student.getChildText("name")+" sex = "+student.getChildText("sex")+" age = "+student.getChildText("age")+" phone = "+student.getChildText("phone"));}}}3、第三种用dom4j解析package dom4j;import java.io.File;import java.io.FileWriter;import java.util.Iterator;import java.util.List;import java.util.Random;import org.dom4j.Document;import org.dom4j.DocumentHelper;import org.dom4j.Element;import org.dom4j.io.OutputFormat;import org.dom4j.io.SAXReader;import org.dom4j.io.XMLWriter;public class dom4j {private static String xmlpath = "dom4j.xml";public static void main(String[] args)throws Exception{//createXml();resolving();}public static void createXml() throws Exception{//创建document对象Document document = DocumentHelper.createDocument();//创建根节点Element root = DocumentHelper.createElement("studnets");//将根节点添加到document对象中document.setRootElement(root);for(int i = 0 ;i < 20 ; i++){//创建根元素节点并将根元素节点添加到根节点中Element student = root.addElement("student");//设置根元素节点的值//声明参数IDString id ="";//循环生成一个9为的随机ID数for(int j = 0; j< 9 ; j ++ ){id += new Random().nextInt(8)+1;}student.addAttribute("id",id);//创建元素节点并将元素节点添加到根元素节点中Element name = student.addElement("name");Element sex = student.addElement("sex");Element age = student.addElement("age");Element phone = student.addElement("phone");//声明一个姓名的数组String nameList[] = {"吕布","赵云","马超","张飞","关羽","许褚","孙策","周瑜","夏侯渊","张颌","于禁","黄忠","典韦","曹仁","程普"};String sexList[] = {"男","女"};//设置元素节点的文本值name.setText(nameList[newRandom().nextInt(nameList.length)]);sex.setText(sexList[new Random().nextInt(sexList.length)]);age.setText(new Random().nextInt(20)+20+"");String tel ="";for(int k = 0; k< 7 ; k++ ){tel += new Random().nextInt(9);}phone.setText("0756-"+tel);}//设置XML文件输出的格式OutputFormat format = new OutputFormat("\t", true);format.setEncoding("utf-8");XMLWriter xmlWriter = new XMLWriter(new FileWriter(xmlpath), format);//输出XML文件xmlWriter.write(document);xmlWriter.close();}//解析XML文件@SuppressWarnings("rawtypes")public static void resolving() throws Exception{//获取XML解析器SAXReader saxReader = new SAXReader();//获取document对象Document document = saxReader.read(new File(xmlpath));//获取根节点Element root = document.getRootElement();//获取根元素节点List chindList = root.elements();//循环获取元素文本值,第一种方法for(Iterator iter = chindList.iterator(); iter.hasNext();){ Element student =(Element)iter.next();System.out.println("id = "+student.attributeValue("id")+" name = "+student.elementText("name")+" sex = "+student.elementText("sex")+" age = "+student.elementText("age")+" phone = "+student.elementText("phone"));}System.err.println("\n---------------------------------------------------------------------");//循环获取元素文本值,第二种方法for(int i = 0 ; i< chindList.size() ; i++ ){Element student = (Element)chindList.get(i);System.out.println("id = "+student.attributeValue("id")+" name = "+student.elementText("name")+" sex = "+student.elementText("sex")+" age = "+student.elementText("age")+" phone = "+student.elementText("phone"));}}}。
如何利用Java语言进行XML编程的研究报告
如何利用Java语言进行XML编程的研究报告随着计算机技术的不断发展,XML(可扩展标记语言)已经成为Web数据交换的一种标准方式。
它是一种使用标签描述数据的语言,具有自我描述性以及能够方便地扩展的特点。
而Java语言可以很好地与XML技术相结合,用于XML编程。
本文将介绍如何利用Java语言进行XML编程的方法和技巧。
一、读取XML文件Java语言中提供了许多读取XML文件的工具,如DOM、SAX、JDOM、XMLBeans等。
其中DOM(文档对象模型)是最常用的读取XML文件的方式。
DOM是一种树状结构,将XML文档中的标签、属性、内容等信息以节点的形式表示,每个节点都有一个唯一的节点名和一个节点值。
通过使用DOM解析器,Java程序可以将XML文档转换为DOM树,然后通过遍历DOM树的方式实现对XML文档的读取。
二、创建XML文档Java语言中也提供了多种创建XML文档的方式,如DOM、JDOM、XOM、StAX等。
其中DOM仍然是最常用的方式。
通过DOM创建XML文档的过程与读取XML文档的过程类似,只不过是反过来了。
先创建一个空的DOM树,然后按照XML文档的结构,在树中添加标签、属性和文本节点等元素,最后将DOM树转换为XML文档。
三、解析XML文件解析XML文件是将XML文档转换为Java对象,使程序能够方便地使用XML数据。
Java语言中可以使用JAXB、Castor、XMLBeans等工具进行XML文件的解析。
其中,JAXB(Java Architecture for XML Binding)是最常用的XML解析工具之一。
JAXB通过将XML数据映射到Java对象上,实现了XML文档的解析和Java对象的序列化过程。
四、使用XPath查询XML数据XPath是一种用于在XML文档中查询信息的语言,它可以实现XML数据的定位、筛选和排序等操作。
在Java语言中,可以使用JDOM、DOM4J等工具实现XPath查询XML数据的功能。
使用JAXB读写xml
使⽤JAXB读写xml1.注解在Java模型中的创建与 xml ⽂件对应的节点和属性需要⽤注解来表⽰@XmlRootElement作⽤:将⼀个Java类映射为⼀段XML的根节点参数:name 定义这个根节点的名称namespace 定义这个根节点命名空间@XmlAccessorType作⽤:定义映射这个类中的何种类型需要映射到XML。
可接收四个参数,分别是:XmlAccessType.FIELD:表⽰将这个类中的⾮静态(static)、⾮序列化(transient)属性映射到xml,有⽆get/set⽅法均可XmlAccessType.PROPERTY:使⽤ set/get ⽅法来序列化属性或者元素(get⽅法可不需注解⾃动映射)——说明:通过get⽅法映射到xml,get⽅法上是否添加注解都可,但是不能在属性上添加注解XmlAccessType.PUBLIC_MEMBER:将这个类中的所有public的field(字段)或property(get/set对)同时映射到XML(默认注解),该注解包含了XmlAccessType.FIELD和XmlAccessType.PROPERTY两个注解,所以注意不要对同⼀个字段添加两次注解XmlAccessType.NONE:不映射补充说明:@XmlAccessorType的默认访问级别是 XmlAccessType.PUBLIC_MEMBER,因此,如果java对象中的private成员变量设置了public权限的 getter/setter⽅法,就不要在private变量上使⽤@XmlElement和@XmlAttribute注解,否则在由java对象⽣成 xml时会报同⼀个属性在java 类⾥存在两次的错误。
同理,如果@XmlAccessorType的访问权限为XmlAccessType.NONE,如果在java的成员变量上使⽤了@XmlElement或@XmlAttribute 注解,这些成员变量依然可以映射到xml⽂件。
Java解析XML的四种方法
Java解析XML的四种方法概序XML现在已经成为一种通用的数据交换格式,它的平台无关性,语言无关性,系统无关性,给数据集成与交互带来了极大的方便。
XML文件解析方法XML在不同的语言里解析方式都是一样的,只不过实现的语法不同而已。
基本的解析方式有两种,一种叫SAX,另一种叫DOM。
SAX是基于事件流的解析,DOM是基于XML文档树结构的解析。
假设我们XML的内容和结构如下:<?xml version="1.0" encoding="UTF-8"?><employees><employee><name>ddviplinux</name><sex>m</sex><age>30</age></employee></employees>本文实现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 接口来操作这个树结构。
关于java后台如何接收xml格式的数据
关于java后台如何接收xml格式的数据业务场景:⽤户发送下单请求,格式为xml格式,服务器接收数据完成下单,并返回结果给客户。
请求格式:<request><head><sign></sign><time></time><msg></msg></head><body><productId></productId><count></count><price></price><user><userId></userId><name></name><mobil></mobil><email></email></user><extendInfos><extendInfo><city></city><province></province><district></district><address></address></extendInfo></extendInfos></body></request>这段请求报⽂是xml格式的,在后台我们可以使⽤ javax.xml.bind.annotation 这个包格式化数据。
我们可以在做数据对应的dto是⽤@XmlElement注释标注对应节点⽐如:import java.io.Serializable;import javax.xml.bind.annotation.XmlAccessType;import javax.xml.bind.annotation.XmlAccessorType;import javax.xml.bind.annotation.XmlElement;import javax.xml.bind.annotation.XmlRootElement;import ng.builder.ToStringBuilder;import ng.builder.ToStringStyle;import com.juqitech.adapter.dto.ChannelDTO;@XmlRootElement(name = "request")@XmlAccessorType(XmlAccessType.NONE)public class RequestDTO implements Serializable {private static final long serialVersionUID = -1;@XmlElementprivate RequestHeaderDTO head;@XmlElementprivate RequestBodyDTO body;public RequestHeaderDTO getHead() {return head;}public void setHead(RequestHeaderDTO head) {this.head = head;}public RequestBodyDTO getBody() {return body;}public void setBody(RequestBodyDTO body) {this.body = body;}}@XmlRootElement(name = "request")可以定义在类上,代表根节点@XmlAccessorType(XmlAccessType.FIELD)表⽰使⽤这个类中的 private ⾮静态字段作为 XML 的序列化的属性或者元素。
java xml相关操作
java xml相关操作
Java与XML的结合是一种常见的方式,可以实现数据的存储和传输。
以下是一些Java XML相关操作的详细介绍:
1. 解析XML文件:使用Java中的DOM、SAX或JDOM等API可以解析XML文件并获取其中的数据。
2. 创建XML文件:可以使用Java中的DOM或JDOM等API创建XML文件,并将数据写入其中。
3. 使用XML Schema验证XML文档:可以使用Java中的SAX或DOM API以及一些第三方库,如JAXB或XSDValidator等,来验证XML 文档是否符合XML Schema的规范。
4. 转换XML格式:可以使用Java中的XSLT API将XML文档转换为其他格式,如HTML、PDF等。
5. 使用XPath查询XML文档:可以使用Java中的XPath API来查询XML文档中的数据。
6. 使用JAXB绑定XML和Java对象:可以使用JAXB API将XML 文档中的数据绑定到Java对象上,并进行操作和修改。
7. 使用XML与Web服务交互:可以使用Java中的WebService API 来使用XML和Web服务交互,并获取和发送数据。
总之,Java与XML的结合可以实现许多功能,如数据存储、数据传输、Web服务交互等,是Java开发中的重要部分。
- 1 -。
java读取XML文件内容的四种方法
Java parse XML methods(4)关键字: xml1. 介绍1>DOM(JAXP Crimson解析器)DOM是用与平台和语言无关的方式表示XML文档的官方W3C标准。
DOM是以层次结构组织的节点或信息片断的集合。
这个层次结构允许开发人员在树中寻找特定信息。
分析该结构通常需要加载整个文档和构造层次结构,然后才能做任何工作。
由于它是基于信息层次的,因而DOM被认为是基于树或基于对象的。
DOM 以及广义的基于树的处理具有几个优点。
首先,由于树在内存中是持久的,因此可以修改它以便应用程序能对数据和结构作出更改。
它还可以在任何时候在树中上下导航,而不是像SAX那样是一次性的处理。
DOM使用起来也要简单得多。
2>SAXSAX处理的优点非常类似于流媒体的优点。
分析能够立即开始,而不是等待所有的数据被处理。
而且,由于应用程序只是在读取数据时检查数据,因此不需要将数据存储在内存中。
这对于大型文档来说是个巨大的优点。
事实上,应用程序甚至不必解析整个文档;它可以在某个条件得到满足时停止解析。
一般来说,SAX还比它的替代者DOM快许多。
选择DOM还是选择SAX?对于需要自己编写代码来处理XML文档的开发人员来说,选择DOM还是SAX解析模型是一个非常重要的设计决策。
DOM采用建立树形结构的方式访问XML文档,而SAX 采用的事件模型。
DOM解析器把XML文档转化为一个包含其内容的树,并可以对树进行遍历。
用DOM解析模型的优点是编程容易,开发人员只需要调用建树的指令,然后利用 navigation APIs访问所需的树节点来完成任务。
可以很容易的添加和修改树中的元素。
然而由于使用DOM解析器的时候需要处理整个XML文档,所以对性能和内存的要求比较高,尤其是遇到很大的XML文件的时候。
由于它的遍历能力,DOM解析器常用于XML文档需要频繁的改变的服务中。
SAX解析器采用了基于事件的模型,它在解析XML文档的时候可以触发一系列的事件,当发现给定的tag的时候,它可以激活一个回调方法,告诉该方法制定的标签已经找到。
java解析xml详解及示例
java解析xml详解及示例java 解析xml的几种方法第一种:DOMDOM的全称是Document Object Model,也即文档对象模型。
在应用程序中,基于DOM 的XML分析器将一个XML文档转换成一个对象模型的集合(通常称DOM树),应用程序正是通过对这个对象模型的操作,来实现对XML文档数据的操作。
通过DOM接口,应用程序可以在任何时候访问XML文档中的任何一部分数据,因此,这种利用DOM接口的机制也被称作随机访问机制。
DOM接口提供了一种通过分层对象模型来访问XML文档信息的方式,这些分层对象模型依据XML的文档结构形成了一棵节点树。
无论XML文档中所描述的是什么类型的信息,即便是制表数据、项目列表或一个文档,利用DOM所生成的模型都是节点树的形式。
也就是说,DOM强制使用树模型来访问XML文档中的信息。
由于XML本质上就是一种分层结构,所以这种描述方法是相当有效的。
DOM树所提供的随机访问方式给应用程序的开发带来了很大的灵活性,它可以任意地控制整个XML文档中的内容。
然而,由于DOM 分析器把整个XML文档转化成DOM树放在了内存中,因此,当文档比较大或者结构比较复杂时,对内存的需求就比较高。
而且,对于结构复杂的树的遍历也是一项耗时的操作。
所以,DOM分析器对机器性能的要求比较高,实现效率不十分理想。
不过,由于DOM分析器所采用的树结构的思想与XML 文档的结构相吻合,同时鉴于随机访问所带来的方便,因此,DOM分析器还是有很广泛的使用价值的。
Java代码import java.io.File;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 DomT est1{public static void main(String[] args) throws Exception{// step 1: 获得dom解析器工厂(工作的作用是用于创建具体的解析器)DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();// System.out.println("class name: " + dbf.getClass().getName());// step 2:获得具体的dom解析器DocumentBuilder db = dbf.newDocumentBuilder();// System.out.println("class name: " + db.getClass().getName());// step3: 解析一个xml文档,获得Document对象(根结点)Document document = db.parse(new File("candidate.xml"));NodeList list = document.getElementsByTagName("PERSON");for(int i = 0; i < list.getLength(); i++){Element element = (Element)list.item(i);String content =element.getElementsByTagName("NAME").item(0).getFirstC hild().getNodeValue();System.out.println("name:" + content);content =element.getElementsByTagName("ADDRESS").item(0).getFir stChild().getNodeValue(); System.out.println("address:" + content);content =element.getElementsByTagName("TEL").item(0).getFirstChil d().getNodeValue();System.out.println("tel:" + content);content =element.getElementsByTagName("FAX").item(0).getFirstChil d().getNodeValue();System.out.println("fax:" + content);content =element.getElementsByTagName("EMAIL").item(0).getFirstC hild().getNodeValue();System.out.println("email:" + content);System.out.println("--------------------------------------");}}}Java代码import java.io.File;import javax.xml.parsers.DocumentBuilder;import javax.xml.parsers.DocumentBuilderFactory;import org.w3c.dom.Attr;import /doc/723478280.html,ment;import org.w3c.dom.Document;import org.w3c.dom.Element;import/doc/723478280.html,dNodeMap;import org.w3c.dom.Node;import org.w3c.dom.NodeList;/*** 使用递归解析给定的任意一个xml文档并且将其内容输出到命令行上* @author*/public class DomT est3{public static void main(String[] args) throws Exception{DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();DocumentBuilder db = dbf.newDocumentBuilder();Document doc = db.parse(new File("student.xml"));//获得根元素结点Element root = doc.getDocumentElement();parseElement(root);}private static void parseElement(Element element){String tagName = element.getNodeName();NodeList children = element.getChildNodes();System.out.print("<" + tagName);//element元素的所有属性所构成的NamedNodeMap对象,需要对其进行判断 NamedNodeMap map = element.getAttributes();//如果该元素存在属性if(null != map){{//获得该元素的每一个属性Attr attr = (Attr)map.item(i);String attrName = attr.getName();String attrValue = attr.getValue();System.out.print(" " + attrName + "=\"" + attrValue + "\""); } }System.out.print(">");for(int i = 0; i < children.getLength(); i++){Node node = children.item(i);//获得结点的类型short nodeType = node.getNodeType();if(nodeType == Node.ELEMENT_NODE){//是元素,继续递归parseElement((Element)node);}else if(nodeType == Node.TEXT_NODE){//递归出口System.out.print(node.getNodeValue());}else if(nodeType == /doc/723478280.html,MENT_NODE) {System.out.print("System.out.print(data);System.out.print("-->");}}System.out.print("");}}第二种 sax:SAX的全称是Simple APIs for XML,也即XML简单应用程序接口。
java 在xml文件中调用方法
java 在xml文件中调用方法在Java中,XML文件是一种常用的数据交换格式,它可以用来存储和传输数据。
在XML文件中调用方法是一种常见的操作,它可以帮助我们实现对XML数据的处理和操作。
本文将介绍如何在Java 中通过XML文件调用方法,并给出一些实际的示例。
我们需要使用Java中的一些库来处理XML文件。
常用的库有DOM、SAX和JDOM等。
在本文中,我们将以DOM库为例来介绍如何在Java中调用XML文件中的方法。
DOM库提供了一个可以将XML文件解析为树状结构的接口,我们可以通过这个接口来访问和操作XML文件中的数据。
下面是一个简单的示例,展示了如何使用DOM库来解析XML文件并调用其中的方法。
我们需要创建一个DocumentBuilderFactory对象,用于创建一个DocumentBuilder对象。
然后,我们可以使用DocumentBuilder 对象的parse方法将XML文件解析为一个Document对象,该对象表示了整个XML文件的树状结构。
```javaimport javax.xml.parsers.DocumentBuilderFactory;import javax.xml.parsers.DocumentBuilder;import org.w3c.dom.Document;import org.w3c.dom.Element;import org.w3c.dom.Node;import org.w3c.dom.NodeList;public class XMLParser {public static void main(String[] args) {try {// 创建一个DocumentBuilderFactory对象DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();// 创建一个DocumentBuilder对象DocumentBuilder builder = factory.newDocumentBuilder();// 使用DocumentBuilder对象的parse方法将XML文件解析为一个Document对象Document document = builder.parse("example.xml");// 获取根节点Element root = document.getDocumentElement();// 调用方法NodeList nodeList =root.getElementsByTagName("method");for (int i = 0; i < nodeList.getLength(); i++) {Node node = nodeList.item(i);if (node.getNodeType() == Node.ELEMENT_NODE) {Element method = (Element) node;String methodName = method.getAttribute("name");System.out.println("调用方法:" + methodName); }}} catch (Exception e) {e.printStackTrace();}}}```在上面的示例中,我们使用了一个名为"example.xml"的XML文件来演示如何调用XML文件中的方法。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
在java环境下读取xml文件的方法主要有4种:DOM、SAX、JDOM、JAXB1. 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.newInstance();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.}30.//获得根节点StuInfo31.Element elmtStuInfo = doc.getDocumentElement();32.//得到所有student节点33. NodeList nlStudent = elmtStuInfo.getElementsByTagNameNS(34. strNamespace, "student");35.for (……){36. //当前student节点元素37. Element elmtStudent = (Element)nlStudent.item(i);38. NodeList nlCurrent = elmtStudent.getElementsByTagNameNS(39. strNamespace, "name");40.}对于读取得方法其实是很简单的,写入xml文件也是一样不复杂。
Java代码1.DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();2.DocumentBuilder builder = null;3.try {4.builder = factory .newDocumentBuilder();5.} catch (ParserConfigurationException pce) {6.System.err.println(pce);7.System.exit(1);8.}9.Document doc = null;10.doc = builder .newDocument();11.//下面是建立XML文档内容的过程,12.//先建立根元素"学生花名册"13.Element root = doc.createElement("学生花名册");14.//根元素添加上文档15.doc.appendChild(root);16.//建立"学生"元素,添加到根元素17.Element student = doc.createElement("学生");18.student.setAttribute("性别", studentBean.getSex());19.root.appendChild(student);20.//建立"姓名"元素,添加到学生下面,下同21.Element name = doc.createElement("姓名");22.student.appendChild(name);23.Text tName = doc.createTextNode(studentBean.getName());.appendChild(tName);25.Element age = doc.createElement("年龄");26.student.appendChild(age);27.Text tAge = doc.createTextNode(String.valueOf(studentBean.getAge()));28.age.appendChild(tAge);2.SAX (Simple API for XML)此方法主要由XML-DEV 邮件列表的成员开发的,SAX是基于事件的方法,它很类似于标签库的处理机制,在标签开始、结束以及错误发生等等地方调用相应的接口实现方法,不是全部文档都读入内存。
SAX具有优异的性能和利用更少的存储空间特点。
SAX 的设计只考虑了功能的强大性,却没有考虑程序员使用起来是否方便。
使用必须扩展ContentHandler、ErrorHandler、DTDHandler等,但是必须扩展ContentHandler(或者DefaultHandler )。
Java代码1.import org.xml.sax.*;2.public class MyContentHandler implements ContentHandler {3.……4.}5./**6. * 当其他某一个调用事件发生时,先调用此方法来在文档中定位。
7. * @param locator8. */9. public void setDocumentLocator(Locator locator){10. }11./**12. * 在解析整个文档开始时调用13. * @throws SAXException14. */15. public void startDocument() throws SAXException{16. System.out.println("** Student information start **");17. }18./**19. * 在解析整个文档结束时调用20. * @throws SAXException21. */22. public void endDocument() throws SAXException{23. System.out.println("**** Student information end ****");24. }25./**26. * 在解析名字空间开始时调用27. * @param prefix28. * @param uri29. * @throws SAXException30. */31. public void startPrefixMapping(String prefix32. , String uri) throws SAXException{33. }34./**35. * 在解析名字空间结束时调用36. * @param prefix37. * @throws SAXException38. */39. public void endPrefixMapping(String prefix) throws SAXException{40. }41./**42. * 在解析元素开始时调用43. * @param namespaceURI44. * @param localName45. * @param qName46. * @param atts47. * @throws SAXException48. */49. public void startElement(String namespaceURI, String localName50. , String qName, Attributes atts) throws SAXException{51. }52./** 在解析元素结束时调用53. * @param namespaceURI54. * @param localName 本地名,如student55. * @param qName 原始名,如LIT:student56. * @throws SAXException */57. public void endElement(String namespaceURI, String localName,String qName) throws SAXException{58. if (localName.equals(“student”)){59. System.out.println(localName+":"+currentData);60. }61.}取得元素数据的方法——characters取得元素数据中的空白的方法——ignorableWhitespace在解析到处理指令时调用的方法——processingInstruction当未验证解析器忽略实体时调用的方法——skippedEntity运行时,只需要使用下列代码:Java代码1.MySAXParser mySAXParser = new MySAXParser();2.mySAXParser.parserXMLFile("SutInfo.xml");3.JDOMJDOM的处理方式有些类似于DOM,但它主要是用SAX实现的。