Thoughts by Techxplorer

Recently I had to create a batch of XML files to export data from one system for import into another. As I have done for the past two years I wrote the solution using the PHP programming language.

The basic structure of the XML was like this:

<root_node>
    <data_node att_1="value" att_2="value">
        data value
    </data_node>
</root_node>

The att_1 attribute defined the type of data element and the att_2 attribute defined the sub type.

The way I approached the task was to use the DOM extension in PHP5. The DOM extension provides the functionality necessary to manipulate XML using the API defined by the Document Object Model specification. I needed some code that would:

1. Start the XML document
2. Add the root node to the document
3. Add a number of data_nodes, sanitising the data along the way
4. Give me an XML string for writing to a file

Starting the XML document

To start the XML document I used code like this:

// start the XML document
$xml_dom = new DOMDocument('1.0', 'UTF-8');

Line 02 of the code above creates a new instance of the DOMDocument class. This is the container object for my XML, I also specify the XML version ‘1.0′ and the encoding ‘UTF-8′.

Adding the root node to the document

// add the root node
$element = $xml_dom->createElement('root_node');
$root_node = $xml_dom->appendChild($element);

Line 02 above uses the createElement method to create an instance of the DOMElement class. This will be used as the root node of the XML file that I’m generating.

Line 03 of the code adds the element to the DOMDocument object. As it was the first node added it became the root node of the document.

Adding the Data Nodes

Adding the data nodes was going to be a repetative task. Essentially executing the same operation again and again using different values for the attributes and the actual data. I also was going to need to undertake the same basic data sanitising tasks for each new node. With this in mind, creating a function to do the work made the most sense.

My function looked like this:

function add_node(&$xml_dom, &$root_node,
  $type, $sub_type, $value) {

 // sanitise the value
 $value = trim($value);
 $value = htmlentities($value, ENT_NOQUOTES);

 // add the value
 $node = $xml_dom->createElement('data_node', $value);
 $node->setAttribute('type', $type);
 $node->setAttribute('sub_type', $sub_type);
 $root_node->appendChild($node);

}

Line 01 of the code above defines the add_node function.

The function takes a number of parameters. The first two parameters are passed by reference and are the instance of the DOMDocument class and the root node element that were created in the first two sections of code.

By passing these two parameters by reference I can use the function to act upon the same XML document with each call of the function.

Lines 04 and 05 sanitise the value before it is added to the XML. First any extraneous white space is removed, and then any characters that should be represented as character entities are encoded as such. For example ‘&’ becomes ‘&’.

Line 08 creates an new instance of the DOMElement class to represent the data_value node.

Line 09 uses the setAttribute method to add the ‘type’ attribute with a value specified by the $type variable.

Line 10 uses the setAttribute method to add the ’sub_type’ attribute with a value specified by the $sub_type variable.

Lastly line 11 adds the new data_value node to the root node of the XML document.

By breaking this functionality out into a seperate function I can loop through the data I’m exporting and add the nodes as necessary.

Getting the XML String

The last task was to get the finalised XML so that I could write it to a file. To do this you use the saveXML function like this:

$xml_string = $xml_dom->saveXML();

There are many other ways of outputing XML in PHP but I felt this gave me the most flexibility with the least stress. For example if I was building the XML string manually I would have needed to keep track of opening and closing tags etc.