C#之XML文件：XML解析

原创已于 2024-05-10 11:17:02 修改 · 1.2k 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#java #学习 #开发语言 #数据库

于 2023-08-26 13:12:19 首次发布

结构

命名空间

解析方式

DOM：Document Object Model，文档对象模型。这种方式是W3C推荐的处理XML的一种标准方式。
SAX：Simple API for XML。这种方式不是官方标准，属于开源社区XML-DEV，几乎所有的XML解析器都支持它。

DOM与SAX比较：

DOM解析：处理大型文件时其性能下降的非常厉害。这个问题是由DOM的树结构所造成的，这种结构占用的内存较多，而且DOM必须在解析文件之前把整个文档装入内存,适合对XML的随机访问。优点：提供随机定义元素操作，来回移动指针、将整个XML文件一次性加载到内存，形成虚的内存树；缺点：如果XML文件较大，内存空间占用较大、强制将较大的XML文件加载到内存中，有可能损害文件。
SAX解析：不同于DOM,SAX是事件驱动型的XML解析方式。它顺序逐行读取XML文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问。

解析工具

JAXP：DOM或SAX方式进行解析XML。API在JDK之中；
JDom:：JDOM是一个开源项目，它基于树型结构，利用纯JAVA的技术对XML文档实现解析、生成、序列化以及多种操作。（http://jdom.org），JDOM 直接为JAVA编程服务。它利用更为强有力的JAVA语言的诸多特性（方法重载、集合概念等），把SAX和DOM的功能有效地结合起来。JDOM是用Java语言读、写、操作XML的新API函数。在直接、简单和高效的前提下，这些API函数被最大限度的优化。
Dom4J（推荐）：dom4j是目前在xml解析方面是最优秀的(Hibernate、Sun的JAXM也都使用dom4j来解析XML)，它合并了许多超出基本 XML 文档表示的功能，包括集成的 XPath 支持、XML Schema 支持以及用于大文档或流化文档的基于事件的处理。

JAXP-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 DomTest1 {  
    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).getFirstChild().getNodeValue(); 
           System.out.println("name:" + content);  
           content = element.getElementsByTagName("ADDRESS")
                            .item(0).getFirstChild().getNodeValue();  
           System.out.println("address:" + content);  
           content = element.getElementsByTagName("TEL")
                            .item(0).getFirstChild().getNodeValue();  
           System.out.println("tel:" + content);  
           content = element.getElementsByTagName("FAX")
                            .item(0).getFirstChild().getNodeValue();  
           System.out.println("fax:" + content);  
           content = element.getElementsByTagName("EMAIL")
                            .item(0).getFirstChild().getNodeValue(); 
           System.out.println("email:" + content);  
           System.out.println("--------------------------------------");  
         }  
     }  
}

import java.io.File;  
import javax.xml.parsers.DocumentBuilder;  
import javax.xml.parsers.DocumentBuilderFactory;  
import org.w3c.dom.Attr;  
import org.w3c.dom.Comment;  
import org.w3c.dom.Document;  
import org.w3c.dom.Element;  
import org.w3c.dom.NamedNodeMap;  
import org.w3c.dom.Node;  
import org.w3c.dom.NodeList;  
/** 
 * 使用递归解析给定的任意一个xml文档并且将其内容输出到命令行上 
 * @author 
 */  
public class DomTest3 {  
    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){  
            for(int i = 0; i < map.getLength(); i++){  
                //获得该元素的每一个属性  
                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 == Node.COMMENT_NODE){  
                System.out.print("<!--");  
                Comment comment = (Comment)node;  
                //注释内容  
                String data = comment.getData();  
                System.out.print(data);  
                System.out.print("-->");  
            }  
        }  
        System.out.print("</" + tagName + ">");  
    }  
}

JAXP-SAX解析

Java代码

import java.io.File;  
import javax.xml.parsers.SAXParser;  
import javax.xml.parsers.SAXParserFactory;  
import org.xml.sax.Attributes;  
import org.xml.sax.SAXException;  
import org.xml.sax.helpers.DefaultHandler;  
public class SaxTest1{  
    public static void main(String[] args) throws Exception {  
        //step1： 获得SAX解析器工厂实例  
        SAXParserFactory factory = SAXParserFactory.newInstance();  
        //step2: 获得SAX解析器实例  
        SAXParser parser = factory.newSAXParser();  
        //step3: 开始进行解析  
        parser.parse(new File("student.xml"), new MyHandler());  
    }  
}  
class MyHandler extends DefaultHandler {  
    @Override  
    public void startDocument() throws SAXException {  
        System.out.println("parse began");  
    }  
    @Override  
    public void endDocument() throws SAXException {  
        System.out.println("parse finished");  
    }  
    @Override  
    public void startElement(String uri, String localName, String qName,  
            Attributes attributes) throws SAXException {  
        System.out.println("start element");  
    }  
    @Override  
    public void endElement(String uri, String localName, String qName)  
            throws SAXException {  
        System.out.println("finish element");  
    }  
}

