Shulou(Shulou.com)06/02 Report--

This article focuses on "what is the method of joint programming between Java and XML". Interested friends may wish to have a look at it. The method introduced in this paper is simple, fast and practical. Next, let the editor take you to learn "what is the method of joint programming between Java and XML"?

Preliminary DOM

DOM is the abbreviation of Document Object Model, that is, the document object model. As mentioned earlier, XML organizes data into a tree, so DOM is an object description of this tree. Generally speaking, it is to build a tree model for XML documents logically by parsing XML documents, and the nodes of the tree are objects. We can access the contents of the XML document by accessing these objects. [@ more@] Let's look at a simple example of how we manipulate an XML document in DOM.

This is an XML document and the object we want to manipulate:

Good-bye serialization, hello Java!

Next, we need to parse the contents of this document into Java objects for the program to use, and with JAXP, we only need a few lines of code to do this. First, we need to establish a parser factory to take advantage of this factory to obtain a specific parser object:

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance ()

The purpose of using DocumentBuilderFacotry here is to create a program that is independent of the specific parser. When the static method newInstance () of the DocumentBuilderFactory class is called, it determines which parser to use based on a system variable. And because all parsers are subject to the interface defined by JAXP, the code is the same no matter which parser is used. So when switching between different parsers, you only need to change the value of the system variable without changing any code. This is the benefit of the factory. For a specific implementation of this factory pattern, see the class diagram below.

DocumentBuilder db = dbf.newDocumentBuilder ()

When you get a factory object, you can use its static method newDocumentBuilder () method to get a DocumentBuilder object that represents a specific DOM parser. But it doesn't matter which parser it is, Microsoft's or IBM's.

We can then use this parser to parse the XML document:

Document doc = db.parse ("c:/xml/message.xml")

The parse () method of DocumentBuilder takes an XML document name as an input parameter and returns a Document object, which represents a tree model of an XML document. All future operations on XML documents have nothing to do with the parser, just operate on this Document object. The specific method of operating on Document is defined by DOM.

Jaxp supports DOM 2 recommended by W3C. If you are familiar with DOM, the following is simple: you only need to make method calls according to the DOM specification. Of course, if you are not clear about DOM, don't worry, we will introduce it in detail later. What you need to know and keep in mind here is that DOM is a model used to describe the data in XML documents, and the whole reason for introducing DOM is to use this model to manipulate the data in XML documents. The DOM specification defines nodes (that is, objects), properties and methods, and we access XML data through the access of these nodes.

Starting with the Document object above, we can start our journey to DOM. Using the getElementsByTagName () method of the Document object, we can get a NodeList object, a Node object represents a tag element in an XML document, and the NodeList object, by name, represents a list of Node objects:

NodeList nl = doc.getElementsByTagName ("message")

What we get from such a statement is everything in the XML document

A list of Node objects corresponding to the tag. We can then use the item () method of the NodeList object to get each Node object in the list:

Node my_node = nl.item (0)

When a Node object is created, the data stored in the XML document is extracted and encapsulated in the Node. In this example, to extract the contents of the Message tag, we usually use the getNodeValue () method of the Node object:

String message = my_node.getFirstChild () .getNodeValue ()

Notice that a getFirstChild () method is also used to get the first child Node object under message. Although there are no child tags or attributes under the message tag other than text, we insist on using the getFirseChild () method here, which is mainly related to the W3C definition of DOM. The W3C also defines the text part of the tag as a Node, so we need to get the Node that represents the text before we can use getNodeValue () to get the content of the text.

Now that we are able to extract the data from the XML file, we can use the data in the right place to build the application.

The following content, we will pay more attention to DOM, for DOM to do a more detailed analysis, so that we can use more handy.

DOM detailed explanation

1. Basic DOM object

There are five basic objects for DOM: Document,Node,NodeList,Element and Attr. The following is a general introduction to the functions and implementation methods of these objects.

Click to enlarge

The Document object represents the entire XML document, and all other Node are included in the Document object in a certain order, arranged into a tree structure. Programmers can get all the contents of the XML document by traversing the tree, which is also the starting point for the operation of XML documents. We always get a Document object by parsing the XML source file before performing subsequent operations. In addition, Document includes methods to create other nodes, such as createAttribut () to create an Attr object. The main methods it contains are:

CreateAttribute (String): creates an Attr object with a given property name, and then uses the setAttributeNode method to place it on top of an Element object.

CreateElement (String): creates an Element object with a given tag name that represents a tag in the XML document, and then you can add attributes or perform other operations on this Element object.

CreateTextNode (String): creates a Text object with a given string, and the Text object represents a plain text string contained in a tag or attribute. If there are no other tags within a tag, the Text object represented by the text within the tag is the only child of the Element object.

GetElementsByTagName (String): returns a NodeList object that contains tags for all given tag names.

GetDocumentElement (): returns an Element object that represents the root node of the DOM tree, that is, the object that represents the root element of the XML document.

