java的XML语法是什么及怎么使用

发布时间：2022-11-09 17:29:49 作者：iii
来源：亿速云阅读：171

Java的XML语法是什么及怎么使用

引言

XML（可扩展标记语言）是一种用于存储和传输数据的标记语言。它被广泛用于配置文件、数据交换、Web服务等领域。Java作为一种强大的编程语言，提供了多种处理XML的方式。本文将详细介绍Java中的XML语法及其使用方法。

XML简介

XML是一种自描述的语言，它使用标签来定义数据的结构。XML文档由元素、属性、文本等内容组成。XML的主要特点包括：

可扩展性：用户可以自定义标签。
自描述性：XML文档的结构和内容可以通过标签来描述。
平台无关性：XML可以在不同的平台和系统之间进行数据交换。

Java中的XML处理

Java提供了多种处理XML的方式，主要包括以下几种：

3.1 DOM解析

DOM（文档对象模型）是一种基于树结构的解析方式。它将整个XML文档加载到内存中，形成一个树状结构，开发者可以通过操作树节点来访问和修改XML数据。

3.2 SAX解析

SAX（简单API for XML）是一种基于事件的解析方式。它逐行读取XML文档，并在遇到特定事件（如开始标签、结束标签等）时触发回调函数。

3.3 StAX解析

StAX（流API for XML）是一种基于流的解析方式。它结合了DOM和SAX的优点，既可以像SAX一样逐行读取XML文档，又可以像DOM一样随机访问XML数据。

3.4 JAXB

JAXB（Java Architecture for XML Binding）是一种将XML文档与Java对象进行绑定的技术。它可以将XML文档转换为Java对象，也可以将Java对象转换为XML文档。

XML语法基础

4.1 XML文档结构

一个典型的XML文档包括以下部分：

XML声明：用于指定XML版本和编码方式。
根元素：XML文档的最外层元素。
子元素：根元素内部的元素。
属性：元素的附加信息。
文本内容：元素内部的文本。

<?xml version="1.0" encoding="UTF-8"?>
<bookstore>
  <book category="cooking">
    <title lang="en">Everyday Italian</title>
    <author>Giada De Laurentiis</author>
    <year>2005</year>
    <price>30.00</price>
  </book>
</bookstore>

4.2 XML元素

XML元素由开始标签、结束标签和内容组成。元素可以嵌套，形成层次结构。

<book>
  <title>Everyday Italian</title>
  <author>Giada De Laurentiis</author>
</book>

4.3 XML属性

XML属性用于为元素提供附加信息。属性必须放在开始标签中，并且以键值对的形式出现。

<book category="cooking">
  <title lang="en">Everyday Italian</title>
</book>

4.4 XML命名空间

XML命名空间用于避免元素和属性的命名冲突。命名空间通过URI来唯一标识。

<root xmlns:h="http://www.w3.org/TR/html4/">
  <h:table>
    <h:tr>
      <h:td>Apples</h:td>
      <h:td>Bananas</h:td>
    </h:tr>
  </h:table>
</root>

4.5 XML注释

XML注释用于在文档中添加注释信息，注释内容不会被解析器处理。

<!-- This is a comment -->
<book>
  <title>Everyday Italian</title>
</book>

Java中的XML生成

5.1 使用DOM生成XML

DOM API提供了创建和修改XML文档的功能。以下是一个使用DOM生成XML的示例：

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.File;

