World Wide Tutorial

Introduction
JDOM is a Java API independently developed by Sun Microsystems. It can handle XML data more simply than with conventional API. Its use is convenient for any Java developer and is based on XML API Sun.
Sun Microsystems (Comment on the JSR-102 Approval Ballot)
In general we tend to prefer to avoid adding new APIs to the Java platform which replicate the functionality of existing APIs. However JDOM does appear to be significantly easier to use than the earlier APIs, so we believe it will be a useful addition to the platform.
You can download the binaries here.

Objective of this article
You learn in this article to manipulate given XML with Java and API JDOM. We will study the possibilities of this API through simple examples. We will learn to create a simple XML file, go to his tree, modify its content.

1. The origins of JDOM
1.1. Description SAX
SAX is an acronym for Simple API for XML.
Such events parser uses to steer the treatment of an XML file. An object (handler called in English) is to implement specific methods defined in an interface of the API to provide treatments to achieve: based on events, the parser calls these methods.
To learn more about SAX, visit the official website.
JDOM uses collections SAX parser for XML files.

1.2. Description DOM
DOM is an acronym for Document Object Model. It is a W3C specification to propose an API that allows model, navigate and manipulate an XML document. The main role of DOM is to provide a memory representation of an XML document in the form of a tree of objects and to allow manipulation (tee, research and update).

Starting from this representation (the model), DOM proposes to browse the document, but also to be able to modify it. The latter is one of the most interesting aspect of DOM.
DOM is set to be independent of the language in which it will be implemented. DOM is a specification that will be used, must be implemented by a third party. DOM is not specific to Java.
The DOM parser for JAVA is the most widely Xerces you can find here.
JDOM uses DOM to manipulate the elements of a specific Document Object Model (created by a manufacturer based on SAX).
JDOM can therefore build documents, navigate their structure, in addition, modify or delete their content.

1.3. JDOM Why?
A logical question that can arise at this stage of the article: But what JDOM brings us more?
The simplicity! It is indeed very hard to develop complex applications around XML DOM, who remember it, has not been developed specifically for Java.
Let's now look at all possibilities for JDOM through simple examples.

2. Creates an XML file with JDOM
2.1. Downloading and installing the API JDOM
You need as a first step download the latest version of JDOM available at this address: http://www.jdom.org/dist/binary/. Then, to make available the file / build / jdom.jar, placing it in your classpath.

2.2. Create a simple tree
The creation of an XML file from scratch is very simple. Suffice it to build each component can be added to each other in a logical manner. A node is an instance of org.jdom.Element.
We therefore begin by creating a class JDOM1 who will take responsibility for creating the tree follows:
XML file
<personnes> <etudiant classe="P2"> <name> CynO </ name> <etudiant> <personnes>

JDOM1.java
import java.io. *;
import org.jdom .*;
import org.jdom.output .*;
public class JDOM1
(
    / / We'll start our tree by creating the root XML
    / / to be here "people".
    static Element root = new Element ( "people");
    / / It creates a new document based on JDOM root that we have just created
    org.jdom.Document static document = new Document (root);
    public static void main (String [] args)
    (
       / / It creates a new Element on the student and adds
       / / time qu'Element root
       Element student = new Element ( "student");
       racine.addContent (student);
       / / It creates a new attribute class and it adds to student
      / / by using the setAttribute
       Attribute class = new Attribute ( "class", "P2");
       etudiant.setAttribute (class);
       / / It creates a new Element name, he assigns the text
       / / and it adds time qu'Element of student
       Element name = new Element ( "name");
       nom.setText ( "CynO");
       etudiant.addContent (name);
       / / The following two methods will be defined later in the article
       display ();
       records ( "Exercice1.xml");
    )
)

2.3. Show and save its XML file

JDOM1.java
/ / Add these two methods in our class JDOM1
static void display ()
(
try
(
/ / It uses a classic display with getPrettyFormat ()
XMLOutputter exit = new XMLOutputter (Format.getPrettyFormat ());
sortie.output (document System.out);
)
catch (java.io.IOException e) ()
)

static void record (String file)
(
try
(
/ / It uses a classic display with getPrettyFormat ()
XMLOutputter exit = new XMLOutputter (Format.getPrettyFormat ());
/ / Note that simply create an instance of FileOutputStream
/ / argument with the file name to make the serialization.
sortie.output (document, new FileOutputStream (file));
)
catch (java.io.IOException e) ()
)
After execution here is the result (display on the standard output and content of the file "Exercice1.xml").

Exercice1.xml
<? xml version = "1.0" encoding = "UTF-8"?>
<personnes>
<etudiant classe="P2">
<name> CynO </ name>
</ Student>
</ persons>
We will see in Part III how to work on an existing document, browse the tree and its filter elements.

3. Browse an XML file
3.1. Parser an XML file
Parser an XML file is to transform an XML file into a tree JDOM.
We will use it to the manufacturer SAXBuilder based, as its name suggests, the SAX API.
First, create the following file in the directory containing your future class JDOM2:

Exercice2.xml
<? xml version = "1.0" encoding = "UTF-8"?>
<persons>
<Student class="P2">
<name> CynO </ name>
<prenoms>
<firstname> Nicolas </ first name>
<firstname> Laurent </ first name>
</ prenoms>
</ Student>
<Student class="P1">
<name> Superwoman </ name>
</ Student>
<Student class="P1">
<name> Don Corleone </ name>
</ Student>
</ persons>
Our goal here is to display in a first time the names of all students.
We will create for it a new class: JDOM2.

JDOM2.java
import java.io. *;
import org.jdom .*;
import org.jdom.input .*;
import org.jdom.filter .*;
import java.util.List;
import java.util.Iterator;
public class JDOM2
(
org.jdom.Document static document;
Static Element root;
public static void main (String [] args)
(
/ / It creates an instance of SAX Builder
SAX Builder sxb = new SAX Builder ();
try
(
/ / It creates a new document JDOM argument with the XML file
/ / The parsing is complete;)
sxb.build document = (new File ( "Exercice2.xml"));
)
catch (Exception e) ()
/ / It initiates a new root element with the root element of the document.
root = document.getRootElement ();
/ / Method defined in section 3.2. this article
afficheALL ();
)
)

3.2. Browse a tree
We will use this method in two classes belonging to the framework Collection (java.util package):
java.util.List
java.util.Iterator
We will create a list based on nodes of our students tree then we will go through an iterator.

JDOM2.java
/ / Add this method to class JDOM2
static void afficheALL ()
(
/ / It creates a List containing all the nodes "student" of the Element root
List listEtudiants = racine.getChildren (student);
/ / It creates an Iterator on our list
Iterator i = listEtudiants.iterator ();
while (i.hasNext ())
(
/ / It recreates the current Element each turn loop in order to
/ / able to use methods of the Element as:
/ / select a node son, edit text, etc. ...
Element current = (Element) i.next ();
/ / It displays the name of the current element
System.out.println (courant.getChild ( "name"). GetText ());
)
)
A performance you should see CynO, Superwoman and Don Corleone.