The Node object is the most basic object in the DOM structure and represents an abstract node in the document tree. In actual use, the Node object is rarely used, but the child objects of Node objects such as Element, Attr, Text and so on are used to manipulate the document. The Node object provides an abstract, common root for these objects. Although methods to access its child nodes are defined in the Node object, it is important to note that there are some Node child objects, such as the Text object, which do not have child nodes. The main methods contained in the Node object are:

AppendChild (org.w3c.dom.Node): add a child node to this node and place it at the end of all child nodes. If the child node already exists, delete it before adding it.

GetFirstChild (): if the node has a child node, the first child node is returned, and the equivalent getLastChild () method returns the last child node.

GetNextSibling (): returns the next sibling of this node in the DOM tree, and the getPreviousSibling () method returns its previous sibling.

GetNodeName (): returns the name of the node based on the type of node.

GetNodeType (): returns the type of node.

GetNodeValue (): returns the value of the node.

HasChildNodes (): determines whether there is a child node.

HasAttributes (): determines whether this node has attributes.

GetOwnerDocument (): returns the Document object where the node is located.

InsertBefore (org.w3c.dom.Node new,org.w3c.dom.Node ref): inserts another sub-object before a given sub-object.

RemoveChild (org.w3c.dom.Node): deletes a given child node object.

ReplaceChild (org.w3c.dom.Node new,org.w3c.dom.Node old): replaces the given child node object with a new Node object.

The NodeList object, as its name implies, represents a list that contains one or more Node. You can simply think of it as an array of Node, and we can get the elements in the list by method:

GetLength (): returns the length of the list.

Item (int): returns the Node object at the specified location.

The Element object represents the tag elements in the XML document, inherits from Node, and is the most important child object of Node. Attributes can be included in tags, so there are methods in Element objects to access their properties, and any method defined in Node can also be used on Element objects.

GetElementsByTagName (String): returns a NodeList object that contains the tag with the given tag name in the descendant node under this tag.

GetTagName (): returns a string that represents the tag name.

GetAttribute (String): returns the value of the attribute with the given attribute name in the tag. The main thing to need here is that entity attributes are allowed in the XML document, and this method does not apply to these entity attributes. At this point, you need to use the getAttributeNodes () method to get an Attr object for further operations.

GetAttributeNode (String): returns an Attr object that represents a given property name.

The Attr object represents an attribute in a tag. Attr inherits from Node, but because Attr is actually contained in Element, it cannot be regarded as a child of Element, so Attr is not part of the DOM tree in DOM, so getparentNode (), getpreviousSibling () and getnextSibling () in Node will all return null. That is, Attr is actually seen as part of the Element object that contains it, and it does not appear as a separate node in the DOM tree. This should be different from other Node sub-objects when used.

It should be noted that the DOM objects mentioned above are defined by interfaces in DOM and are defined using the language-independent IDL language. Therefore, DOM can actually be implemented in any object-oriented language, as long as it implements the interfaces and functions defined by DOM. At the same time, some methods are not defined in DOM and are expressed by attributes of IDL, which are mapped to corresponding methods when mapped to a specific language.

2.DOM instance

With the above introduction, I believe you know more about DOM. The following example will make you more familiar with DOM.

First of all, let's talk about what this example is going to do. We want to save some URL addresses in a file called link.xml. Through a simple program, we can read and display these URL through DOM, or we can write the added URL address to this XML file in turn. It's simple, but practical, and enough to illustrate most of the uses of DOM.

The XML file itself is not complex, so its DTD is not given. Link.xml:

JSP Insider

Http://www.jspinsider.com

JSP Insider

two

one

2001

A JSP information site.

The makers of Java

Http://java.sun.com

Sun Microsystems

three

one

2001

Sun Microsystem's website.

The standard JSP container

Http://jakarta.apache.org

Apache Group

four

one

2001

Some great software.

The first program we call xmldisplay.java, the specific list of programs can be found in the attachment. The main function is to read the contents of each node in this XML file, and then format the output on System.out. Let's take a look at this program:

Import javax.xml.parsers.*

Import org.w3c.dom.*

This is necessary to introduce the class, because here you are using the XML parser provided by Sun, so you need to introduce the java.xml.parsers package, which contains the concrete implementation of the DOM parser and the SAX parser. The DOM interface defined by W3C is defined in the org.w3c.dom package.

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance ()

DocumentBuilder builder=factory.newDocumentBuilder ()

Document doc=builder.parse ("links.xml")

Doc.normalize ()

In addition to the above, there is a tip: calling normalize () on the Document object removes unnecessary Text Node objects in the XML document that are mapped in the DOM tree as white space in the formatted content. Otherwise, the DOM tree you get may not be what you think it is. This normalize () is more useful, especially when outputting.

NodeList links = doc.getElementsByTagName ("link")

As I just said, white space characters in XML documents are also mapped as objects in the DOM tree. Therefore, sometimes there are problems with calling the getChildNodes method of the Node method directly, and sometimes the expected NodeList object cannot be returned. The solution is to use Element's getElementByTagName (String), and the returned NodeLise is the expected object. You can then use the item () method to extract the elements you want.

For (int iTuno Bandi)

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.