XML and Web Services

CPTR304:Internet Authoring
Henry Osborne

 subset of Standard Generalized Markup Language (SGML)
 design goal is to be as powerful and flexible as SGML with

less complexity

 XHTML is a reformulation of HTML 4 as XML

2

 Entity: a named unit of storage
 Element: data object that is part of an XML document
 Document Type Declaration: A set of instructions that

describes the accepted structure and content of an XML file

 Well-formed: An XML document is considered well-formed

when it contains a single root level element

 Valid: An XML document is valid when it is both well-

formed and obeys a referenced DTD

3

A well-formed XML document can be as simple as:
<?xml version="1.0"?>
<message>Hello, World!</message>

Here is an example of a valid version of the same document:
<!DOCTYPE message SYSTEM "message.dtd">

4

In this case, an external DTD is loaded from local
storage, but the declarations may also be listed
locally:
<!DOCTYPE message [
<!ELEMENT message (#PCDATA)>
]>

5

 Creating XML is a free-form process, without any rigid constraints

except those that define a well-formed document

 Names of tags, attributes, and the order in which they appear are all

up to the creator of the XML document

 XML is a language that provides the means for describing data
 Each tag and attribute should consist of a descriptive name for the

data contained within it

 XML lends itself well to the transportation of data between disparate

systems

6

Title

Author

Publisher

ISBN

The Moon Is a Harsh Mistress

R. A. Heinlein

Orb

0312863551

Fahrenheit 451

R. Bradbury

Del Rey

0345342968

The Silmarillion

J.R.R. Tolkien

G Allen & Unwin

0048231398

1984

G. Orwell

Signet

0451524934

Frankenstein

M. Shelley

Bedford

031219126X

7

<library>
<book isbn="0345342968">
<title>Fahrenheit 451</title>
<author>R. Bradbury</author>
<publisher>Del Rey</publisher>
</book>
<book isbn="0048231398">
<title>The Silmarillion</title>
<author>J.R.R. Tolkien</author>
<publisher>G. Allen &
Unwin</publisher>
</book>
<book isbn="0451524934">
<title>1984</title>

<author>G. Orwell</author>
<publisher>Signet</publisher>
</book>
<book isbn="031219126X">
<title>Frankenstein</title>
<author>M. Shelley</author>
<publisher>Bedford</publisher>
</book>
<book isbn="0312863551">
<title>The Moon Is a Harsh
Mistress</title>
<author>R. A. Heinlein</author>
<publisher>Orb</publisher>
</book>
</library>

8

 parsing is done by SimpleXML internally using the DOM

parsing model

 XML document must be well-formed, or SimpleXML will emit

warnings and fail to parse it

 SimpleXML supports only version 1.0 documents
 All objects created by SimpleXML are instances of the

SimpleXMLElement class

10

Procedural

OOP

// Load an XML string
$xmlstr = file_get_contents(’library.xml’);
$library = simplexml_load_string($xmlstr);

// Load an XML string
$xmlstr = file_get_contents(’library.xml’);
$library = new SimpleXMLElement($xmlstr);

// Load an XML file
$library = simplexml_load_file(’library.xml’);

// Load an XML file
$library = new SimpleXMLElement(’library.xml’, NULL, true);

11

$library = new SimpleXMLElement(’library.xml’, NULL, true);
foreach ($library->book as $book)
{
echo $book[’isbn’] . "n";
echo $book->title . "n";
echo $book->author . "n";
echo $book->publisher . "nn";
}
12

foreach ($library->children() as $child)
{
echo $child->getName() . ":n";
foreach ($child->attributes() as $attr)

// Get attributes of this element

{
echo ’ ’ . $attr->getName() . ’: ’ . $attr . "n";
}
foreach ($child->children() as $subchild)

// Get children

{
echo ’ ’ . $subchild->getName() . ’: ’ . $subchild . "n";
}
echo "n";

}

13

 W3C standardized language that is used to access and

search XML documents

 Used extensively in Extensible Stylesheet Language

Transformations (XSLT) and forms the basis of XML Query
(XQuery) and XML Pointer (XPointer)

 XPath can be a very complex language

14

// Search the root element
$results = $library->xpath(’/library/book/title’);

foreach ($results as $title)
{
echo $title . "n";

}
// Search the first child element
$results = $library->book[0]->xpath(’title’);

foreach ($results as $title)
{
echo $title . "n";
}
15

 PHP 5.1.3 introduced two new methods to

SimpleXML that now give it the power it needs to
create and modify XML documents:
 SimpleXMLElement::addChild()
 SimpleXMLElement::addAttribute()

16

$book = $library->addChild(’book’);
$book->addAttribute(’isbn’, ’0812550706’);
$book->addChild(’title’, "Ender’s Game");
$book->addChild(’author’, ’Orson Scott Card’);
$book->addChild(’publisher’, ’Tor Science Fiction’);
header(’Content-type: text/xml’);
echo $library->asXML();

17

 allows a provider to associate certain element and

attribute names with namespaces identified by URIs
 This qualifies the elements and attributes, avoiding
any potential naming conflicts when two elements
of the same name exist yet contain different types
of data

18


<library xmlns="http://example.org/library"
xmlns:meta="http://example.org/book-meta"
xmlns:pub="http://example.org/publisher"
xmlns:foo="http://example.org/foo">
<book meta:isbn="0345342968">
<title>Fahrenheit 451</title>
<author>Ray Bradbury</author>

<pub:publisher>Del Rey</pub:publisher>
</book>
</library>

19

There are two ways to import documents into a DOM tree; the first is by loading them
from a file:
$dom = new DomDocument();
$dom->load("library.xml");
Alternatively, you can load a document from a string—which is handy when using
REST Web services:

$dom->loadXML($xml);

21

Just as simply, you can save XML documents using:
 DomDocument::save() (to a file),
 DomDocument::saveXML() (to a string),

 DomDocument::saveHTML() (also to a string, but saves

an HTML document instead of an XML file), and
 DomDocument:saveHTMLFile() (to a file in HTML
format).

22

$dom->load(’library.xml’);
// Do something with our XML here
// Save to file
if ($use_xhtml) {
$dom->save(’library.xml’);
} else {
$dom->saveHTMLFile(’library.xml’);
}
// Output the data
if ($use_xhtml) {
echo $dom->saveXML();
} else {
echo $dom->saveHTML();
}
23

$xpath = new DomXPath($dom);

$xpath->registerNamespace("lib",
"http://example.org/library");
$result = $xpath->query("//lib:title/text()");
foreach ($result as $book) {
echo $book->data;
}

24


$book = $dom->createElement("book");
$book->setAttribute("meta:isbn", "0973589825");

$title = $dom->createElement("title");
$text = $dom->createTextNode("php|architect’s
Guide to PHP Design Patterns");

$title->appendChild($text);
$book->appendChild($title);
25

$author = $dom->createElement("author","Jason
E. Sweat");
$book->appendChild($author);
$publisher = $dom>createElement("pub:publisher", "Marco Tabini
& Associates , Inc.");
$book->appendChild($publisher);
$dom->documentElement->appendChild($book);

26

$dom = new DOMDocument();
$result = $xpath->query("//lib:book");
$result->item(1)->parentNode->insertBefore($result>item(1), $result->item(0));

27

$result->item(1)->parentNode->appendChild($result>item(0));

28

$clone = $result->item(0)->cloneNode();

$result->item(1)->parentNode->appendChild($clone);
29

$node = $dom->createElement(’ns1:somenode’);
$node->setAttribute(’ns2:someattribute’, ’somevalue’);
$node2 = $dom->createElement(’ns3:anothernode’);
$node->appendChild($node2);
// Set xmlns: *attributes
$node->setAttribute(’xmlns:ns1’, ’http://example.org/ns1’);
$dom->appendChild($node);
30

$node = $dom->createElementNS(’http://example.org/ns1’,
’ns1:somenode’);

$node->setAttributeNS(’http://example.org/ns2’,
’ns2:someattribute’, ’somevalue’
);
$node2 = $dom->createElementNS(’http://example.org/ns3’,
’ns3:anothernode’);
$node3 = $dom->createElementNS(’http://example.org/ns1’,
’ns1:someothernode’);

31

This results in the following output:
<ns1:somenode xmlns:ns1="http://example.org/ns1"

xmlns:ns2="http://example.org/ns2"
xmlns:ns3="http://example.org/ns3"
ns2:someattribute="somevalue">

<ns3:anothernode xmlns:ns3="http://example.org/ns3"/>
<ns1:someothernode/>
</ns1:somenode>
32

 You can import SimpleXML objects for use with DOM by using

dom_import_simplexml()

$sxml = simplexml_load_file(’library.xml’);
$node = dom_import_simplexml($sxml);
$dom->importNode($node, true);
33

 The opposite is also possible, by using the aptly-named

simplexml_import_dom() function
$dom->load(’library.xml’);

$sxe = simplexml_import_dom($dom);
echo $sxe->book[0]->title;
34

 noted for being extensible and interoperable
 characterized by their use of XML to communicate

between and among disparate systems
 three popular types of Web Services in use today:
 XMLRPC
 SOAP (the successor to web services!XML-RPC), and

 REST

36

 a remote procedure call (RPC) protocol which uses XML to

encode its calls and HTTP as a transport mechanism

 created in 1998 by Dave Winer of UserLand Software and

Microsoft

 As new functionality was introduced, the standard evolved

into what is now SOAP.

37

An example of a typical XML-RPC request:

<methodCall>
<methodName>examples.getStateName</methodName>

<params>
<param>
<value><i4>40</i4></value>

</param>
</params>
</methodCall>

38

 previously an acronym that stood for Simple Object Access

Protocol

 powerful tool for communication between disparate systems
 allows the definition and exchange of complex data types in

both the request and response

 providing a mechanism for various messaging patterns, the

most common of which is the Remote Procedure Call (RPC)

39

SOAP request made to the Google Web Search service:
try
{
$client = new SoapClient(’http://api.google.com/GoogleSearch.wsdl’);
$results = $client->doGoogleSearch($key, $query, 0, 10, FALSE, ’’, FALSE, ’’, ’’,
’’);
foreach ($results->resultElements as $result)
{
echo ’<a href="’ . htmlentities($result->URL) . ’">’;
echo htmlentities($result->title, ENT_COMPAT, ’UTF-8’);
echo ’</a><br/>’;
}
}
catch (SoapFault $e)
{
echo $e->getMessage();
}

40

$client = new
SoapClient(’http://api.google.com/GoogleSearch.wsdl
’, array(’trace’ => 1));

$results = $client->doGoogleSearch($key, $query, 0,
10, FALSE, ’’, FALSE, ’’, ’’, ’’);
echo $client->__getLastRequestHeaders();
echo $client->__getLastRequest();

41

class MySoapServer
{
public function getMessage()
{
return ’Hello, World!’;
}
public function addNumbers($num1, $num2)
{
return $num1 + $num2;
}
}
42

$options = array(’uri’ => ’http://example.org/soap/server/’);
$server = new SoapServer(NULL, $options);
$server->setClass(’MySoapServer’);
$server->handle();

43

$options = array(
’location’ => ’http://example.org/soap/server/server.php’,
’uri’ => ’http://example.org/soap/server/’

);
$client = new SoapClient(NULL, $options);
echo $client->getMessage() . "n";
echo $client->addNumbers(3, 5) . "n";
44

 Representational State Transfer
 Web service architectural style in which the focus is on the

presence of resources in the system

 Each resource must be identified by a global identifier—a

URI

 Clients communicate with the REST service by HTTP, and

the server responds with a representation of the resource

 Representation is often in the form of HTML or XML
45

$u = ’username’;
$p = ’password’;
$fooTag = "https://{$u}:{$p}@api.del.icio.us/v1/posts/all?tag=foo";
$bookmarks = new SimpleXMLElement($fooTag, NULL, true);
foreach ($bookmarks->post as $bookmark)
{
echo ’<a href="’ . htmlentities($bookmark[’href’]) . ’">’;
echo htmlentities($bookmark[’description’]);
echo "</a><br />n";
}
46

XML and Web Services

More Related Content

What's hot (20)

Viewers also liked (8)

Similar to XML and Web Services (20)

More from Henry Osborne (20)

Recently uploaded (20)

XML and Web Services

Editor's Notes