public class DOMExample {
    public static void main(String[] args) {
        try {
            DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder docBuilder = docFactory.newDocumentBuilder();
            Document doc = docBuilder.newDocument();

            // 创建根元素
            Element rootElement = doc.createElement("bookstore");
            doc.appendChild(rootElement);

            // 创建子元素
            Element book = doc.createElement("book");
            rootElement.appendChild(book);

            // 设置属性
            book.setAttribute("category", "cooking");

            // 创建子元素
            Element title = doc.createElement("title");
            title.appendChild(doc.createTextNode("Everyday Italian"));
            book.appendChild(title);

            // 将文档写入文件
            TransformerFactory transformerFactory = TransformerFactory.newInstance();
            Transformer transformer = transformerFactory.newTransformer();
            DOMSource source = new DOMSource(doc);
            StreamResult result = new StreamResult(new File("bookstore.xml"));
            transformer.transform(source, result);

            System.out.println("XML文件生成成功！");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

5.2 使用JAXB生成XML

JAXB提供了将Java对象转换为XML文档的功能。以下是一个使用JAXB生成XML的示例：

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import java.io.File;

public class JAXBExample {
    public static void main(String[] args) {
        Bookstore bookstore = new Bookstore();
        Book book = new Book();
        book.setCategory("cooking");
        book.setTitle("Everyday Italian");
        book.setAuthor("Giada De Laurentiis");
        book.setYear(2005);
        book.setPrice(30.00);
        bookstore.getBooks().add(book);

        try {
            JAXBContext context = JAXBContext.newInstance(Bookstore.class);
            Marshaller marshaller = context.createMarshaller();
            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);

            // 将对象转换为XML并写入文件
            marshaller.marshal(bookstore, new File("bookstore.xml"));
            System.out.println("XML文件生成成功！");
        } catch (JAXBException e) {
            e.printStackTrace();
        }
    }
}

Java中的XML解析

6.1 使用DOM解析XML

DOM解析器将整个XML文档加载到内存中，形成一个树状结构。以下是一个使用DOM解析XML的示例：

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.File;

public class DOMParserExample {
    public static void main(String[] args) {
        try {
            File xmlFile = new File("bookstore.xml");
            DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
            Document doc = dBuilder.parse(xmlFile);
            doc.getDocumentElement().normalize();

            System.out.println("根元素: " + doc.getDocumentElement().getNodeName());
            NodeList nodeList = doc.getElementsByTagName("book");

            for (int i = 0; i < nodeList.getLength(); i++) {
                Node node = nodeList.item(i);
                if (node.getNodeType() == Node.ELEMENT_NODE) {
                    Element element = (Element) node;
                    System.out.println("类别: " + element.getAttribute("category"));
                    System.out.println("标题: " + element.getElementsByTagName("title").item(0).getTextContent());
                    System.out.println("作者: " + element.getElementsByTagName("author").item(0).getTextContent());
                    System.out.println("年份: " + element.getElementsByTagName("year").item(0).getTextContent());
                    System.out.println("价格: " + element.getElementsByTagName("price").item(0).getTextContent());
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

6.2 使用SAX解析XML

SAX解析器逐行读取XML文档，并在遇到特定事件时触发回调函数。以下是一个使用SAX解析XML的示例：

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import java.io.File;

public class SAXParserExample {
    public static void main(String[] args) {
        try {
            File xmlFile = new File("bookstore.xml");
            SAXParserFactory factory = SAXParserFactory.newInstance();
            SAXParser saxParser = factory.newSAXParser();

            DefaultHandler handler = new DefaultHandler() {
                boolean bTitle = false;
                boolean bAuthor = false;
                boolean bYear = false;
                boolean bPrice = false;

                @Override
                public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
                    if (qName.equalsIgnoreCase("title")) {
                        bTitle = true;
                    }
                    if (qName.equalsIgnoreCase("author")) {
                        bAuthor = true;
                    }
                    if (qName.equalsIgnoreCase("year")) {
                        bYear = true;
                    }
                    if (qName.equalsIgnoreCase("price")) {
                        bPrice = true;
                    }
                }

                @Override
                public void characters(char[] ch, int start, int length) throws SAXException {
                    if (bTitle) {
                        System.out.println("标题: " + new String(ch, start, length));
                        bTitle = false;
                    }
                    if (bAuthor) {
                        System.out.println("作者: " + new String(ch, start, length));
                        bAuthor = false;
                    }
                    if (bYear) {
                        System.out.println("年份: " + new String(ch, start, length));
                        bYear = false;
                    }
                    if (bPrice) {
                        System.out.println("价格: " + new String(ch, start, length));
                        bPrice = false;
                    }
                }
            };

            saxParser.parse(xmlFile, handler);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

6.3 使用StAX解析XML

StAX解析器结合了DOM和SAX的优点，既可以逐行读取XML文档，又可以随机访问XML数据。以下是一个使用StAX解析XML的示例：

import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamConstants;
import javax.xml.stream.XMLStreamReader;
import java.io.FileInputStream;

public class StAXParserExample {
    public static void main(String[] args) {
        try {
            FileInputStream fileInputStream = new FileInputStream("bookstore.xml");
            XMLInputFactory factory = XMLInputFactory.newInstance();
            XMLStreamReader reader = factory.createXMLStreamReader(fileInputStream);

            while (reader.hasNext()) {
                int event = reader.next();
                switch (event) {
                    case XMLStreamConstants.START_ELEMENT:
                        if (reader.getLocalName().equals("title")) {
                            System.out.println("标题: " + reader.getElementText());
                        }
                        if (reader.getLocalName().equals("author")) {
                            System.out.println("作者: " + reader.getElementText());
                        }
                        if (reader.getLocalName().equals("year")) {
                            System.out.println("年份: " + reader.getElementText());
                        }
                        if (reader.getLocalName().equals("price")) {
                            System.out.println("价格: " + reader.getElementText());
                        }
                        break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

6.4 使用JAXB解析XML

JAXB提供了将XML文档转换为Java对象的功能。以下是一个使用JAXB解析XML的示例：

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;
import java.io.File;

public class JAXBParserExample {
    public static void main(String[] args) {
        try {
            File xmlFile = new File("bookstore.xml");
            JAXBContext context = JAXBContext.newInstance(Bookstore.class);
            Unmarshaller unmarshaller = context.createUnmarshaller();
            Bookstore bookstore = (Bookstore) unmarshaller.unmarshal(xmlFile);

            for (Book book : bookstore.getBooks()) {
                System.out.println("类别: " + book.getCategory());
                System.out.println("标题: " + book.getTitle());
                System.out.println("作者: " + book.getAuthor());
                System.out.println("年份: " + book.getYear());
                System.out.println("价格: " + book.getPrice());
            }
        } catch (JAXBException e) {
            e.printStackTrace();
        }
    }
}

XML与Java对象的映射

7.1 使用JAXB进行对象映射

JAXB提供了将Java对象与XML文档进行映射的功能。以下是一个使用JAXB进行对象映射的示例：

import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import java.util.List;

@XmlRootElement(name = "bookstore")
public class Bookstore {
    private List<Book> books;

    @XmlElement(name = "book")
    public List<Book> getBooks() {
        return books;
    }

    public void setBooks(List<Book> books) {
        this.books = books;
    }
}

public class Book {
    private String category;
    private String title;
    private String author;
    private int year;
    private double price;

    // Getters and Setters
}

7.2 自定义映射

JAXB允许开发者通过注解自定义Java对象与XML文档的映射关系。以下是一个自定义映射的示例：

import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement(name = "book")
public class Book {
    private String category;
    private String title;
    private String author;
    private int year;
    private double price;

    @XmlAttribute
    public String getCategory() {
        return category;
    }

    public void setCategory(String category) {
        this.category = category;
    }

    @XmlElement
    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    @XmlElement
    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    @XmlElement
    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    @XmlElement
    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}

XML验证

8.1 DTD验证

DTD（文档类型定义）是一种用于定义XML文档结构的语言。以下是一个使用DTD验证XML的示例：

<!DOCTYPE bookstore [
  <!ELEMENT bookstore (book*)>
  <!ELEMENT book (title, author, year, price)>
  <!ATTLIST book category CDATA #REQUIRED>
  <!ELEMENT title (#PCDATA)>
  <!ELEMENT author (#PCDATA)>
  <!ELEMENT year (#PCDATA)>
  <!ELEMENT price (#PCDATA)>
]>

8.2 XML Schema验证

XML Schema是一种用于定义XML文档结构的语言。以下是一个使用XML Schema验证XML的示例：

”`xml xs:complexType xs:sequence xs:complexType xs:sequence /xs:sequence /xs:complexType </xs:element