import java.io.File;  
import java.util.Stack;  
import javax.xml.parsers.SAXParser;  
import javax.xml.parsers.SAXParserFactory;  
import org.xml.sax.Attributes;  
import org.xml.sax.SAXException;  
import org.xml.sax.helpers.DefaultHandler;  
public class SaxTest2 {  
    public static void main(String[] args) throws Exception  {  
        SAXParserFactory factory = SAXParserFactory.newInstance();  
        SAXParser parser = factory.newSAXParser();  
        parser.parse(new File("student.xml"), new MyHandler2());  
    }  
}  
class MyHandler2 extends DefaultHandler {  
    private Stack<String> stack = new Stack<String>();  
    private String name;  
    private String gender;  
    private String age;  
    @Override  
    public void startElement(String uri, String localName, String qName,  
            Attributes attributes) throws SAXException {  
        stack.push(qName);  
        for(int i = 0; i < attributes.getLength(); i++)  
        {  
            String attrName = attributes.getQName(i);  
            String attrValue = attributes.getValue(i);  
            System.out.println(attrName + "=" + attrValue);  
        }  
    }  
    @Override  
    public void characters(char[] ch, int start, int length)  
            throws SAXException {  
        String tag = stack.peek();  
        if("姓名".equals(tag))  {  
            name = new String(ch, start,length);  
        } else if("性别".equals(tag)){  
            gender = new String(ch, start, length);  
        } else if("年龄".equals(tag)){  
            age = new String(ch, start, length);  
        }  
    }  
    @Override  
    public void endElement(String uri, String localName, String qName)  
            throws SAXException {  
        stack.pop(); //表示该元素已经解析完毕，需要从栈中弹出  
        if("学生".equals(qName)){  
            System.out.println("姓名：" + name);  
            System.out.println("性别：" + gender);  
            System.out.println("年龄：" + age);  
            System.out.println();  
        }    
    }  
}

JDOM解析

Java代码：JDOM创建xml

import java.io.FileWriter;  
import org.jdom.Attribute;  
import org.jdom.Comment;  
import org.jdom.Document;  
import org.jdom.Element;  
import org.jdom.output.Format;  
import org.jdom.output.XMLOutputter;  
public class JDomTest1{  
    public static void main(String[] args) throws Exception {  
        Document document = new Document();  
        Element root = new Element("root");  
        document.addContent(root);  
        Comment comment = new Comment("This is my comments");  
        root.addContent(comment); 
        Element e = new Element("hello");  
        e.setAttribute("sohu", "www.sohu.com");  
        root.addContent(e);  
        Element e2 = new Element("world");  
        Attribute attr = new Attribute("test", "hehe");  
        e2.setAttribute(attr);  
        e.addContent(e2); 
        e2.addContent(new Element("aaa").setAttribute("a", "b")  
            .setAttribute("x", "y").setAttribute("gg", "hh").setText("text content"));  
        Format format = Format.getPrettyFormat(); 
        format.setIndent("    ");  
//      format.setEncoding("gbk");  
        XMLOutputter out = new XMLOutputter(format);  
        out.output(document, new FileWriter("jdom.xml"));  
    }  
}

Java代码：JDOM解析xml

import java.io.File;  
import java.io.FileOutputStream;  
import java.util.List;  
import org.jdom.Attribute;  
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 JDomTest2 {  
    public static void main(String[] args) throws Exception  {  
        SAXBuilder builder = new SAXBuilder();  
        Document doc = builder.build(new File("jdom.xml"));  
        Element element = doc.getRootElement();  
        System.out.println(element.getName());  
        Element hello = element.getChild("hello");  
        System.out.println(hello.getText());  
        List list = hello.getAttributes();  
        for(int i = 0 ;i < list.size(); i++) {  
            Attribute attr = (Attribute)list.get(i); 
            String attrName = attr.getName();  
            String attrValue = attr.getValue();  
            System.out.println(attrName + "=" + attrValue);  
        }  
        hello.removeChild("world");  
        XMLOutputter out = new XMLOutputter(Format.getPrettyFormat().setIndent("    "));  
        out.output(doc, new FileOutputStream("jdom2.xml"));       
    }  
}

DOM4J解析（推荐，开发常用）

Java代码：DOM4J解析XML单元测试

package com.study.xml.junit;

import java.io.FileOutputStream;
import java.io.OutputStream;

import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.junit.Test;

/**
* @Name: DOM4JTest
* @Description: 使用DOM4J解析XML测试类
* @Author: XXX
* @CreateDate: XXX 
* @Version: V1.0
 */
public class DOM4JTest {

    /**
    * @Name: writeXML2Console
    * @Description: 将指定XML文件中的内容打印到控制台
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void writeXML2Console() throws Exception {
        SAXReader reader = new SAXReader() ;
        String url = "src/books.xml" ;
        Document document = reader.read(url) ;
        OutputFormat format = OutputFormat.createPrettyPrint() ;
        XMLWriter writer = new XMLWriter(System.out, format) ;
        writer.write(document) ;
    }

    /**
    * @Name: findElementContent
    * @Description: 得到某个具体节点的内容
    * 例如：
    *   得到第二本书节点中的售价节点的内容
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void findElementContent() throws Exception {
        SAXReader reader = new SAXReader() ;
        String url = "src/books.xml" ;
        Document document = reader.read(url) ;
        Element rootElement = document.getRootElement() ;
        Element secondBook = (Element) rootElement.elements("书").get(1) ;
        Element salePrice = secondBook.element("售价") ;
        System.out.println(salePrice.getUniquePath() + "[" + salePrice.getText() + "]");
    }

    /**
    * @Name: iteratorAllElement
    * @Description: 遍历所有元素节点
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void iteratorAllElement() throws Exception {
        SAXReader reader = new SAXReader() ;
        String url = "src/books.xml" ;
        Document document = reader.read(url) ;
        Element rootElement = document.getRootElement() ;
        treeWalk(rootElement) ;
    }

    private void treeWalk(Element element) {
        System.out.println(element.getName());
        for (int i = 0; i < element.nodeCount(); i++) {
            Node node = element.node(i) ;
            if(node instanceof Element) {
                treeWalk((Element) node) ;
            }
        }
    }

    /**
    * @Name: updateElementContent
    * @Description: 修改某个元素节点下的内容
    * 例如：
    *   修改第二本书节点下售价节点的内容为300
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void updateElementContent() throws Exception {
        SAXReader reader = new SAXReader() ;
        String url = "src/books.xml" ;
        Document document = reader.read(url) ;
        Element rootElement = document.getRootElement() ;
        Element secondBook = (Element) rootElement.elements("书").get(1) ;
        Element salePrice = secondBook.element("售价") ;
        salePrice.setText("300") ;
        OutputStream out = new FileOutputStream(url) ;
        OutputFormat format = OutputFormat.createPrettyPrint() ;
        format.setEncoding("UTF-8") ;
        XMLWriter writer = new XMLWriter(out, format) ;
        writer.write(document) ;
    }

    /**
    * @Name: addChildElement
    * @Description: 向指定元素节点增加子节点
    * 例如：
    *   在第二本书节点下增加内部价：<批发价 id="p2" name="pfj">800</批发价>  
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void addChildElement() throws Exception {
        SAXReader reader = new SAXReader() ;
        String url = "src/books.xml" ;
        Document document = reader.read(url) ;
        Element rootElement = document.getRootElement() ;
        Element secondBook = (Element) rootElement.elements("书").get(1) ;
        secondBook.addElement("批发价")
            .addAttribute("id", "p2")
            .addAttribute("name", "pfj")
            .addText("800") ;
        OutputStream out = new FileOutputStream(url) ;
        OutputFormat format = OutputFormat.createPrettyPrint() ;
        format.setEncoding("UTF-8") ;
        XMLWriter writer = new XMLWriter(out, format) ;
        writer.write(document) ;
    }

    /**
    * @Name: addSameLevelElement
    * @Description: 向指定元素节点下增加同级元素节点
    * 例如：
    *   向第二本书节点的售价前增加内部价<内部价>200</内部价>
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void addSameLevelElement() throws Exception {
        SAXReader reader = new SAXReader() ;
        String url = "src/books.xml" ;
        Document document = reader.read(url) ;
        Element rootElement = document.getRootElement() ;
        Element secondBook = (Element) rootElement.elements("书").get(1) ;
        Element innerPrice = DocumentHelper.createElement("内部价") ;
        innerPrice.addText("200") ;
        secondBook.elements().add(2, innerPrice) ;
        OutputStream out = new FileOutputStream(url) ;
        OutputFormat format = OutputFormat.createPrettyPrint() ;
        format.setEncoding("UTF-8") ;
        XMLWriter writer = new XMLWriter(out, format) ;
        writer.write(document) ;
    }

    /**
    * @Name: deleteElement
    * @Description: 删除指定元素节点：
    * 例如：
    *   删除第二本书节点下的批发价节点
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void deleteElement() throws Exception {
        SAXReader reader = new SAXReader() ;
        String url = "src/books.xml" ;
        Document document = reader.read(url) ;
        Element rootElement = document.getRootElement() ;
        Element secondBook = (Element) rootElement.elements("书").get(1) ;
        Element pfj = secondBook.element("批发价") ;
        secondBook.remove(pfj) ;
        OutputStream out = new FileOutputStream(url) ;
        OutputFormat format = OutputFormat.createPrettyPrint() ;
        format.setEncoding("UTF-8") ;
        XMLWriter writer = new XMLWriter(out, format) ;
        writer.write(document) ;
    }

    /**
    * @Name: opeElementAttribute
    * @Description: 操作节点属性
    * 例如：
    *   添加：向第二本书节点上添加属性：bookid="a2"
    *   删除：删除第二本书节点中批发价节点的name属性
    *   修改：将第三本书节点的id属性改为：bookid="a33"
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void opeElementAttribute() throws Exception {
        SAXReader reader = new SAXReader() ;
        String url = "src/books.xml" ;
        Document document = reader.read(url) ;
        Element rootElement = document.getRootElement() ;
        //向第二本书节点上添加属性：bookid="a2"
        Element secondBook = (Element) rootElement.elements("书").get(1) ;
        secondBook.addAttribute("bookid", "a2") ;
        //删除批发价中的name属性
        Element pfj = secondBook.element("批发价") ;
        Attribute name = pfj.attribute("name") ;
        pfj.remove(name) ;
        //将第三本书节点的id属性改为：bookid="a33"
        Element thridBook = (Element) rootElement.elements("书").get(2) ;
        thridBook.setAttributeValue("bookid", "a33") ;
        OutputStream out = new FileOutputStream(url) ;
        OutputFormat format = OutputFormat.createPrettyPrint() ;
        format.setEncoding("UTF-8") ;
        XMLWriter writer = new XMLWriter(out, format) ;
        writer.write(document) ;
    }
}

补充：Xpath介绍

百度百科解释：

XPath即为XML路径语言，它是一种用来确定XML（标准通用标记语言的子集）文档中某部分位置的语言。XPath基于XML的树状结构，提供在数据结构树中找寻节点的能力。起初 XPath 的提出的初衷是将其作为一个通用的、介于XPointer与XSLT间的语法模型。但是 XPath 很快的被开发者采用来当作小型查询语言。

XPath是一个努力为XSL转换XSLT和XPointer之间共享一个共同的XPointer功能语法和语义的结果。它的主要目的是解决一个XML XML文档部分[ ]。为了支持这一功能，还提供用于处理字符串的基本设施、数字和布尔值。XPath使用一个紧凑的、非XML语法方便使用在uri和XML属性值的XPath。XPath操作基于XML文档的逻辑结构，而不是其表面的语法。Xpath的名字来自其使用的符号在URL路径通过一个XML文档的层次结构导航。除了用于定位，XPath还设计有一个真子集，可用于匹配（测试一个节点是否符合一个模式）；使用XPath进行XSLT。

XPath模型的XML文档的节点树。有不同类型的节点，包括元素节点、属性节点和文本节点。XPath定义了一个方法来计算每个节点类型字符串值。某些类型的节点也有名字。XPath完全支持XML命名空间的XML名称。因此，一个节点的名称被建模为一个地方的部分和一个可能的空命名空间URI；这就是所谓的扩展名。

Java代码：DOM4J+XPATH解析XML文件

package com.study.xml.junit;

import java.io.FileOutputStream;
import java.io.OutputStream;

import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.XPath;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.junit.Test;

import com.study.xml.utils.DOM4JUtils;

/**
* @Name: DOM4JXpathTest
* @Description: 使用DOM4J解析XML测试类，使用Xpath语法定位元素位置
* @Author: XXX
* @CreateDate: XXX
* @Version: V1.0
 */
public class DOM4JXpathTest {

    /**
    * @Name: writeXML2Console
    * @Description: 将指定XML文件中的内容打印到控制台
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void writeXML2Console() throws Exception {
        SAXReader reader = new SAXReader() ;
        String url = "src/books.xml" ;
        Document document = reader.read(url) ;
        OutputFormat format = OutputFormat.createPrettyPrint() ;
        XMLWriter writer = new XMLWriter(System.out, format) ;
        writer.write(document) ;
    }

    /**
    * @Name: findElementContent
    * @Description: 得到某个具体节点的内容
    * 例如：
    *   得到第二本书节点中的售价节点的内容
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void findElementContent() throws Exception {
        SAXReader reader = new SAXReader() ;
        String url = "src/books.xml" ;
        Document document = reader.read(url) ;
        Node salePrice = document.selectSingleNode("/书架/书[2]/售价") ;
        System.out.println(salePrice.getUniquePath() + "[" + salePrice.getText() + "]");
    }

    /**
    * @Name: iteratorAllElement
    * @Description: 遍历所有元素节点
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void iteratorAllElement() throws Exception {
        SAXReader reader = new SAXReader() ;
        String url = "src/books.xml" ;
        Document document = reader.read(url) ;
        Element rootElement = document.getRootElement() ;
        treeWalk(rootElement) ;
    }

    private void treeWalk(Element element) {
        System.out.println(element.getName());
        for (int i = 0; i < element.nodeCount(); i++) {
            Node node = element.node(i) ;
            if(node instanceof Element) {
                treeWalk((Element) node) ;
            }
        }
    }

    /**
    * @Name: updateElementContent
    * @Description: 修改某个元素节点下的内容
    * 例如：
    *   修改第二本书节点下售价节点的内容为300
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void updateElementContent() throws Exception {
        SAXReader reader = new SAXReader() ;
        String url = "src/books.xml" ;
        Document document = reader.read(url) ;
        Element salePrice = (Element) document.selectSingleNode("/书架/书[2]/售价") ;
        salePrice.setText("300") ;
        OutputStream out = new FileOutputStream(url) ;
        OutputFormat format = OutputFormat.createPrettyPrint() ;
        format.setEncoding("UTF-8") ;
        XMLWriter writer = new XMLWriter(out, format) ;
        writer.write(document) ;
    }

    /**
    * @Name: addChildElement
    * @Description: 向指定元素节点增加子节点
    * 例如：
    *   向第二本书节点的售价前增加内部价：<批发价 id="p2" name="pfj">800</批发价>  
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void addChildElement() throws Exception {
        String url = "src/books.xml" ;
        Document document = DOM4JUtils.getDocument(url) ;
        Element secondBook = (Element) document.selectSingleNode("//书[2]") ;
        secondBook.addElement("批发价")
            .addAttribute("id", "p2")
            .addAttribute("name", "pfj")
            .addText("800") ;
        DOM4JUtils.writeBackXml(document, url) ;
    }

    /**
    * @Name: addSameLevelElement
    * @Description: 向指定元素节点下增加同级元素节点
    * 例如：
    *   向第二本书节点的售价前增加内部价<内部价>200</内部价>
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void addSameLevelElement() throws Exception {
        String url = "src/books.xml" ;
        Document document = DOM4JUtils.getDocument(url) ;
        Element secondBook = (Element) document.selectSingleNode("/书架/书[2]") ;
        Element innerPrice = DocumentHelper.createElement("内部价") ;
        innerPrice.addText("200") ;
        //向第二本书节点的售价前增加内部价<内部价>200</内部价>
        secondBook.elements().add(2, innerPrice) ;
        DOM4JUtils.writeBackXml(document, url) ;
    }

    /**
    * @Name: deleteElement
    * @Description: 删除指定元素节点：
    * 例如：
    *   删除第二本书节点下的批发价节点
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void deleteElement() throws Exception {
        String url = "src/books.xml" ;
        Document document = DOM4JUtils.getDocument(url) ;
        Element secondBook = (Element) document.selectSingleNode("/书架/书[2]") ;
        Element pfj = secondBook.element("批发价") ;
        //删除第二本书节点下的批发价节点
        secondBook.remove(pfj) ;
        DOM4JUtils.writeBackXml(document, url) ;
    }

    /**
    * @Name: opeElementAttribute
    * @Description: 操作节点属性
    * 例如：
    *   添加：向第二本书节点上添加属性：bookid="a2"
    *   删除：删除第二本书节点中批发价节点的name属性
    *   修改：将第三本书节点的id属性改为：bookid="a33"
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    @Test
    public void opeElementAttribute() throws Exception {
        String url = "src/books.xml" ;
        Document document = DOM4JUtils.getDocument(url) ;
        //向第二本书节点上添加属性：bookid="a2"
        Element secondBook = (Element) document.selectSingleNode("//书[2]") ;
        secondBook.addAttribute("bookid", "a2") ;
        //删除批发价中的name属性
        Element pfj = secondBook.element("批发价") ;
        Attribute name = pfj.attribute("name") ;
        pfj.remove(name) ;
        //将第三本书节点的id属性改为：bookid="a33"
        Element thridBook = (Element) document.selectSingleNode("//书[3]") ;
        thridBook.setAttributeValue("bookid", "a33") ;
        DOM4JUtils.writeBackXml(document, url) ;
    }


}

项目练习

项目介绍

使用DOM4J+XPATH解析XML实践：使用XML实现数据存储，将页面用户提交的数据存储到xml进行持久化，按照分层设计思想，使用Jsp+Servlet实现简单的用户注册系统。

前期准备

（1）导入依赖包：dom4j-1.6.1.jar、jaxen-1.1-beta-6.jar、commons-beanutils-1.8.3.jar、commons-logging-1.1.1.jar。

（2）编写xml文件：users.xml

<?xml version="1.0" encoding="UTF-8"?>
<users>
    <user username="admin" password="admin" birthday="2016-01-12" email="123@123.com"/>
    <user username="test01" password="test01" birthday="2016-01-12" email="123@123.com"/>
    <user username="test02" password="test02" birthday="2016-01-12" email="123@123.com"/>
</users>

（3）创建JavaBean：User.java

说明：JavaBean中的属性与xml文件中user节点的属性名称保持一致，以便将JavaBean属性值传入xml文档进行存储。

package com.study.java.domain;

import java.io.Serializable;
import java.util.Date;

/**
* @Name: User
* @Description: PO类：用户信息类
* @Author: XXX
* @CreateDate: XXX
* @Version: V1.0
 */
public class User implements Serializable {

