AJAX: A Fresh Look at Web Development
Sunday 18th of March 2018 12:40:33 AM Couldn't it be nice if you could turn your plain old Web pages into something more exciting? Isn't it time to inject some life into your decade-old Web technologies? If you feel the need for the fresher, richer, and more interactive Web experience, get to know AJAX.

If you use Google Maps or the Gmail Web client you actually have experienced an AJAX-based solution already. AJAX, which stands for asynchronous JavaScript and XML, is a conglomerate technology that enables dynamic, asynchronous behavior on Web pages without the need for annoying browser page refreshes. Utilizing AJAX, users can interact with Web pages almost as they would with rich clients.

AJAX is a simple technology that all the major browsers already support. As you will see shortly, the only prerequisite for AJAX implementation is knowledge of JavaScript.

How AJAX Works

If you've used the Gmail Web client or Google Maps you probably noticed that you can scroll over the map or spell check the typed text, respectively, without page submits. AJAX, the technology behind this behavior, handles the requested operations in _JavaScript and asynchronously invokes the server-side operations that provide the desired results.

Introducing the XMLHttpRequest
At the core of AJAX technology is a JavaScript object: XMLHttpRequest. This object has been supplied through browser implementations—first through Internet Explorer, and then through Mozilla/Safari. At the time of writing this article, version 8 of the Opera browser supplied a compatible implementation. However, Opera has had a somewhat rocky history in terms of the stability of its XMLHttpRequest implementation.

AJAX in Action

In order to demonstrate AJAX, this tutorial implements a common portal scenario: e-mail message previewing. ( for the application source code.) Most Web portals allow portal users to preview the contents of their e-mail inboxes from the main page. In order to view the body text in their messages, however, users need to click on the individual messages—one by one, refreshing the page each time. This case study demonstrates how to practically accomplish richer Web client behavior, similar to what rich clients like Outlook Express and Mozilla Thunderbird provide, utilizing the existing Web technologies of AJAX.

It builds a portlet that provides not only access to the list of most recent messages but also previews of the messages themselves—all from the main page without needing to refresh.

In order to access message content, you need a server component that provides access to the messages. This demonstration utilizes a trivial servlet that will serve as a simulator, providing a comma-separated representation of the messages: from, subject, date, and message body:

protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
if ( req.getParameter( "message_id" ).equals( "1" ) ){
resp.getWriter().println( "John Doe,Greetings,10-10-2005,Hi.I am doing good" );
}else if ( req.getParameter( "message_id" ).equals( "2" ) ){
resp.getWriter().println( "Joanna Doe,Hi,10-10-2005,Document is complete." );
}else if ( req.getParameter( "message_id" ).equals( "3" ) ){
resp.getWriter().println( "Joanna Doe,Hi,10-10-2005,Meeting is at 3." );
A:link {background: white; color: blue;}
A:hover {background: blue; color: white;}

These styles will cause anchors to "reverse" in color when the mouse pointer hovers over them, as illustrated in Figure 10-9.

Figure 10-9

Figure 10-9. Hover styles

As a matter of fact, the rule for A:hover would be used while the pointer hovers over any anchor, not just a hyperlink. While some other pseudo-classes, like :link and :visited , are constrained to the ... }else{ resp.getWriter().println( ",NA ,NA ,NA ,Nothing to display" ); }//end else }//end service

Your portal will have a mail preview portal window/portlet with a simplistic inbox listing on the left side and the preview pane on the right side. As you mouse over the message on the left, the preview pane makes the server call and displays the message text—in real time—utilizing AJAX.

Step 1: Creating Web Mail Preview Portlet
Figure 1. Web Page That Simulates a Typical Web Mail Portlet

To begin, create the Web page that simulates the look and feel of a typical Web mail portlet and incorporates JavaScript onMouseOver events that trigger AJAX calls (see Figure 1).

In this case, "onMouseOver" events are attached to table fields (TD) that contain names of the e-mail senders. This choice of data fields and the triggering events for AJAX calls are strictly for illustrative purposes:

<form name="inbox">
<table style="previewTable">
<thead id="tableHeader">
<tr class="even">
<td onMouseOver="displayMessageBody(1)">John Doe</td>
<td onMouseOver="displayMessageBody(2)">Joanna Doe</td>
<td>Status of the report</a></td>
<tr class="even">
<td onMouseOver="displayMessageBody(3)">Jim Doe</td>
<td>Meeting is today</td>
<div id="preview">
<input id="messageBody"class="message" type="textarea" READONLY value=""/>

Notice that the input field "messageBody" is the one that will be populated by the method displayMessageBody, which takes the message ID as a parameter. An AJAX call will use this parameter to request the message details from the server. (Complete source for this application is available for download. Please see resources)

Step 2: Making an AJAX Call
The key element of this implementation is an AJAX call. In the following code, notice how different browser implementations require different instantiation methods for the XMLHttpRequest object:

function getHTTPRequestObject() {
var xmlHttpRequest;
@if (@_jscript_version >= 5)
try {
xmlHttpRequest = new ActiveXObject("Msxml2.XMLHTTP");
} catch (exception1) {
try {
xmlHttpRequest = new ActiveXObject("Microsoft.XMLHTTP");
} catch (exception2) {
xmlhttp = false;
xmlhttpRequest = false;
@end @*/
if (!xmlHttpRequest && typeof XMLHttpRequest != 'undefined') {
try {
xmlHttpRequest = new XMLHttpRequest();
} catch (exception) {
xmlHttpRequest = false;
return xmlHttpRequest;
var httpRequester = getHTTPRequestObject(); // Create the xml http object on the page load

This code utilizes Internet Explorer annotations to instantiate an AJAX object. Other browsers executing this script will simply ignore the annotated sections of the getHTTPRequestObject() function. Keep in mind that your browser must support JavaScript 1.5 and above.

Step 3: Asynchronous Loading of the Content
This step implements the asynchronous invocation of the Web resources. The following code illustrates the exact steps required for the asynchronous loading of the Web resources from the JavaScript function:

var couldProcess = false;
function displayMessageBody( messageID ) {
idToDisplay = messageID
if (!couldProcess && httpRequester) {
httpRequester.open("POST", serverSideURL + escape(messageID), true);
httpRequester.onreadystatechange = processResponse;
couldProcess = true;

The method displayMessageBody accepts the ID of the message to display. It specifies how the XMLHttpRequest object should access the URL by passing the following three parameters:

  • The method POST or GET
  • The URL, plus any escaped parameters (In this case, you pass only an ID. To specify multi-parameter URLs, use the standard URL query string notations and always escape.)
  • A Boolean flag indicating whether the call should be executed in an asynchronous fashion

The method also sets the content-processing method processResponse as a callback, which is invoked when the content from the URL loads.

Step 4: Processing the Results
The previously mentioned method processResponse is invoked as a callback. It takes the output from the XMLHttpRequest object, parses it, and assigns it to the page object(s):

function processResponse() {
if ( httpRequester.readyState == COMPLETE ) {//this is a locally declared constant, its
if ( httpRequester.responseText.indexOf('invalid') == -1 ) {
var values = httpRequester.responseText.split(","); // parse the server response
document.getElementById('messageBody').value = values[3];//pick the fourth value
couldProcess = false;

HttpRequester.readyState is an indicator that declares the completion of the URL code. It can take the following values:

  • 0 = uninitialized
  • 1 = loading
  • 2 = loaded
  • 3 = interactive
  • 4 = complete (This demo focuses on this state.)
  • Notice that the response is accessed as textual content. XMLHttpRequest can easily retrieve non-XML text, as well as XML content.

    If you needed to retrieve XML content, the line would read responseXML and you would access it as XML DOM object. This versatility of text formats is welcome news because XML could be overkill for simple data retrieval scenarios like the one described here.

    Step 5: Improving the Robustness of the AJAX Application
    Any extensive use of JavaScript inevitably raises concerns about the robustness and reliability of an application that heavily relies on this very relaxed and forgiving scripting language. With AJAX, the issue is even more complicated. AJAX makes remote calls, which introduce an additional dimension of complexity and the opportunity for errors—especially considering that built-in support for server-side error conditions is very limited.

    With all this in mind, here are some immediate error-prevention suggestions:

    • Make sure that your application can function in a bare bones mode, even without the AJAX.
    • Verify response codes from the AJAX calls before the further processing of the results.XMLHttpRequest API supports HTTP codes (200, 400, ...). These can be accessed via the status property (along with the statusText property, which holds the message associated with the status of the response):
      if ( httpRequester.readyState == 4) {
      if ( httpRequester.status == 200) {
      } else {

    AJAX Implementation: An Art of Tradeoffs

    Many programmers consider JavaScript a sub-optimal programming solution because of its lacking debugging methods and its error-prone, weak-typed programming model. With this in mind, it is fair to say that AJAX is a solution of trade-offs. You trade the safety of the more robust languages like Java or C# for the presentational attractiveness and the innovative appeal of this JavaScript-based technology.

    Hopefully, the popularity of AJAX and the increasing use of JavaScript will prompt browser producers to further innovate the JavaScript objects and incorporate mechanisms that make JavaScript objects a bit more compatible, safer to use, and easier to debug.

    In the meantime, I see AJAX as an immediate candidate for the new generation of Internet portals and interactive applications. With AJAX, Internet news portals such as Yahoo, Google News, or MSN will allow users to access all areas of interest—including specific details—from the same portal page.

    The promise of rich clients that can be implemented by leveraging existing Web technologies and Internet infrastructure as-is is attractive. Interactive communication applications already have adopted AJAX—Google uses it for its ultra-popular Gmail e-mail client—and I expect this trend to continue.

    One advantage that software development teams will enjoy is this technology's accessibility and flat learning curve. As previously mentioned, it is available on all modern browsers. Also, it does not require advanced programming skills like J2EE or .NET, yet it can produce impressive and effective results that will appeal to end users.

    element, there is a larger uppercase letter wherever an uppercaseletter appears in the source and a small uppercase wherever there isa lowercase letter in the source. This may remind you rather stronglyof text-transform:
    uppercase, withthe only real difference that here, the uppercase letters are ofdifferent sizes. That's true, but the reason thatsmall-caps is declared using a font property isthat some fonts have a specific small-caps face. Thus, a fontproperty is used to select that face.

    better to define certain limits for the size of the height and width? Limiting width and height

    Should it become necessary ordesirable, you can place limits on an element's width andheight by using the following CSS2 properties, which I'll referto as the min-max properties.

    XML documents are also quite naturally retrieved from a persistence layer (databases, file systems, XML stores). This lends XML to be used in real world applications where the information being used by different parts of a system is the most important thing.

    XML is platform independent, textual information

    Information in an XML document is stored in plain-text. This might seem like a restriction if were thinking of embedding binary information in an XML document. There are several advantages to keeping things plain text. First, it is easy to write parsers and all other XML enabling technology on different platforms. Second, it makes everything very interoperable by staying with the lowest common denominator approach. This is the whole reason the web is so successful despite all its flaws. By accepting and sending information in plain text format, programs running on disparate platforms can communicate with each other. This also makes it easy to integrate new programs on top of older ones (without rewriting the old programs), by simply making the interface between the new and old program use XML.

    For example, if you have an address book document stored in an XML file, created on a Mac, that you would like to share with someone who has a PC, you can simply email them the plain text address book XML document. This cant be done with binary encoded information which is totally platform (and program) dependent.

    Another example is web enabling legacy systems. It is very feasible to create a Java web ennoblement application server that simply uses the services provided by the underlying legacy system. Instead of rewriting the legacy system, if the system can be made to communicate results and parameters through XML, the new and old system can work together without throwing away a company's investment in the legacy system.

    UL LI {list-style-image: url(big-ohio.gif);}
    Figure 7-82

    Figure 7-82. Using really big images as bullets

    You should usually provide a fallback for the bullet type. Do this just in case your image doesn't load, or gets corrupted, or is in a format that some user agents might not be able to display (as is the case in Figure 7-83). Therefore, you should always define a backup list-style-type for the list:

    If you want an exact match, you can use an ordinary attribute selector. Thus, the following rule:

    <P CLASS="driving directions" >This is a side note (and it's green).</P>

    If you aren't quite so concerned about exact matching, you can string class selectors together. This is a new feature of CSS2, and with this approach, you can match a class attribute with a value of driving directions in this way: