- 2.1 Not a Mockup
- 2.2 A Technique Without a Name
- 2.3 What Is Ajax?
- 2.4 An Ajax Encounter of the First Kind
- 2.5 An Ajax Encounter of the Second Kind
- 2.6 An Ajax Encounter of the Third Kind
- 2.7 The Shape of Things to Come
- 2.8 Summary
This chapter is from the book
This chapter is from the book
This chapter is from the book
2.5 An Ajax Encounter of the Second Kind
As flexible and cross-browser capable as the "hidden frames" method of implementing Ajax is, all that has been accomplished is the "AJ" part of Ajax. Which is sort of like the sound of one hand clapping, and that usually means that Igor has been slacking off again. Thankfully, there's another part—eh, make that technology—available: XML. The problem with XML is that it has developed a reputation of being difficult; however, it doesn't have to be. Just keep in mind that, in those situations, code has a tendency to follow you around, like Igor.
2.5.1 XML
In its simplest form, XML is nothing more than a text file containing a single well-formed XML document. Come to think of it, the same is pretty much true in its most complex form as well. Looking past all of the hype surrounding XML, it is easy to see that XML is merely the text representation of selfdescribing data in a tree data structure. When this is understood, all that is left are the nitty-gritty little details, like "What's a tree data structure?" and "How exactly does data describe itself?"
A tree data structure is built of nodes, with each node having only one node connected above it, called a parent node. The sole exception to this rule is the root node, which has no parent node. Nodes can also have other nodes connected below, and these are called child nodes. In addition, nodes on the same level that have the same parent node are called children. Figure 2-2 is a graphical representation of a tree data structure.
)
Figure 2-2 Tree data structure
Figure 2-2 can also be represented as the XML document shown in Listing 2-4.
Listing 2-4. XML Representation of the Same Information as in Figure 2-2
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<library>
<book>
<series>The Wonderland Gambit</series>
<title>The Cybernetic Walrus</title>
<author>Jack L. Chalker</author>
</book>
<book>
<series>The Wonderland Gambit</series>
<title>The March Hare Network</title>
<author>Jack L. Chalker</author>
</book>
<book>
<series>The Wonderland Gambit</series>
<title>The Hot-Wired Dodo</title>
<author>Jack L. Chalker</author>
</book>
</library>
The nodes shown in Listing 2-4 are called elements, which closely resemble HTML tags. And like HTML tags, start tags begin with < while end tags begin with </. However, unlike HTML tags, all XML tags either must have a closing tag or be self-closing or must be empty elements. Self-closing tags are recognizable by the ending />; if the forward slash was omitted, the document would not be a well-formed XML document. In addition, to all elements being either closed or self-closing, the tags must always match up in order. This means that the XML document in Listing 2-5 is well formed but the XML document in Listing 2-6 is not well formed. In a nutshell, "well formed" means that there is a right place for everything. Feet are a good example of this: Imagine if Igor used two left feet; the monster wouldn't be well formed and wouldn't be able to dance, either.
Listing 2-5. A Well-Formed XML Document
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<one>
<two>
<three>
<four/>
</three>
</two>
</one>
Listing 2-6. An XML Document That Is Not Well Formed
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<one>
<two>
<three>
<four/>
</two>
</three>
</one>
As neat and nifty as the hidden frames method of communicating with the server is, the addition of an XML document provides another option, XMLHTTP, or, as some refer to it the XMLHttpRequest object. Note all those capital letters, which are meant to indicate that it is important. The XMLHttpRequest object sends information to and retrieves information from the server. Although it doesn't have to be, this information is usually in the form of XML and, therefore, has the advantage of being more compact than the usual HTML that the server sends. Just in case you're interested, this was the means of communication for that page that I had handwritten and was using during the "it doesn't blink" fiasco.
2.5.2 The XMLHttpRequest Object
Unlike the hidden frames approach, in which the unload/reload cycle is still there but is tucked out of the way, using the XMLHttpRequest object means finally saying good-bye to the unload/reload cycle that we've all come to know and loathe. This means that, in theory, if not in practice, a single page could conceivably be an entire website. Basically, it's a load-and-go arrangement.
In theory, the original page loads and a user enters information into a form and clicks submit. A JavaScript event handler sends the user's information to the server via XMLHTTP and either waits penitently for a response (synchronous) or sets an event handler for the response (asynchronous). When the response is received, the JavaScript takes whatever action that it is programmed to, including updating parts of the page, hence the lack of an unload/reload cycle or "blink." This is great theory, but a theory is pretty useless if it cannot be put into practice; let's take a look in Listings 2-7 and 2-8 at how this can be implemented from a client-side perspective.
Listing 2-7. Example Ajax Web Page
<html>
<head>
<title>AJAX Internet Explorer Flavor</title>
<script language="javascript">
var dom = new ActiveXObject('MSXML2.FreeThreadedDOMDocument.3.0');
var objXMLHTTP = new ActiveXObject('Microsoft.XMLHTTP');
/*
Obtain the XML document from the web server.
*/
function initialize()
{
var strURL = 'msas.asmx/getTime';
objXMLHTTP.open('POST',strURL,true);
objXMLHTTP.onreadystatechange = stateChangeHandler;
try
{
objXMLHTTP.send();
}
catch(e)
{
alert(e.description);
}
}
/*
Handle server response to XMLHTTP requests.
*/
function stateChangeHandler()
{
if(objXMLHTTP.readyState == 4)
try
{
dom.loadXML(objXMLHTTP.responseText);
document.getElementById('time').innerText =
dom.selectSingleNode('time').text;
}
catch(e) { }
}
</script>
</head>
<body onload="initialize()">
<div id="time"></div>
</body>
</html>
Listing 2-8. XML Document
<?xml version="1.0" encoding="utf-8" ?> <time>3:30 PM</time>
If this were CSI, Columbo or The Thin Man, now is the time when the hero explains how the deed was done. It goes something like this: The HTML page loads, which causes the onload event handler, initialize, to fire. In this function, the XMLHttpRequest object's open method is invoked, which only sets the method (POST), gives the relative URL of a web service, and states that the request will be asynchronous (true). Next, the onreadystatechage event handler is set; this is the function that handles what to do when the web service responds. Finally, the send method of the XMLHttpRequest object is invoked, sending our request on its merry way.
When a response is received from the web service, the stateChangeHandler is fired. You've probably noticed the test of the readyState property. The reason for this is that there are more than one possible readyState values, and we're interested in only four, complete. When the response is complete, the result is loaded into an XML document, the appropriate node is selected, and the HTML is updated.
Listings 2-7 and 2-8 could be considered by some a pure example of Ajax. Unfortunately, the way it is currently coded, browsers other than Microsoft Internet Explorer would have real issues with it. What sort of issues? The code simply won't work because of differences in how XML and the XMLHttpRequest object work in various browsers. This doesn't mean that this form of Ajax is an IE-only technology; it simply means that careful planning is required to ensure cross-browser compatibility.
On the subject of compatibility, I don't want to scare you off, but let me point out that the more advanced the client-side coding is, the more likely it is that there will be issues. The majority of these issues are merely little annoyances, similar to flies buzzing around. These "flies" aren't fatal, but it is a good idea to keep these things in mind.