百科 教育 动画 游戏 博览 网址 金融 搜搜 资料 新闻
触屏版

close ◇ 读取数据,请稍候 Loading...

.: Welcome to flymote.com [flymot.com] :.

网页太慢?试试: 或 [ 刷新 ]




  »

◆ 其它资料:.
Parsing XML With DOMXML And PHP(799)
采用PHP的用户认证(800)
Zend Engine2.0版本设计蓝图概览(802)
MVC模式的PHP实现(802)
PHP5对象模型深度探索 之 对象复制(803)
PHP5对象模型深度探索(804)
XML in PHP 5 - What's New?(804)
Head-to-Head: PHP vs. ASP.NET(804)
用PHP制作饼图调查表(804)
SMTP类,支持附件(多个),支持HTML(804)

Parsing XML With DOMXML And PHP

2005-06-20   Mitchell Har      阅读: 799   【本类别其它资料】 【资料库首页
上一篇 收藏 评论 打印 收藏夹 发布 下一篇

〖Parsing XML With DOMXML And PHP〗
Author: Mitchell Harper

This is a printable version of "Parsing XML With DOMXML And PHP". For the complete online version, please visit http://www.devarticles.com/content.php?articleId=44 
________________________________________
Page 1: Introduction
Extensible Mark-up Language (XML) has just about made its impression everywhere: B2B, B2C, as a replacement for .INI files, to aid with data abstraction and transportation, etc. There are a huge number of companies that offer some sort of content over the web in the form of XML, such as news headlines, weather conditions, traffic reports, etc. 

When we're talking about data manipulation and implementation with a reference to PHP, most people will automatically assume some sort of interaction with a MySQL database. MySQL has become synonymous with PHP, just like Oracle has become synonymous with Java. MySQL is great, but we can make our data more readily available over the web in the form of XML. 

Two benefits of transporting data across the web in the format of XML spring into mind: its cross-platform availability, and its language-neutral syntax: as long as an XML document is available for download from a web site or FTP server, we can parse that document through PHP and then do whatever we like (subject to copyright laws) with that data. 

In this article I'm going to give you the 101 on how to parse XML documents using the DOMXML library in PHP. I will discuss setting up the XML parser, loading and parsing documents. Once we've covered enough solid ground, I will show you how to implement a real-time XML feed from devArticles.com, which you can then use on your site. 

To get the most out of this article and its coding samples, you should be running a Windows/Linux/Unix web server with the latest version of Apache installed. You can download Apache for Windows, Linux and Unix for free from http://apache.org. 

Because this article describes how to actually parse XML documents and not what XML is, you should have a fairly substantial knowledge of the XML language syntax already (If you don’t, then refer to some of the books at the end of this article). You should also be proficient with PHP.
Page 2: What is the DOMXML parsing method?
The DOMXML (Document Object Model Extensible Mark-up Language) is one of two ways to parse an XML document. The DOM method treats an XML file as a complete entity, which contains related items in a hierarchical structure. Using the DOM method, we can reference XML nodes using parent/child relationships, loops and associative arrays of related elements. 

The DOMXML method loads the entire XML document into memory and organizes each and every element so that they are easily accessible using a DOM-compliant XML parser. If you've ever worked with XML on a Windows system, then you will be familiar with the MSXML library, which is a great example of a DOM-compliant XML parser. 

If we have an XML document that looks like this: 

<?xml version="1.0"?> 
<document
  <child> 
    <another_child/> 
  </child> 
</document

... then this would be represented in-memory using a DOM-compliant XML parser like this: 

document 
  child 
    another_child 

As you can see, the document is hierarchically structured, and it's very easy to differentiate between parent and child nodes (In our example, the "child" node is both a parent (to the "another_childelement) and child (to the "documentelement)). 

Another commonly used XML parsing method is SAX (Simple API for XML). SAX-compliant parsers are event-based and have a data-centric view of XML documents, meaning that they focus on the data parts of the document, and not its structure. SAX parsers process an XML document from top to bottom and fire events when a specific condition is encountered, such as the start of an element, the end of an element, the starting of character data, etc. For SAX parsers to work, your application/script must implement callback functions to "catch" the events fired by the parser and handle them accordingly. 

Because SAX-compliant XML parsers don't load the complete XML document into memory beforehand, they are extremely fast and efficient. SAX-compliant XML parsers are ideal when working with huge XML files or streams of continuous XML data, because there is no limit on what that documents size can be. 

Processing an XML document with a DOM-compliant XML parser is extremely easy compared to using a SAX-compliant parser, and this will be the implementation method described throughout this article. If you want more information on how to use Expat (A PHP-compatible SAX-compliant XML parsing engine written in C), then take a look at http://www.zend.com/zend/art/parsing.php. 

Making sure DOMXML is installed 
Before we can continue with this article, we must make sure that we have the DOMXML parser installed and configured on our Apache web server. 

For Unix/Linux Users: 
DOMXML is bundled with the latest version of PHP, however it isn't enabled by default. To enable it, you'll need to change into the directory where PHP is installed and re-configure PHP using the following commands: 

./configure --with-dom --with-apache=../apache_1.3.12 
make 
make install 

Remember to change "../apache_1.3.12" to the directory where you installed Apache (You can find this directory with the "where apache" command). 

For Windows NT/2000 Users: 
You’ll need to install the DOMXML functionality add-on for Apache, which is available here. The zip file contains three files: libxml2.dll and iconb.dll need to be extracted to the \winnt\system32 directory, and php_domxml.dll needs to be extracted to your extensions directory, which is c:\php\extensions by default. 

Next, you'll need to modify your PHP.INI file so that it loads the extension DLL automatically. You'll find your PHP.INI file in the \winnt directory by default. Firstly, you'll want to make sure your extensions directory is set correctly. Look for the line starting "extension_dir = " and make sure it's set to "c:\php\extensions". The value should be surrounded by double quotes. 

Next, look for the line starting ";extension=php_domxml.dll" and take away the semi-colon from the front; the semi-colon acts as a comment in the INI file. Once you restart Apache, the DOMXML DLL will load into memory automatically, giving you programmatic access to it from within PHP. 

Now that we know what DOMXML is and have actually configured/installed it, let's get to work and begin with some simple XML parsing!
Page 3: Parsing a simple XML document
Example One 
Consider the following XML document

<?xml version="1.0"?> 
<website> 
<url>http://www.devarticles.com</url> 
</website> 

To extract the contents of the <url> node, we would use the following PHP code: 

<?php 

$theXML 
"<?xml version='1.0'?>"
$theXML .= " <website><url>"
$theXML .= " http://www.devarticles.com"
$theXML .= " </url></website>"

$xmlDoc xmldoc($theXML); 
$root $xmlDoc->root(); 

$node array_shift($root->children()); 
echo 
$node->content

?> 

We start by creating a string that contains our XML. The xmldoc() function creates an object that contains our hierarchically structured and validated XML data. If our XML was not valid, then the xmldoc() function would spit an error.
One of the great things about using the DOMXML parser is that you can just as easily load a local or remote file, using the xmldocfile() function instead: 

$xmlDoc = xmldocfile("/htdocs/xml/sample.xml"); 

OR 

$xmlDoc = xmldocfile("http://www.mysite.com/sample.xml"); 

All XML documents have a single root element, which is the starting point of the documents content. In our example, it's the <website> element. We retrieve the root element with the root() function, like this: 

$root = $xmlDoc->root(); 

Once we have access to the root element, we use its children() function to return a list of its child nodes as an associative array. The array_shift() function pops the first item off the array and returns it as an associative array. Its "content" key/value pair will contain the URL that we're after, and we use the echo command to write it to the browser window: 

$node = array_shift($root->children()); 
echo $node->content;
Page 4: Parsing Example 2
In example one, the elements in our XML document didn't contain any attributes. Let's parse some XML that contains attributes: 

<?php 

$theXML 
"<?xml version='1.0'?>"
$theXML .= " <people>"
$theXML .= " <person id='13' dob='13/07/82'>"
$theXML .= " Mitchell Harper"
$theXML .= " </person>"
$theXML .= " <person id='14' dob='20/08/1960'>"
$theXML .= " Bodger Dodger"
$theXML .= " </person>"
$theXML .= " </people>"

$xmlDoc xmldoc($theXML); 
$root $xmlDoc->root(); 
$people $root->children(); 

while(
$person array_shift($people)) 

if(
$person->name == "person"

echo 
"<b>Person Found:</b><br> "
echo 
"Name: " $person->content "<br>"
echo 
"Id: " $person->getattr("id") . "<br>"
echo 
"DOB: " $person->getattr("dob") . "<br><br>"


?> 

If you copy-paste this code into a file named "example2.php" and run it through your browser, you can see our XML string contains the details of two people, each persons details were stored in a <person> element

Parsing the XML is a little different this time. We load and parse the XML string as normal, however we assign each child node of the documents root element, <people>, to an associative array in the $people variable: 

$xmlDoc = xmldoc($theXML); 
$root = $xmlDoc->root(); 
$people = $root->children(); 

We use the $people associative array to loop through each of the root elements classes that it contains. The "name" key/value pair returns the name of the current node that we are working with. We only want to work with <person> nodes, so we use a simple "if" block to take care of that: 

if($person->name == "person") 

Each <person> node contains two attributes and a child text node, which contains the person's name. To extract the person's id and date of birth attributes, we use the getattr() function, passing it the name of the attribute whose value we're after: 

echo "Id: " . $person->getattr("id") . "<br>"; 
echo "DOB: " . $person->getattr("dob") . "<br><br>"; 

One import thing to note about the DOMXML parser is that it's very fussy with spaces. For example, if we had this XML string: 

<blah> <node/> </blah> 

Then each space between the nodes would be treated as a text node, thus our XML document would contain five elements instead of three. To correct this, just remove the spaces between each node: 

<blah><node/></blah> 

As you can see from the two examples described above, XML nodes are represented as a set of associative arrays and classes through the DOMXML library. Before we move onto the next section however, I strongly suggest that you take a look at this link. It's is part of PHP's manual and contains a tonne of information about using DOMXML from within PHP, including how to create and append nodes, how to access class attributes and how to instantiate new DOMXML classes programmatically.
Page 5: Putting our DOMXML knowledge to good use
Now that we're versed with some practical ways to parse and extract meaningful data from XML documents, let's take a look at how we can create something useful with what we've learnt. 

Open up a new web browser window and go here. This is an XML file, and it contains a list of the ten most recent articles published on our site. Each <article> element contains the details of one article. I created this XML file due to a lot of public interest in our articles. I had received multiple requests for content automation from our site, and this XML file was the result. 

If you're wondering how the XML file is generated, then it’s really quite easy: Every time we add/update an article, a background process named "UpdateXMLDoc" is executed. This process grabs the ten most recent articles from our MySQL database and formats their details into XML using simple string concatenation. 

What we're going to do now is create a PHP script that will retrieve this XML file remotely, load it as an XML object and display each article as a hyper linked field in a HTML table. The PHP script is a tad bit big to post in its entirety, however it's available as part of the support material from the last page of this article if you’d like to download it and use it on your site. I'll focus on the more important aspects of the code from here on in. 

$xmlDoc = @xmldocfile("http://www.devarticles.com/devarticles_recent.xml") or die("Couldn't get XML data"); 

Firstly, we load the remote XML file using the xmldocfile() function. The function call is prefixed with the "@" symbol, which will stop PHP from spitting errors if they occur. If the function call fails, the die method will write an error to the browser and terminate the script. 

$nodeRoot = $xmlDoc->root(); 
$childNodes = $nodeRoot->children(); 

These two lines should be familiar to you by now. They simply get a reference to the XML documents root element and all of its child nodes as associative arrays. 

while($node = array_shift($childNodes)) 

if($node->name == "article") 


Skipping down the script a bit, we load each of the roots child elements and pop them off the array, one at a time. We're only concerned with the <article> nodes, because they contain the information about each article. 

for($i = 0; $i < sizeof($nodeArray); $i++) 
if($nodeArray[$i]->content <> " ") 


Next, we setup a for loop to run through each <article> node in the XML document. As I mentioned earlier, if you leave spaces between each element, then the space is treated as a text node. We use an if block to skip any blank nodes. 

We use a switch command to workout which field we're dealing with in the loop. Each field corresponds to a child node for the <article> node in our XML file. We save each fields value to a temporary variable: 

switch($nodeArray[$i]->name) 

case "title": 

$title = $nodeArray[$i]->content; 
break; 

case "url": 

$url = $nodeArray[$i]->content; 
break; 

case "doc_type": 

$docType = $nodeArray[$i]->content; 
break; 

case "summary": 

$summary = $nodeArray[$i]->content; 
break; 



Lastly, we use these variables to form the basis of a HTML <td> tag. I've used a bit of CSS to add some MouseOver creative flair to each <td> tag: 

<tr> 
<td bgcolor="#FFEFCE" onMouseOver="this.style.backgroundColor='#FFFFC0'" onMouseOut="this.style.backgroundColor='#FFEFCE'"> 

<p style="margin-top:5; margin-bottom:5; margin-left:10; margin-right:10"> 

<a target="_blank" href="<?php echo $url?>"> 
<font face="verdana" color="black" size="1"> 
<?php echo $title?> 
</font> 
</a> 
</td> 
</tr> 

This script is complete, and only needs a small amount of work to integrate with any existing site. 
Page 6: Conclusion
Parsing XML with PHP is a task that will allow you to give your applications more diversity, flexibility and portability. If you run a content-drive website, have you thought about offering some of your content to other sites in the form of XML? If you haven’t, I'd recommend that you do. It's a great way to get some extra traffic to your site and also some free brand-based promotion too! 

Of course this article only teaches you the basics of parsing XML with DOMXML, and I will be writing an article describing how to use the SAX-compatible Expat parser in the near future. 

Take a look at the links and books shown below if you'd like to learn more about using XML with PHP.
责任编辑:

【最近的搜索】:

上一篇 收藏 评论 打印 收藏夹 发布 下一篇
平均得分 0, 共 0 人评分
1 2 3 4 5 6 7 8 9 10
CopyRight(c) 2007 - 2017 All Rights Reserved  【赣ICP备12001042号】
触屏版 | Archiver 20171122 01:38 | 简介 | 帮助 | 留言 | 关于 | 360网站安全检测平台