java读取XML文件的方法
mavenjava读取maven的pom.xml文件
maven java读取maven的pom.xml文件可以使用maven官方的maven-model里的MavenXpp3Reader类来读取pom.xml文件,需要引用maven jar包:dependencygroupId org.apache.maven /groupIdartifactId maven-model /artifactIdversion 3.0 /version/dependency当然,也可以直接找到pom的安装路径下的lib目录找到maven-model-3.1.0.jar文件,引用到项目中。
import org.apache.maven.model.Model;import org.apache.maven.model.io.xpp3.MavenXpp3Reader;import org.codehaus.plexus.util.xml.pull.XmlPullParserException;import java.io.File;import java.io.FileNotFoundException;import java.io.FileReader;import java.io.IOException;* Created by on 2015/10/21.public class Main {public static void main(String[] args) throws IOException, XmlPullParserException {MavenXpp3Reader reader = new MavenXpp3Reader();String myPom = System.getProperty( user.dir ) + File.separator + pom.xmlModel model = reader.read(new FileReader(myPom));}如果你需要解析pom的父pom,以及父依赖等信息,需要用到ModelBuildingRequest 类,实例代码如下。
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程序读取配置文件的几种方法
Java程序读取配置⽂件的⼏种⽅法Java 开发中,需要将⼀些易变的配置参数放置再 XML 配置⽂件或者 properties 配置⽂件中。
然⽽ XML 配置⽂件需要通过 DOM 或 SAX ⽅式解析,⽽读取 properties 配置⽂件就⽐较容易。
1. 读取properties⽂件的⽅法1. 使⽤类加载器ClassLoder类读取配置⽂件InputStream in = MainClass.class.getClassLoader().getResourceAsStream("com/demo/config.properties");MainClass.class是主类的反射对象,因为getClassLoader()是class类的对象⽅法。
在类加载器中调⽤getResourceAsStream()时,采⽤相对路径,起始位置在src⽬录,路径开头没有“/”。
InputStream in = (new MainClass()).getClass().getClassLoader().getResourceAsStream("com/demo/config.properties");因为getClass()是object类的对象⽅法,所有在主类调⽤时要将主类实体化,即new MainClass()。
同理,相对路径起始位置同上。
2. ⽤class对象读取配置⽂件之所以Class对象也可以加载资源⽂件是因为Class类封装的getResourceAsStream⽅法的源码中调⽤了类加载器。
InputStream in = MainClass.class.getResourceAsStream(“/com/demo/config.properties”);同样MainClass.class是主类的反射对象。
在class对象中调⽤getResourceAsStream()时,采⽤绝对路径,起始位置在类路径(bin⽬录),因此路径要以“/”开头。
java使用document解析xml文件
java使⽤document解析xml⽂件准备⼯作:1创建java⼯程2创建xml⽂档。
完成后看下⾯代码:import org.w3c.dom.*;import javax.xml.parsers.DocumentBuilder;import javax.xml.parsers.DocumentBuilderFactory;public class Main {public static void main(String[] args) throws Exception {//创建⼀个⽂档解析器⼯⼚DocumentBuilderFactory fac= DocumentBuilderFactory.newInstance();//⽤上⾯的⼯⼚创建⼀个⽂档解析器DocumentBuilder builder=fac.newDocumentBuilder();//⽤上⾯的⽂档解析器解析⼀个⽂件放到document对象⾥Document doc=builder.parse("src/server.xml");//获取⽂档中节点名称为Listener的所有节点,并返回⼀个节点集合NodeList listenerList=doc.getElementsByTagName("Listener");System.out.println("⼀共有"+listenerList.getLength()+"个节点");//遍历整个集合(把所有标签名为Listener的节点⼀个⼀个拿出来for (int i=0;i<listenerList.getLength();i++){System.out.println("===========这是第"+(i+1)+"个listener节点的开始:===========");//把集合⾥的每⼀个listener节点分别拿出来Node node=listenerList.item(i);//再把上⼀个节点中的所有属性拿出来NamedNodeMap nodeMap= node.getAttributes();System.out.println("第"+(i+1)+"个节点⼀共有"+nodeMap.getLength()+"个属性");//遍历所有属性for(int j=0;j<nodeMap.getLength();j++){Node node1=nodeMap.item(j);System.out.println("第"+(j+1)+"个属性的名称是"+node1.getNodeName());System.out.println("第"+(j+1)+"个属性的值是"+node1.getNodeValue());}//获取节点的所有⼦节点,注意会把所有换⾏符也解析为⼦节点NodeList childNode=node.getChildNodes();//遍历所有⼦节点for(int k=0;k<childNode.getLength();k++){if(childNode.item(k).getNodeType()==Node.ELEMENT_NODE){//这个过滤条件是只将标签节点保留(换⾏符的节点就删去)}System.out.println("===========这是第"+(i+1)+"个节点的结束:===========");}}}为了⽅便记忆,在这⾥拆解⼀下。
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文件 实例
package com.yondor.apps.cxfserver;import org.apache.velocity.runtime.directive.Parse;import org.w3c.dom.*;import javax.xml.parsers.*;import java.io.*;public class t {/* public void init(String xmlFile) throws Exception{//很明显该类是一个单例,先获取产生DocumentBuilder工厂//的工厂,在通过这个工厂产生一个DocumentBuilder,//DocumentBuilder就是用来产生Document的DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance(); DocumentBuilder db=dbf.newDocumentBuilder();doc=db.parse(new File(xmlFile));}*///该方法负责把XML文件的内容显示出来public static void viewXML1(String xmlFile) throws Exception{Document doc=null;DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance(); DocumentBuilder db=dbf.newDocumentBuilder();doc=db.parse(new File(xmlFile));//在xml文件里,只有一个根元素,先把根元素拿出来看看Element element=doc.getDocumentElement();System.out.println("根元素为:"+element.getTagName());//List<Element> names=root.getChildren("txtbook");//NodeList nodeList=element.getElementsByTagName("txtbook");System.out.println("dbstore节点链的长度:"+nodeList.getLength()); if(nodeList!=null){int t=nodeList.getLength();for(int k=0;k<t;k++){Node fatherNode=nodeList.item(k);System.out.println("父节点为:"+fatherNode.getNodeName());//把父节点的属性拿出来NamedNodeMap attributes=fatherNode.getAttributes();for(int i=0;i<attributes.getLength();i++){Node attribute=attributes.item(i);System.out.println("dbstore的属性名为:"+attribute.getNodeName()+" 相对应的属性值为:"+attribute.getNodeValue());}NodeList childNodes = fatherNode.getChildNodes();System.out.println(childNodes.getLength());for(int j=0;j<childNodes.getLength();j++){Node childNode=childNodes.item(j);//如果这个节点属于Element ,再进行取值if(childNode instanceof Element){//System.out.println("子节点名为:"+childNode.getNodeName()+"相对应的值为"+childNode.getFirstChild().getNodeValue());System.out.println("子节点名为:"+childNode.getNodeName()+"相对应的值为"+childNode.getFirstChild().getNodeValue());}}}}}public static void main(String[] args)throws Exception{String path="F:/workspace/goldcity/goldcity_server/";t.viewXML1(path+"src/main/webapps/WEB-INF/test.xml");}}。
java注解XML
java注解XML⽤的是jdk⾃带的javax.xml.bind.JAXBContext将对象和xml字符串进⾏相互转换。
⽐较常⽤的⼏个: @XmlRootElement:根节点 @XmlAttribute:该属性作为xml的attribute @XmlElement:该属性作为xml的element,且可以增加属性(name="NewElementName"),那么⽣成的xml串的elment的标签是NewElementName⾸先,java注解读取XML。
⼀、新建school.xml⽂件,内容如下:<?xml version="1.0" encoding="UTF-8"?><SCHOOL><name>延边⼤学</name><address>吉林延吉市</address><student grade="1"><num>001</num><name>⼩杜</name><age>23</age></student><student grade="2"><num>002</num><name>⼩张</name><age>21</age></student></SCHOOL>⼆、根据配置⽂件书写对应的注解类。
编写Student基类,内容如下:package com.cvicse.ump.xml.school;import javax.xml.bind.annotation.XmlAttribute;import javax.xml.bind.annotation.XmlElement;public class Student {private String studentNum;private String studentName;private String studentGrade;private int age;@XmlElement(name="num")public String getStudentNum() {return studentNum;}public void setStudentNum(String studentNum) {this.studentNum = studentNum;}@XmlElement(name="name")public String getStudentName() {return studentName;}public void setStudentName(String studentName) {this.studentName = studentName;}@XmlAttribute(name="grade")public String getStudentGrade() {return studentGrade;}public void setStudentGrade(String studentGrade) {this.studentGrade = studentGrade;}@XmlElementpublic int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "Student [studentNum=" + studentNum + ", studentName=" + studentName + ", studentGrade=" + studentGrade + ", age=" + age + "]";}}编写基类school,内容如下:package com.cvicse.ump.xml.school;import java.util.List;import javax.xml.bind.annotation.XmlElement;import javax.xml.bind.annotation.XmlRootElement;@XmlRootElement(name="SCHOOL")public class School {private String name;private String address;private List<Student>students;@XmlElementpublic String getName() {return name;}public void setName(String name) { = name;}@XmlElementpublic String getAddress() {return address;}public void setAddress(String address) {this.address = address;}@XmlElement(name="student")public List<Student> getStudents() {return students;}public void setStudents(List<Student> students) {this.students = students;}@Overridepublic String toString() {return "School [name=" + name + ", address=" + address + "]"; }}编写XML读取程序:package com.cvicse.ump.xml.school;import java.io.File;import java.util.List;import javax.xml.bind.JAXBContext;import javax.xml.bind.JAXBException;import javax.xml.bind.Unmarshaller;public class SchoolRead {public static void main(String[] args) {File file = new File("src/school.xml");try {JAXBContext context = JAXBContext.newInstance(School.class); Unmarshaller unMar = context.createUnmarshaller();School school = (School) unMar.unmarshal(file);System.out.println(school);List<Student>students = school.getStudents();for(Student student:students){System.out.println(student);}} catch (JAXBException e) {e.printStackTrace();}}}编写写⼊⽂件程,内容如下:package com.cvicse.ump.xml.school;import java.util.ArrayList;import java.util.List;import javax.xml.bind.JAXBContext;import javax.xml.bind.JAXBException;import javax.xml.bind.Marshaller;public class SchoolWrite {public static void main(String[] args) {School school = new School();school.setName("实验⼩学");school.setAddress("⼭东济南市");List<Student> students = new ArrayList<Student>();Student student1 = new Student();student1.setStudentNum("001");student1.setStudentName("xiaoDy");student1.setAge(25);student1.setStudentGrade("1");Student student2 = new Student();student2.setStudentNum("002");student2.setStudentName("xiaoWf");student2.setAge(22);student2.setStudentGrade("2");students.add(student1);students.add(student2);school.setStudents(students);try {JAXBContext context = JAXBContext.newInstance(School.class);Marshaller mar = context.createMarshaller();mar.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);mar.setProperty(Marshaller.JAXB_ENCODING, "UTF-8");mar.marshal(school, System.out);} catch (JAXBException e) {e.printStackTrace();}}}源码下载:https:///cxDZgKQbeDLqt (提取码:68e1)参考⽹址:/lhzjj/article/details/11796713。
读写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 调用返回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语句来执行这些操作。
读取hive-sit.xml java 通用方法
读取hive-sit.xml java 通用方法【实用版3篇】目录(篇1)1.Hive 和 Hadoop 的关系2.Hive-sit.xml 的作用3.Java 读取 hive-sit.xml 的通用方法4.示例代码正文(篇1)Hive 是一个基于 Hadoop 的数据仓库工具,可以用来处理和分析大规模的结构化数据。
Hadoop 是一个分布式计算框架,提供了数据存储和处理的基础设施。
Hive 依赖于 Hadoop 来执行查询和操作数据,因此了解 Hive 和 Hadoop 的关系对于使用 Hive 至关重要。
Hive-sit.xml 是 Hive 的配置文件,用于存储 Hive 的设置和参数。
这个文件通常位于 Hive 的安装目录下,比如在 Linux 系统中,它可能位于/etc/hive/conf 目录下。
在实际使用中,我们需要读取这个文件来获取 Hive 的配置信息,以便更好地使用 Hive。
对于 Java 程序来说,读取 hive-sit.xml 的通用方法是使用 XML 解析库,比如 DOM 和 SAX。
这里我们以 DOM 解析库为例,给出一个简单的示例代码:```javaimport java.io.FileInputStream;import java.io.IOException;import javax.xml.parsers.DocumentBuilder;import javax.xml.parsers.DocumentBuilderFactory;import org.w3c.dom.Document;public class ReadHiveConfig {public static void main(String[] args) {try {FileInputStream fis = newFileInputStream("/etc/hive/conf/hive-sit.xml");DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();DocumentBuilder dBuilder =dbFactory.newDocumentBuilder();Document doc = dBuilder.parse(fis);doc.getDocumentElement().normalize();System.out.println(doc.getDocumentElement().getNodeValue());fis.close();} catch (IOException e) {e.printStackTrace();}}}```这段代码首先使用 FileInputStream 读取 hive-sit.xml 文件,然后使用 DocumentBuilderFactory 创建一个 DocumentBuilder 实例,接着使用这个实例解析文件内容,并将解析后的文档打印出来。
读取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 解析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数据的功能。
关于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⽂件并转换成对象,并进⾏修改1.⾸先要写⼯具类,处理读取和写⼊xml⽂件使⽤的⼯具。
XMLUtil.javaimport java.io.FileInputStream;import java.io.FileWriter;import java.io.IOException;import java.io.InputStreamReader;import java.io.StringReader;import java.io.StringWriter;import javax.xml.bind.JAXBContext;import javax.xml.bind.JAXBException;import javax.xml.bind.Marshaller;import javax.xml.bind.Unmarshaller;/*** 封装了XML转换成object,object转换成XML的代码** @author mscall**/public class XMLUtil {/*** 将对象直接转换成String类型的 XML输出** @param obj* @return*/public static String convertToXml(Object obj) {// 创建输出流StringWriter sw = new StringWriter();try {// 利⽤jdk中⾃带的转换类实现JAXBContext context = JAXBContext.newInstance(obj.getClass());Marshaller marshaller = context.createMarshaller();// 格式化xml输出的格式marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT,Boolean.TRUE);marshaller.setProperty(Marshaller.JAXB_ENCODING, "UTF-8");// 将对象转换成输出流形式的xmlmarshaller.marshal(obj, sw);} catch (JAXBException e) {e.printStackTrace();}return sw.toString();}/*** 将对象根据路径写⼊指定的xml⽂件⾥** @param obj* @param path* @return*/public static void convertToXml(Object obj, String path) {try {// 利⽤jdk中⾃带的转换类实现JAXBContext context = JAXBContext.newInstance(obj.getClass());Marshaller marshaller = context.createMarshaller();// 格式化xml输出的格式marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT,Boolean.TRUE);marshaller.setProperty(Marshaller.JAXB_ENCODING, "GBK");// 将对象转换成输出流形式的xml// 创建输出流FileWriter fw = null;try {fw = new FileWriter(path);} catch (IOException e) {e.printStackTrace();}marshaller.marshal(obj, fw);} catch (JAXBException e) {e.printStackTrace();}}/*** 将String类型的xml转换成对象*/public static Object convertXmlStrToObject(Class<?> clazz, String xmlStr) { Object xmlObject = null;try {JAXBContext context = JAXBContext.newInstance(clazz);// 进⾏将Xml转成对象的核⼼接⼝Unmarshaller unmarshal = context.createUnmarshaller();StringReader sr = new StringReader(xmlStr);xmlObject = unmarshal.unmarshal(sr);} catch (Exception e) {e.printStackTrace();}return xmlObject;}/*** 将file类型的xml转换成对象*/public static Object convertXmlFileToObject(Class<?> clazz, String xmlPath) {Object xmlObject = null;try {JAXBContext context = JAXBContext.newInstance(clazz);Unmarshaller unmarshaller = context.createUnmarshaller();InputStreamReader isr=new InputStreamReader(new FileInputStream(xmlPath),"GBK"); xmlObject = unmarshaller.unmarshal(isr);} catch (Exception e) {e.printStackTrace();}return xmlObject;}}2、测试写⼊public static void test(){Users users = new Users();User u = new User();u.setUsername("admin");u.setPassword("123");List<User> lus = new ArrayList<>();lus.add(u);users.setUserList(lus);try {XMLUtil.convertToXml(users, "C:/XML/users.xml");} catch (Exception e1) {e1.printStackTrace();}}3、测试读Users users = (Users) XMLUtil.convertXmlFileToObject(Users.class, "C:/XML/Users.xml");4、xml⽂件<?xml version="1.0" encoding="GBK" standalone="yes"?><users><user><username>admin0</username><password>123</password></user><user><username>admin</username><password>123</password></user></users>。
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)。
10000k消耗时间:OutOfMemoryError
接着是 SAX
这种处理的优点非常类似于流媒体的优点。分析能够立即开始,而不是等待所有的数据被处理。而且,由于应用程序只是在读取数据时检查数据,因此不需要将数据存储在内存中。这对于大型文档来说是个巨大的优点。事实上,应用程序甚至不必解析整个文档;它可以在某个条件得到满足时停止解析。一般来说,SAX 还比它的替代者 DOM 快许多。
}
System.out.println("运行时间:"+(System.currentTimeMillis() - lasting)+" 毫秒");
}
}
10k消耗时间:265 203 219 172
100k消耗时间:9172 9016 8891 9000
try {
SAXParserFactory sf = SAXParserFactory.newInstance();
SAXParser sp = sf.newSAXParser();
MyXMLReader reader = new MyXMLReader();
sp.parse(new InputSource("data_10k.xml"), reader);
try{
File f=new File("data_10k.xml");
DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
DocumentBuilder builder=factory.newDocumentBuilder();
Bean文件:
package com.test;
import org.xml.sax.*;
import org.xml.sax.helpers.*;
import javax.xml.parsers.*;
public class MyXMLReader extends DefaultHandler {
String tag = (String) tags.peek();
if (tag.equals("NO")) {
System.out.print("车牌号码:" + new String(ch, start, length));
}
if (tag.equals("ADDR")) {
Document doc = builder.parse(f); ame("VALUE");
for (int i=0;i<nl.getLength();i++){
System.out.print("车牌号码:" + doc.getElementsByTagName("NO").item(i).getFirstChild().getNodeValue());
Attributes attrs) {
tags.push(qName);
}
}
10k消耗时间:110 47 109 78
100k消耗时间:344 406 375 422
1000k消耗时间:3234 3281 3688 3312
10000k消耗时间:32578 34313 31797 31890 30328
JDOM 自身不包含解析器。它通常使用 SAX2 解析器来解析和验证输入 XML 文档(尽管它还可以将以前构造的 DOM 表示作为输入)。它包含一些转换器以将 JDOM 表示输出成 SAX2 事件流、DOM 模型或 XML 文本文档。JDOM 是在 Apache 许可证变体下发布的开放源码。
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("运行时间:" + (System.currentTimeMillis() - lasting) + " 毫秒");
}
public void characters(char ch[], int start, int length) throws SAXException {
System.out.println(" 车主地址:" + doc.getElementsByTagName("ADDR").item(i).getFirstChild().getNodeValue());
}
}catch(Exception e){
e.printStackTrace();
SAX 解析器采用了基于事件的模型,它在解析 XML 文档的时候可以触发一系列的事件,当发现给定的tag的时候,它可以激活一个回调方法,告诉该方法制定的标签已经找到。SAX 对内存的要求通常会比较低,因为它让开发人员自己来决定所要处理的tag。特别是当开发人员只需要处理文档中所包含的部分数据时,SAX 这种扩展能力得到了更好的体现。但用 SAX 解析器的时候编码工作会比较困难,而且很难同时访问同一个文档中的多处不同数据。
然后是 JDOM /
JDOM 的目的是成为 Java 特定文档模型,它简化与 XML 的交互并且比使用 DOM 实现更快。由于是第一个 Java 特定模型,JDOM 一直得到大力推广和促进。正在考虑通过“Java 规范请求 JSR-102”将它最终用作“Java 标准扩展”。从 2000 年初就已经开始了 JDOM 开发。
<NO>B1234</NO>
<ADDR>四川省XX市XX乡XX村XX组</ADDR>
</VALUE>
</RESULT>
测试方法:
采用 JSP 端调用Bean(至于为什么采用JSP来调用,请参考:/rosen/archive/2004/10/15/138324.aspx),让每一种方案分别解析10K、100K、1000K、10000K的 XML 文件,计算其消耗时间(单位:毫秒)。
在平时工作中,难免会遇到把 XML 作为数据存储格式。面对目前种类繁多的解决方案,哪个最适合我们呢?在这篇文章中,我对这四种主流方案做一个不完全评测,仅仅针对遍历 XML 这块来测试,因为遍历 XML 是工作中使用最多的(至少我认为)。
预 备
测试环境:
AMD 毒龙1.4G OC 1.5G、256M DDR333、Windows2000 Server SP4、Sun JDK 1.4.1+Eclipse 2.1+Resin 2.1.8,在 Debug 模式下测试。
JSP 文件:
<%@ page contentType="text/html; charset=gb2312" %>
<%@ page import="com.test.*"%>
<html>
<body>
<%
String args[]={""};
MyXMLReader.main(args);
%>
</body>
</html>
测 试
首先出场的是 DOM(JAXP Crimson 解析器)
DOM 是用与平台和语言无关的方式表示 XML 文档的官方 W3C 标准。DOM 是以层次结构组织的节点或信息片断的集合。这个层次结构允许开发人员在树中寻找特定信息。分析该结构通常需要加载整个文档和构造层次结构,然后才能做任何工作。由于它是基于信息层次的,因而 DOM 被认为是基于树或基于对象的。DOM 以及广义的基于树的处理具有几个优点。首先,由于树在内存中是持久的,因此可以修改它以便应用程序能对数据和结构作出更改。它还可以在任何时候在树中上下导航,而不是像 SAX 那样是一次性的处理。DOM 使用起来也要简单得多。
选择 DOM 还是选择 SAX ?
对于需要自己编写代码来处理 XML 文档的开发人员来说,选择 DOM 还是 SAX 解析模型是一个非常重要的设计决策。
DOM 采用建立树形结构的方式访问 XML 文档,而 SAX 采用的事件模型。
DOM 解析器把 XML 文档转化为一个包含其内容的树,并可以对树进行遍历。用 DOM 解析模型的优点是编程容易,开发人员只需要调用建树的指令,然后利用navigation APIs访问所需的树节点来完成任务。可以很容易的添加和修改树中的元素。然而由于使用 DOM 解析器的时候需要处理整个 XML 文档,所以对性能和内存的要求比较高,尤其是遇到很大的 XML 文件的时候。由于它的遍历能力,DOM 解析器常用于 XML 文档需要频繁的改变的服务中。
import org.w3c.dom.*;
import javax.xml.parsers.*;
public class MyXMLReader{
public static void main(String arge[]){
long lasting =System.currentTimeMillis();
另一方面,对于特别大的文档,解析和加载整个文档可能很慢且很耗资源,因此使用其他手段来处理这样的数据会更好。这些基于事件的模型,比如 SAX。
Bean文件:
package com.test;
import java.io.*;
import java.util.*;
JDOM 与 DOM 主要有两方面不同。首先,JDOM 仅使用具体类而不使用接口。这在某些方面简化了 API,但是也限制了灵活性。第二,API 大量使用了 Collections 类,简化了那些已经熟悉这些类的 Java 开发者的使用。