`
winhkey
  • 浏览: 4369 次
文章分类
社区版块
存档分类
最新评论

jdom操作xml文件基础

XML出版Servlet编程 
阅读更多

      首先是个xml文件

xml 代码
  1. <!---->xml version='1.0' encoding='utf-8'?>  
  2. <书库>  
  3.     <书>  
  4.         <书名>Java编程入门书名>  
  5.         <作者>张三作者>  
  6.         <出版社>电子出版社出版社>  
  7.         <价格>35.0价格>  
  8.         <出版日期>2002-10-07出版日期>  
  9.     书>  
  10.     <书>  
  11.         <书名>XML在Java中的应用书名>  
  12.         <作者>李四作者>  
  13.         <出版社>希望出版社出版社>  
  14.         <价格>92.0价格>  
  15.         <出版日期>2002-10-07出版日期>  
  16.     书>  
  17. 书库>  
 
接下来是类
java 代码
  1. package jdom.test;   
  2.   
  3. public class Book   
  4. {   
  5.     private String bookname, author, pub, price, pubdate;   
  6.   
  7.     public Book(){}   
  8.        
  9.     public Book(String bookname, String author, String pub, String price, String pubdate)   
  10.     {   
  11.         this.bookname = bookname;   
  12.         this.author = author;   
  13.         this.pub = pub;   
  14.         this.price = price;   
  15.         this.pubdate = pubdate;   
  16.     }   
  17.        
  18.     public String getAuthor()   
  19.     {   
  20.         return author;   
  21.     }   
  22.   
  23.     public void setAuthor(String author)   
  24.     {   
  25.         this.author = author;   
  26.     }   
  27.   
  28.     public String getBookname()   
  29.     {   
  30.         return bookname;   
  31.     }   
  32.   
  33.     public void setBookname(String bookname)   
  34.     {   
  35.         this.bookname = bookname;   
  36.     }   
  37.   
  38.     public String getPrice()   
  39.     {   
  40.         return price;   
  41.     }   
  42.   
  43.     public void setPrice(String price)   
  44.     {   
  45.         this.price = price;   
  46.     }   
  47.   
  48.     public String getPub()   
  49.     {   
  50.         return pub;   
  51.     }   
  52.   
  53.     public void setPub(String pub)   
  54.     {   
  55.         this.pub = pub;   
  56.     }   
  57.   
  58.     public String getPubdate()   
  59.     {   
  60.         return pubdate;   
  61.     }   
  62.   
  63.     public void setPubdate(String pubdate)   
  64.     {   
  65.         this.pubdate = pubdate;   
  66.     }   
  67. }   

       然后是对这个类访问
       java 代码

  1. package jdom.test;   
  2.   
  3. import java.io.FileInputStream;   
  4. import java.io.FileNotFoundException;   
  5. import java.io.FileOutputStream;   
  6. import java.io.IOException;   
  7. import java.util.List;   
  8. import java.util.Vector;   
  9.   
  10. import org.jdom.Document;   
  11. import org.jdom.Element;   
  12. import org.jdom.JDOMException;   
  13. import org.jdom.input.SAXBuilder;   
  14. import org.jdom.output.Format;   
  15. import org.jdom.output.XMLOutputter;   
  16.   
  17. public class XmlBean   
  18. {   
  19.     Document doc;   
  20.     Book book;   
  21.        
  22.     public XmlBean(String path, Book book)   
  23.     {   
  24.         getDocument(path);   
  25.         this.book = book;   
  26.     }   
  27.        
  28.     public XmlBean(String path)   
  29.     {   
  30.         getDocument(path);   
  31.         book = new Book();   
  32.     }   
  33.        
  34.     /**  
  35.      * 读取XML文件所有信息  
  36.      * @return Vector<book></book>  
  37.      */  
  38.     public Vector<book></book> LoadXML()   
  39.     {   
  40.         List books = getList();   
  41.         Vector<book></book> vector = new Vector<book></book>();   
  42.         for (int i = 0; i < books.size(); i++)   
  43.         {   
  44.             Book book = new Book();   
  45.             Element element = (Element) books.get(i);   
  46.             book.setBookname(element.getChild("书名").getText());   
  47.             book.setAuthor(element.getChild("作者").getText());   
  48.             book.setPub(element.getChild("出版社").getText());   
  49.             book.setPrice(element.getChild("价格").getText());   
  50.             book.setPubdate(element.getChild("出版日期").getText());   
  51.             vector.add(book);   
  52.         }   
  53.         return vector;   
  54.     }   
  55.   
  56.     /**  
  57.      * 删除XML文件指定信息  
  58.      * @param request  
  59.      */  
  60.     public void delXML(String path, int index)   
  61.     {   
  62.         List books = getList();   
  63.         books.remove(index);   
  64.         docToFile(path);   
  65.     }   
  66.   
  67.     /**  
  68.      * 向XML文件添加信息  
  69.      * @param path  
  70.      */  
  71.     public void addXML(String path)   
  72.     {   
  73.         List<element></element> books = getList();   
  74.         Element newbook = new Element("书");   
  75.         Element newname = new Element("书名");   
  76.         newname.setText(book.getBookname());   
  77.         newbook.addContent(newname);   
  78.         Element newauthor = new Element("作者");   
  79.         newauthor.setText(book.getAuthor());   
  80.         newbook.addContent(newauthor);   
  81.         Element newpub = new Element("出版社");   
  82.         newpub.setText(book.getPub());   
  83.         newbook.addContent(newpub);   
  84.         Element newprice = new Element("价格");   
  85.         newprice.setText(book.getPrice());   
  86.         newbook.addContent(newprice);   
  87.         Element newdate = new Element("出版日期");   
  88.         newdate.setText(book.getPubdate());   
  89.         newbook.addContent(newdate);   
  90.         books.add(newbook);   
  91.         docToFile(path);   
  92.     }   
  93.        
  94.     /**  
  95.      * 修改XML文件指定信息  
  96.      * @param request  
  97.      */  
  98.     public void editXML(String path, int index)   
  99.     {   
  100.         List books = getList();   
  101.         Element element = (Element) books.get(index);   
  102.         Element newname = element.getChild("书名");   
  103.         newname.setText(book.getBookname());   
  104.         Element newauthor = element.getChild("作者");   
  105.         newauthor.setText(book.getAuthor());   
  106.         Element newpub = element.getChild("出版社");   
  107.         newpub.setText(book.getPub());   
  108.         Element newprice = element.getChild("价格");   
  109.         newprice.setText(book.getPrice());   
  110.         Element newdate = element.getChild("出版日期");   
  111.         newdate.setText(book.getPubdate());   
  112.         docToFile(path);   
  113.     }   
  114.            
  115.     /**  
  116.      * 写入文件  
  117.      * @param path  
  118.      */  
  119.     void docToFile(String path)   
  120.     {   
  121.         Format format = Format.getPrettyFormat();   
  122.         format.setIndent("");   
  123.         format.setEncoding("utf-8");   
  124.         XMLOutputter outp = new XMLOutputter(format);   
  125.         FileOutputStream fo = null;   
  126.         try  
  127.         {   
  128.             fo = new FileOutputStream(path);   
  129.             outp.output(doc, fo);   
  130.         }   
  131.         catch (FileNotFoundException e)   
  132.         {   
  133.             e.printStackTrace();   
  134.         }   
  135.         catch (IOException e)   
  136.         {   
  137.             e.printStackTrace();   
  138.         }   
  139.         finally  
  140.         {   
  141.             close(fo);   
  142.         }   
  143.     }   
  144.        
  145.     /**  
  146.      *   
  147.      * @param path  
  148.      */  
  149.     void getDocument(String path)   
  150.     {   
  151.         FileInputStream fi = null;   
  152.         try  
  153.         {   
  154.             fi = new FileInputStream(path);   
  155.             SAXBuilder sb = new SAXBuilder();   
  156.             doc = sb.build(fi);   
  157.         }   
  158.         catch (FileNotFoundException e)   
  159.         {   
  160.             e.printStackTrace();   
  161.         }   
  162.         catch (JDOMException e)   
  163.         {   
  164.             e.printStackTrace();   
  165.         }   
  166.         catch (IOException e)   
  167.         {   
  168.             e.printStackTrace();   
  169.         }   
  170.         finally  
  171.         {   
  172.             close(fi);   
  173.         }   
  174.     }   
  175.        
  176.     /**  
  177.      * 得到根元素所有子元素的集合  
  178.      * @param path  
  179.      * @return  
  180.      */  
  181.     List<element></element> getList()   
  182.     {   
  183.         Element root = doc.getRootElement();   
  184.         List<element></element> list = root.getChildren();   
  185.         return list;   
  186.     }   
  187.        
  188.     void close(FileInputStream fi)   
  189.     {   
  190.         if (fi != null)   
  191.         {   
  192.             try  
  193.             {   
  194.             fi.close();   
  195.             }   
  196.             catch (IOException e)   
  197.             {   
  198.             e.printStackTrace();   
  199.             }   
  200.             fi = null;   
  201.         }   
  202.     }   
  203.        
  204.     void close(FileOutputStream fo)   
  205.     {   
  206.         if (fo != null)   
  207.         {   
  208.             try  
  209.             {   
  210.             fo.close();   
  211.             }   
  212.             catch (IOException e)   
  213.             {   
  214.             e.printStackTrace();   
  215.             }   
  216.             fo = null;   
  217.         }   
  218.     }   
  219. }  

再来分别是servlet和filter

java 代码
  1. package servlet;   
  2.   
  3. import java.io.IOException;   
  4. import java.io.PrintWriter;   
  5.   
  6. import javax.servlet.ServletException;   
  7. import javax.servlet.http.HttpServlet;   
  8. import javax.servlet.http.HttpServletRequest;   
  9. import javax.servlet.http.HttpServletResponse;   
  10.   
  11. import jdom.test.Book;   
  12. import jdom.test.XmlBean;   
  13.   
  14. public class XmlServlet extends HttpServlet   
  15. {   
  16.     private static final long serialVersionUID = 1L;   
  17.   
  18.     public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException   
  19.     {   
  20.         doPost(request, response);   
  21.     }   
  22.        
  23.     public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException   
  24.     {   
  25.         PrintWriter out = response.getWriter();   
  26.         String result = "";   
  27.         String act = request.getParameter("act");   
  28.         String path = request.getParameter("path");   
  29.         if ("add".equals(act))   
  30.         {   
  31.             String bookname = request.getParameter("bookname");   
  32.             String author = request.getParameter("author");   
  33.             String pub = request.getParameter("pub");   
  34.             String price = request.getParameter("price");   
  35.             String pubdate = request.getParameter("pubdate");   
  36.             Book book = new Book(bookname, author, pub, price, pubdate);   
  37.             XmlBean xb = new XmlBean(path, book);   
  38.             xb.addXML(path);   
  39.             result = "添加成功";   
  40.         }   
  41.         else if ("del".equals(act))   
  42.         {   
  43.             int id = Integer.parseInt(request.getParameter("id"));   
  44.             XmlBean xb = new XmlBean(path);   
  45.             xb.delXML(path, id);   
  46.             result = "删除成功";   
  47.         }   
  48.         else if ("edit".equals(act))   
  49.         {   
  50.             int id = Integer.parseInt(request.getParameter("id"));   
  51.             String bookname = request.getParameter("bookname");   
  52.             String author = request.getParameter("author");   
  53.             String pub = request.getParameter("pub");   
  54.             String price = request.getParameter("price");   
  55.             String pubdate = request.getParameter("pubdate");   
  56.             Book book = new Book(bookname, author, pub, price, pubdate);   
  57.             XmlBean xb = new XmlBean(path, book);   
  58.             xb.editXML(path, id);   
  59.             result = "修改成功";   
  60.         }   
  61.         else  
  62.         {   
  63.             result = "非法操作";   
  64.         }   
  65.         out.print("



    " + result + "

    }   

评论
1 楼 efei 2007-09-03  
不错
不错哦
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    利用jdom操作xml文档

    ### 利用 JDOM 操作 XML 文档 #### 一、引言 JDOM（Java Document Object Model）是一种用于处理 XML 数据的 Java 库。它提供了面向对象的 API，允许开发人员以简单直观的方式创建、读取、更新和保存 XML 文档。与 ...

    jdom处理xml例子

    通过JDOM，我们可以直接在内存中操作XML文档，这使得XML数据处理更加便捷。 **XML基础** XML（Extensible Markup Language）是一种用于标记数据的语言，广泛应用于数据交换、配置文件和文档存储等领域。XML文档...

    Jdom解析XML

    2. 使用`SAXBuilder`的`build`方法读取XML文件，生成`Document`对象。 3. 通过`Document`对象访问XML结构，如获取根元素、遍历子元素等。 **创建XML文档** 创建XML文档主要涉及以下操作： 1. 创建`Element`对象，...

    用jdom解析xml

    - **构建解析器：** 首先，我们需要导入必要的JDOM库，并创建一个`SAXBuilder`对象，它是JDOM提供的解析器，用于读取XML文件并构建文档对象。 - **读取XML文件：** 使用`SAXBuilder`的`build`方法加载XML文件内容...

    Oracle开发人员JDOM和XML分析生成文档

    `org.jdom`包包含了表示XML文档及其组件的类，如`Attribute`、`Element`、`Document`等，这些类对应XML文档的各个部分，如属性、元素、文档、注释等，使得Java开发者可以方便地创建和操作XML结构。`org.jdom.input`...

    jdom写xml的简单类

    JDOM提供了方便的方式来创建、读取、修改XML文档。本篇文章将深入探讨如何使用JDOM来编写XML文档。 1. **JDOM基本概念** JDOM通过DOM（Document Object Model）模型提供对XML的访问。DOM是一种树型结构，其中XML...

    XML解析入门之JDOM（一）

    读取XML文件时，使用`DocumentBuilder`的`parse()`方法解析XML文件，得到`Document`对象。然后可以通过`Document`的根元素访问整个XML结构。 ```java File inputFile = new File("person.xml"); DocumentBuilder ...

    jdom英文帮助文档

    SAXBuilder适用于大型XML文件，因为它是事件驱动的，内存占用小；DOMBuilder则将整个XML文档加载到内存，适合小型或中型文档。 5. **Document类**：代表整个XML文档，是所有元素的根节点。通过它，你可以获取XML的...

    jdom 帮助文档

    JDOM是一个用于处理XML文档的Java库，它提供了一个基于树型结构的API，使开发人员能够高效地创建、读取、修改和写入XML文档。JDOM的设计目标是成为Java平台上的首选XML处理库，通过提供直观的Java API来简化XML操作...

    关于Jdom和Jdom的一些资料

    2. **解析XML文档**：通过`SAXBuilder`读取XML文件并将其转换为`Document`对象。 3. **访问和修改XML结构**：利用`Element`的`getChild`, `addContent`, `detachNode`等方法来遍历、添加或移除XML元素。 4. **序列...

    JAVA操作XML学习资料合集

    在"java操作xml－jdom.mht"文件中，你可能学习到如何通过JDom解析XML文件，创建XML结构，以及如何读取和修改XML文档中的元素和属性。例如，你可以使用SAXBuilder类来解析XML文件，然后通过Element对象来访问和修改...

    java操作xml和sql server 2008必备包（crimson jdom sqljdbc sqljdbc4）

    DOM允许整个XML文档加载到内存中进行操作，适合小型XML文件；而SAX则是一种事件驱动的解析方式，适用于处理大型XML文件，以节省内存资源。 **Jdom.jar** JDOM是Java DOM实现，它提供了一种更直观、更高效的方式来...

    jdom的jar包和源码

    要使用JDOM读取XML文档，首先需要构建一个SAXBuilder实例，然后调用其`build()`方法传入XML文件路径，即可得到一个Document对象： ```java import org.jdom2.input.SAXBuilder; SAXBuilder saxBuilder = new ...

    jdom4j解析xml

    标题与描述概述的知识点主要集中在使用jdom4j库解析并生成XML文件的过程，特别是针对组织结构树的生成。下面将详细阐述此过程中的关键步骤和技术细节。 ### jdom4j解析XML实例详解 #### 生成XML文档 在示例代码中...

    java开发教程Jdom使用教程

    4. `org.jdom.input`：包含了读取XML文档的类，如SAXBuilder和DOMBuilder。 5. `org.jdom.output`：包含了写入XML文档的类，如XMLOutputter和SAXOutputter。 6. `org.jdom.transform`：支持XSLT转换，包括JDOMSource...

    Jdom、Dom4j 、dom解析xml文件

    JDOM可以直接创建XML文档，也可以读取并解析XML文件。与DOM相比，JDOM提供了更加面向Java的对象模型，使用起来更加直观。例如，你可以直接通过元素名获取元素，而不需要遍历整个DOM树。但是，JDOM同样存在内存占用高...

    JDOM使用详解及实例

    4. `org.jdom.input`：包含读取XML文档的类，如SAXBuilder和DOMBuilder，它们分别用于从SAX事件或DOM模型构建JDOM文档。 5. `org.jdom.output`：提供写入XML文档的类，如XMLOutputter和SAXOutputter，它们负责将...

    jsp操作xml数据库

    首先，需要在JSP页面中导入JDOM库，并使用`SAXBuilder`类读取XML文件，构建`Document`对象，表示整个XML文档。 2. **获取XML节点**：通过`Document`对象，我们可以获取XML的根元素，并进一步遍历和获取子元素。例如...

    jdom包

    1. **解析XML文档**：使用`SAXBuilder`类可以从XML文件或输入流构建一个`Document`对象。例如： ```java SAXBuilder builder = new SAXBuilder(); File inputFile = new File("example.xml"); Document document...

    jdom1.1

    JDOM1.1版本是在其早期版本的基础上进行了优化和增强，提供了更稳定、更安全的XML操作体验。 **JDOM的主要特点：** 1. **全Java实现**：JDOM完全用Java编写，无需依赖其他非Java的XML解析库，如DOM或SAX，这使得...

Magicbox
Global site tag (gtag.js) - Google Analytics