    private static final long serialVersionUID = 5274992031371114394L;

    private String username ;
    private String password ;
    private Date birthday ;
    private String email ;

    public User() {}

    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    @Override
    public String toString() {
        return "User [username=" + username + ", password=" + password
                + ", birthday=" + birthday + ", email=" + email + "]";
    }
}

编写工具类

（1）编写DOM4JUtils工具类

package com.study.java.utils;

import java.io.FileOutputStream;
import java.io.OutputStream;
import java.net.URL;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;

/**
* @Name: DOM4JUtils
* @Description: XML-DOM4J解析工具包
* @Author: XXX
* @CreateDate: XXX
* @Version: V1.0
 */
public class DOM4JUtils {

    private static String XMLPATH = "users.xml" ;

    static {
        ClassLoader loader = DOM4JUtils.class.getClassLoader() ;
        URL url = loader.getResource(XMLPATH) ;
        XMLPATH = url.getPath() ;
    }

    /**
    * @Name: getDocument
    * @Description: 获取xml-Document对象
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Return: Document
     */
    public static Document getDocument() {
        Document document = null ;
        try {
            SAXReader reader = new SAXReader() ;
            document = reader.read(XMLPATH) ;
        } catch (DocumentException e) {
            e.printStackTrace();
        }
        return document ;
    }

    /**
    * @Name: writeXML
    * @Description: 将内存中的xml数据写入到xml文件中
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: @param document
    * @Return: void
     */
    public static void writeXML(Document document) {
        OutputStream out = null ;
        OutputFormat format = null ;
        XMLWriter writer = null ;
        try {
            out = new FileOutputStream(XMLPATH) ;
            format = OutputFormat.createPrettyPrint() ;
            format.setEncoding("UTF-8") ;
            writer = new XMLWriter(out, format) ;
            writer.write(document) ;
        } catch (Exception e) {
            throw new RuntimeException(e) ;
        } finally {
            if(writer != null) {
                try {
                    writer.close() ;
                } catch (Exception e) {
                    e.printStackTrace() ;
                } finally {
                    writer = null ;
                }
            }
            if(out != null) {
                try {
                    out.close() ;
                } catch (Exception e) {
                    e.printStackTrace() ;
                } finally {
                    out = null ;
                }
            }
        }
    }
}

（2）编写日期格式处理工具类：DateConverterUtils.java

package com.study.java.utils;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
* @Name: DateConverterUtils
* @Description: 日期-字符串转换工具类
* @Author: XXX
* @CreateDate: XXX
* @Version: V1.0
 */
public class DateConverterUtils {

    private static final String FORMAT = "yyyy-MM-dd" ;
    private static SimpleDateFormat sdf = null ;

    static {
        sdf = new SimpleDateFormat(FORMAT) ;
    }

    /**
    * @Name: parse
    * @Description: 将给定的字符串转换成日期类型
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: @param str
    * @Return: Date
     */
    public static Date parse(String str) {
        Date date = null ;
        try {
            date = sdf.parse(str) ;
        } catch (Exception e) {
            throw new RuntimeException(e) ;
        }
        return date ;
    }

    /**
    * @Name: format
    * @Description: 格式化日期类型到字符串
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: @param date
    * @Return: String
     */
    public static String format(Date date) {
        String result = null ;
        try {
            result = sdf.format(date) ;
        } catch (Exception e) {
            throw new RuntimeException(e) ;
        }
        return result ;
    }
}

DAO层开发

（1）开发UserDao接口

package com.study.java.dao;

import com.study.java.domain.User;

/**
* @Name: UserDao
* @Description: 用户信息操作DAO接口
* @Author: XXX
* @CreateDate: XXX
* @Version: V1.0
 */
public interface UserDao {

    /**
    * @Name: getUserByUsername
    * @Description: 根据用户名获取用户信息
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: @param username
    * @Return: User
     */
    User getUserByUsername(String username) ;

    /**
    * @Name: getUserByUsernameAndPassword
    * @Description: 根据用户名和密码获取用户信息
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: @param username
    * @Parameters: @param password
    * @Return: User
     */
    User getUserByUsernameAndPassword(String username, String password) ;

    /**
    * @Name: addUser
    * @Description: 添加用户信息到xml
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: @param user
    * @Return: void
     */
    void addUser(User user) ;
}

（2）开发UserDao接口实现类（练习重点：使用XML解析技术实现数据的存储和读取）

package com.study.java.dao.impl;

import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.Node;

import com.study.java.dao.UserDao;
import com.study.java.domain.User;
import com.study.java.utils.DOM4JUtils;
import com.study.java.utils.DateConverterUtils;

/**
* @Name: UserDaoImpl
* @Description: 用户信息操作DAO接口实现类
* @Author: XXX
* @CreateDate: XXX
* @Version: V1.0
 */
public class UserDaoImpl implements UserDao {

    public User getUserByUsername(String username) {
        User user = null ;
        //1、获取domcument对象
        Document document = DOM4JUtils.getDocument() ;
        //2、使用xpath获取指定的user节点元素
        Element userElement = (Element) document
            .selectSingleNode("//user[@username='"+ username +"']") ;
        if(userElement != null) {
            //3、将获取到的user节点元素中的属性值放入到user-bean中
            user = new User() ;
            user.setUsername(userElement.valueOf("@username")) ;
            user.setPassword(userElement.valueOf("@password")) ;
            //将字符串转换成日期类型
            user.setBirthday(DateConverterUtils
                .parse(userElement.valueOf("@birthday"))) ;
            user.setEmail(userElement.valueOf("@email")) ;
        }
        //4、返回查询结果
        return user;
    }

    public User getUserByUsernameAndPassword(String username, String password) {
        User user = null ;
        //1、获取domcument对象
        Document document = DOM4JUtils.getDocument() ;
        //2、使用xpath获取指定的user节点元素
        Element userElement = (Element) document
            .selectSingleNode("//user[@username='"+ username 
            + "' and @password='"+ password +"']") ;
        if(userElement != null) {
            //3、将获取到的user节点元素中的属性值放入到user-bean中
            user = new User() ;
            user.setUsername(userElement.valueOf("@username")) ;
            user.setPassword(userElement.valueOf("@password")) ;
            //将字符串转换成日期类型
            user.setBirthday(DateConverterUtils
                .parse(userElement.valueOf("@birthday"))) ;
            user.setEmail(userElement.valueOf("@email")) ;
        }
        //4、返回查询结果
        return user;
    }

    public void addUser(User user) {
        //1、获取document对象
        Document document = DOM4JUtils.getDocument() ;
        //2、获取根节点元素
        Element rootElement = document.getRootElement() ;
        //3、创建新user节点元素，将user-bean中的属性值设置到user节点的属性中
        Element newUserElement = DocumentHelper.createElement("user") ;
        newUserElement.addAttribute("username", user.getUsername()) ;
        newUserElement.addAttribute("password", user.getPassword()) ;
        newUserElement.addAttribute("birthday", DateConverterUtils.format(user.getBirthday())) ;
        newUserElement.addAttribute("email", user.getEmail()) ;
        //4、加入新节点
        rootElement.add(newUserElement) ;
        //5、写回到xml
        DOM4JUtils.writeXML(document) ;
    }
}

Service层开发

（1）开发UserService接口

package com.study.java.service;

import com.study.java.domain.User;

/**
* @Name: UserService
* @Description: 用户信息操作Service接口
* @Author: XXX
* @CreateDate: XXX
* @Version: V1.0
 */
public interface UserService {

    /**
    * @Name: login
    * @Description: 登录操作
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: @param username
    * @Parameters: @param password
    * @Return: User
     */
    User login(String username, String password) ;

    /**
    * @Name: register
    * @Description: 注册操作
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: @param user
    * @Return: boolean
     */
    boolean register(User user) ;
}

（2）开发UserService接口实现类

package com.study.java.service.impl;

import com.study.java.dao.UserDao;
import com.study.java.dao.impl.UserDaoImpl;
import com.study.java.domain.User;
import com.study.java.service.UserService;

/**
* @Name: UserServiceImpl
* @Description: 用户信息操作Service接口实现类
* @Author: XXX
* @CreateDate: XXX
* @Version: V1.0
 */
public class UserServiceImpl implements UserService {

    private UserDao userDao = new UserDaoImpl() ;

    public User login(String username, String password) {
        User user = null ;
        try {
            user = userDao.getUserByUsernameAndPassword(username, password) ;
        } catch (Exception e) {
            e.printStackTrace() ;
        }
        return user;
    }

    public boolean register(User user) {
        //判断用户名是否已经存在
        User u = userDao.getUserByUsername(user.getUsername()) ;
        if(u == null) {
            userDao.addUser(user) ;
            return true ;
        }
        return false;
    }
}

控制层开发

（1）编写WebFormBean：UserFormBean.java

package com.study.java.web.bean;

import java.util.HashMap;
import java.util.Map;

import com.study.java.utils.DateConverterUtils;

/**
* @Name: UserFormBean
* @Description: 表单VO类：用户表单信息类
* @Author: XXX
* @CreateDate: XXX
* @Version: V1.0
 */
public class UserFormBean {

    private String username ;
    private String password ;
    private String repassword ;
    private String birthday ;
    private String email ;
    //校验错误信息集合
    private Map<String, String> errorMsg = new HashMap<String, String>() ;

    public UserFormBean() {}

    /**
    * @Name: validate
    * @Description: 校验注册字段格式
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: 
    * @Return: void
     */
    public boolean validate() {

        if(username == null || "".equals(username.toString().trim())) {
            errorMsg.put("username", "用户名不能为空！") ;
        } else {
            if(!username.matches("^[a-zA-Z]{3,8}$")) {
                errorMsg.put("username", "用户名必须为3-8位的字母！") ;
            }
        }

        if(password == null || "".equals(password)) {
            errorMsg.put("password", "密码不能为空！") ;
        } else {
            if(!password.matches("^[a-zA-Z]{3,8}$")) {
                errorMsg.put("password", "密码必须为3-8位的字母！") ;
            }
        }

        if(!repassword.equals(password)) {
            errorMsg.put("repassword", "与原密码输入不一致！") ;
        }

        if(birthday == null || "".equals(birthday)) {
            errorMsg.put("birthday", "出生年月不能为空！") ;
        } else {
            try {
                DateConverterUtils.parse(birthday) ;
            } catch (Exception e) {
                errorMsg.put("birthday", "输入格式(yyyy-MM-dd)不正确！") ;
            }
        }
        if(email == null || "".equals(email)) {
            errorMsg.put("email", "邮箱不能为空！") ;
        } else {
            if(!email.matches("\\b^['_a-z0-9-\\+]+(\\.['_a-z0-9-\\+]+)*@[a-z0-9-]+(\\.[a-z0-9-]+)*\\.([a-z]{2}|aero|arpa|asia|biz|com|coop|edu|gov|info|int|jobs|mil|mobi|museum|name|nato|net|org|pro|tel|travel|xxx)$\\b")) {
                errorMsg.put("email", "邮箱格式错误！") ;
            }
        }

        return errorMsg.isEmpty() ;
    }

    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public String getRepassword() {
        return repassword;
    }
    public void setRepassword(String repassword) {
        this.repassword = repassword;
    }
    public String getBirthday() {
        return birthday;
    }
    public void setBirthday(String birthday) {
        this.birthday = birthday;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }

    public Map<String, String> getErrorMsg() {
        return errorMsg;
    }

    public void setErrorMsg(Map<String, String> errorMsg) {
        this.errorMsg = errorMsg;
    }
}

（2）开发前端控制器：ControllerServlet.java

package com.study.java.web.controller;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import com.study.java.domain.User;
import com.study.java.service.UserService;
import com.study.java.service.impl.UserServiceImpl;
import com.study.java.utils.WebUtils;
import com.study.java.web.bean.UserFormBean;

/**
* @Name: ControllerServlet
* @Description: 用户操作控制器
* @Author: XXX
* @CreateDate: XXX
* @Version: V1.0
 */
public class ControllerServlet extends HttpServlet {

    private UserService userService = new UserServiceImpl() ;

    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        String operate = request.getParameter("op") ;
        if("logout".equals(operate)) {
            logout(request, response) ;
        }
        if("login".equals(operate)) {
            login(request, response) ;      
        }
        if("register".equals(operate)) {
            register(request, response) ;
        }
    }

    /**
    * @Name: register
    * @Description: 注册
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: @param request
    * @Parameters: @param response
    * @Parameters: @throws ServletException
    * @Parameters: @throws IOException
    * @Return: void
     */
    private void register(HttpServletRequest request, HttpServletResponse response) 
            throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8") ;
        PrintWriter out = response.getWriter() ;
        //获取表单Bean实例对象
        UserFormBean userFormBean = WebUtils.fillBean(request, UserFormBean.class) ;
        //对页面表单中输入的字段格式进行校验
        if(!userFormBean.validate()) {
            request.setAttribute("userFormBean", userFormBean) ;
            request.getRequestDispatcher("/jsp/register.jsp").forward(request, response) ;
            return ;
        } 
        //对象拷贝：UserFormBean -> UserBean
        User user = WebUtils.copyProperties(User.class, userFormBean) ;
        //注册，保存到xml
        boolean result = userService.register(user) ;
        if(result) {
            //将用户信息保存到session
            HttpSession session = request.getSession() ;
            session.setAttribute("user", user) ;
            out.write("注册成功，2秒后跳转到系统首页！！！") ;
            response.setHeader("Refresh", "2;URL=" + request.getContextPath()) ;
        } else {
            userFormBean.getErrorMsg().put("username", "用户名已存在！") ;
            request.setAttribute("userFormBean", userFormBean) ;
            request.getRequestDispatcher("/jsp/register.jsp").forward(request, response) ;
        }
    }

    /**
    * @Name: login
    * @Description: 登录
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: @param request
    * @Parameters: @param response
    * @Parameters: @throws ServletException
    * @Parameters: @throws IOException
    * @Return: void
     */
    private void login(HttpServletRequest request, HttpServletResponse response) 
            throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8") ;
        PrintWriter out = response.getWriter() ;
        //获取页面请求参数
        request.setCharacterEncoding("UTF-8") ; //设置请求参数内容编码，适用于post提交
        String username = request.getParameter("username") ;
        String password = request.getParameter("password") ;
        User user = userService.login(username, password) ;
        if(user != null) {
            HttpSession session = request.getSession() ;
            session.setAttribute("user", user) ;
            out.write("登录成功，2秒后跳转到系统首页！！！") ;
            response.setHeader("Refresh", "2;URL=" + request.getContextPath()) ;
        } else {
            out.write("用户名或密码错误，登录失败，请重新登录！！！") ;
            response.setHeader("Refresh", "2;URL=" + request.getContextPath() + "/jsp/login.jsp") ;
        }
    }

    /**
    * @Name: logout
    * @Description: 注销
    * @Author: XXX
    * @Version: V1.0
    * @CreateDate: XXX
    * @Parameters: @param request
    * @Parameters: @param response
    * @Parameters: @throws ServletException
    * @Parameters: @throws IOException
    * @Return: void
     */
    private void logout(HttpServletRequest request, HttpServletResponse response) 
            throws ServletException, IOException {
        response.setContentType("text/html;charset=utf-8") ;
        PrintWriter out = response.getWriter() ;
        HttpSession session = request.getSession() ;
        session.removeAttribute("user") ;
        out.write("注销成功，2秒后跳转到系统首页！！！") ;
        response.setHeader("Refresh", "2;URL=" + request.getContextPath()) ;
    }

    public void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        this.doGet(request, response);
    }
}

（3）配置web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" 
    xmlns="http://java.sun.com/xml/ns/javaee" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
  <display-name></display-name>
  <servlet>
    <servlet-name>ControllerServlet</servlet-name>
    <servlet-class>com.study.java.web.controller.ControllerServlet</servlet-class>
  </servlet>

  <servlet-mapping>
    <servlet-name>ControllerServlet</servlet-name>
    <url-pattern>/servlet/ControllerServlet</url-pattern>
  </servlet-mapping>    
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
</web-app>

视图层开发

（1）系统首页：index.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>首页</title>
    <meta http-equiv="pragma" content="no-cache">
    <meta http-equiv="cache-control" content="no-cache">
    <meta http-equiv="expires" content="0">    
    <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    <meta http-equiv="description" content="This is my page">
  </head>

  <body>
    <h1>练习项目</h1>
    <hr/>
    <c:choose>
        <c:when test="${sessionScope.user == null }">
            <a href="${pageContext.request.contextPath }/jsp/register.jsp">注册</a>
            &nbsp;&nbsp;&nbsp;&nbsp;
            <a href="${pageContext.request.contextPath }/jsp/login.jsp">登录</a>
        </c:when>
        <c:otherwise>
            欢迎您！！！${sessionScope.user.username }
            &nbsp;&nbsp;&nbsp;&nbsp;
            <a href="${pageContext.request.contextPath }/servlet/ControllerServlet?op=logout">注销</a>
        </c:otherwise>
    </c:choose>
  </body>
</html>

（2）登录页面：login.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>登录</title>
    <meta http-equiv="pragma" content="no-cache">
    <meta http-equiv="cache-control" content="no-cache">
    <meta http-equiv="expires" content="0">    
      </head>
  <body>
    <form action="${pageContext.request.contextPath }/servlet/ControllerServlet?op=login" method="post">
        用户名：<input type="text" name="username"/><br/>
        密&nbsp;&nbsp;&nbsp;码：<input type="password" name="password"/><br>
        <input type="submit" value="登录"/>
    </form>
  </body>
</html>

（3）注册页面：register.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>注册</title>
    <meta http-equiv="pragma" content="no-cache">
    <meta http-equiv="cache-control" content="no-cache">
    <meta http-equiv="expires" content="0">  
    <script type="text/javascript" 
        src="${pageContext.request.contextPath }/js/Birthday-Calendar.js" ></script>  
  </head>
  <body>
    <form action="${pageContext.request.contextPath }/servlet/ControllerServlet?
                                                        op=register" method="post">
        <table border="1" align="center">
            <tr>
                <td>用户名：</td>
                <td>
                    <input type="text" name="username" 
                           value="${userFormBean.username }">
                    ${userFormBean.errorMsg.username }
                </td>
            </tr>
            <tr>
                <td>密&nbsp;&nbsp;&nbsp;码：</td>
                <td>
                    <input type="password" name="password" 
                    value="${userFormBean.password }">
                    ${userFormBean.errorMsg.password }
                </td>
            </tr>
            <tr>
                <td>确认密码：</td>
                <td>
                    <input type="password" name="repassword" 
                    value="${userFormBean.repassword }">
                </td>
            </tr>
            <tr>
                <td>出生年月：</td>
                <td>
                    <input type="text" name="birthday" 
                    onclick="new Calendar().show(this);" readonly="readonly">
                    ${userFormBean.errorMsg.birthday }
                </td>
            </tr>
            <tr>
                <td>邮&nbsp;&nbsp;&nbsp;箱：</td>
                <td>
                    <input type="text" name="email" 
                    value="${userFormBean.email }">
                    ${userFormBean.errorMsg.email }
                </td>
            </tr>
            <tr>
                <td colspan="2" align="center">
                    <input type="submit" value="提交" />
                    &nbsp;&nbsp;&nbsp;
                    <input type="reset" value="重置" />
                </td>
            </tr>
        </table>
    </form>
  </body>
</html>