A Remote Procedure Call (RPC) architecture enables an application to start the process of an external procedure while being remote to the system that holds it. In simpler terms, a developer writes code that will call a procedure that could be executed either within the same application or in a remote environment. The developer does not care about the details of this remote action, only the interface it begins to execute and the results of that execution.

The general concept of RPC dates back to the 1970s, when it was described in RFC 707 (http://tools.ietf.org/html/rfc707). Not until the early 1980s, however, were the first implementations of RPC created. Microsoft used its version of RPC (MSRPC) as the basis for DCOM.

RPC fits the classic client/server paradigm for distributed computing. An RPC begins on the client by sending a request to a known remote server so that a specific procedure will be executed, with the client supplying parameters to do so. The code is then executed on the server, and a response is generated and returned back to the client. Here the original application continues to run as though the entire interaction is happening in a local environment. Figure 17-2 shows what this architecture looks like.

Figure 17-2. The RPC architecture

A couple of popular variations on RPC exist in languages such as Java and Microsoft .NET. Java uses the Java Remote Method Invocation (Java RMI) to provide functionality similar to a standard RPC, whereas Microsoft has .NET Remoting to implement RPC for distributed systems in a Windows environment. XML-RPC provides a basic set of tools for creating cross-platform RPC calls, using HTTP as a foundation.

An alternative to RPC is to implement a web service with Service-Oriented Architecture (SOA) concepts, where applications are built with loosely coupled services. These services communicate using a formal definition (typically WSDL, discussed shortly) that is independent of the application’s program language and the operating system in which it resides. The individual services are accessed without any knowledge of their underlying resource dependencies.

SOA has many definitions, and groups such as the Organization for the Advancement of Structured Information Standards (OASIS; http://www.oasis-open.org/home/index.php) and the Open Group (http://www.opengroup.org/) have created formal definitions that can be applied to both technology and business. SOA adoption is thought to help the response time for changing market conditions, something that saves money in businesses. It also promotes reuse among components, a concept that is not new in programming circles. No matter what the belief, definition, or benefits, SOA has the following qualities:

Combining SOA techniques with web services basically gives us the web services protocol stack, a collection of network protocols that are used to define and implement how web services interact with one another.

SOA implementations rely on several standards to implement web services. These include XML, HTTP/HTTPS, SOAP, WSDL, and UDDI. A system does not have to have all of these standards to be considered an SOA, however.

By following standards when using and creating web services, a developer can ensure that the services will work as expected, without having to understand anything about those services. I discuss XML in detail in Appendix A. A thorough discussion of HTTP/HTTPS is outside the scope of this book; however, a good source of information is HTTP: The Definitive Guide by David Gourley and Brian Totty (O’Reilly). The standards that we will discuss here, at least in enough detail to understand their roles in web services, are SOAP, WSDL, and UDDI.

<?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:soap="http://www.w3.org/2001/12/soap-envelope"
soap:encodingStyle="http://www.w3.org/2001/12/soap-encoding">

    <soap:Header>
        <!-- Header information -->
    </soap:Header>

    <soap:Body>
        <!-- Body Information -->
    </soap:Body>

</soap:Envelope>

<?xml version="1.0" encoding="utf-8" ?>
<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"
        xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:xsd="http://www.w3.org/2001/XMLSchema"
        SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
    <SOAP-ENV:Body>
        <namesp1:AsinSearchRequest xmlns:namesp1="urn:PI/DevCentral/SoapService">
            <AsinSearchRequest xsi:type="m:AsinRequest">
                <asin>0596528388</asin>
                <page>1</page>
                <mode>books</mode>
                <tag>associate tag</tag>
                <type>lite</type>
                <dev-tag>developer token</dev-tag>
                <format>xml</format>
                <version>1.0</version>
            </AsinSearchRequest>
        </namesp1:AsinSearchRequest>
    </SOAP-ENV:Body>
</SOAP-ENV:Envelope>

<wsdl:definitions name="nmtoken"? targetNamespace="uri"?>

    <import namespace="uri" location="uri"/>*

    <wsdl:documentation .... /> ?

    <wsdl:types> ?
        <wsdl:documentation .... />?
        <xsd:schema .... />*
        <-- extensibility element --> *
    </wsdl:types>

    <wsdl:message name="nmtoken"> *
        <wsdl:documentation .... />?
        <part name="nmtoken" element="qname"? type="qname"?/> *
    </wsdl:message>

    <wsdl:portType name="nmtoken">*
        <wsdl:documentation .... />?
        <wsdl:operation name="nmtoken">*
           <wsdl:documentation .... /> ?
           <wsdl:input name="nmtoken"? message="qname">?
               <wsdl:documentation .... /> ?
           </wsdl:input>
           <wsdl:output name="nmtoken"? message="qname">?
               <wsdl:documentation .... /> ?
           </wsdl:output>
           <wsdl:fault name="nmtoken" message="qname"> *
               <wsdl:documentation .... /> ?
           </wsdl:fault>
        </wsdl:operation>
    </wsdl:portType>

    <wsdl:binding name="nmtoken" type="qname">*
        <wsdl:documentation .... />?
        <-- extensibility element --> *
        <wsdl:operation name="nmtoken">*
           <wsdl:documentation .... /> ?
           <-- extensibility element --> *
           <wsdl:input> ?
               <wsdl:documentation .... /> ?
               <-- extensibility element -->
           </wsdl:input>
           <wsdl:output> ?
               <wsdl:documentation .... /> ?
               <-- extensibility element --> *
           </wsdl:output>
           <wsdl:fault name="nmtoken"> *
               <wsdl:documentation .... /> ?
               <-- extensibility element --> *
           </wsdl:fault>
        </wsdl:operation>
    </wsdl:binding>
    <wsdl:service name="nmtoken"> *
        <wsdl:documentation .... />?
        <wsdl:port name="nmtoken" binding="qname"> *
           <wsdl:documentation .... /> ?
           <-- extensibility element -->
        </wsdl:port>
        <-- extensibility element -->
    </wsdl:service>

    <-- extensibility element --> *

</wsdl:definitions>

<wsdl:definitions xmlns:typens="http://soap.amazon.com"
        xmlns:xsd="http://www.w3.org/2001/XMLSchema"
        xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
        xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/"
        xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
        xmlns="http://schemas.xmlsoap.org/wsdl/"
        targetNamespace="http://soap.amazon.com" name="AmazonSearch">
    <wsdl:types>
        <xsd:schema xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema"
                targetNamespace="http://soap.amazon.com">
            <xsd:complexType name="ProductLineArray">
                <xsd:complexContent>
                    <xsd:restriction base="soapenc:Array">
                        <xsd:attribute ref="soapenc:arrayType"
                            wsdl:arrayType="typens:ProductLine[]"/>
                    </xsd:restriction>
                </xsd:complexContent>
            </xsd:complexType>
            <xsd:complexType name="ProductLine">
                <xsd:all>
                    <xsd:element name="Mode" type="xsd:string" minOccurs="0"/>
                    <xsd:element name="ProductInfo" type="typens:ProductInfo"
                        minOccurs="0"/>
                </xsd:all>
            </xsd:complexType>
            <xsd:complexType name="ProductInfo">
                <xsd:all>
                    <xsd:element name="TotalResults" type="xsd:string"
                        minOccurs="0"/>
                    <xsd:element name="TotalPages" type="xsd:string"
                        minOccurs="0"/>
                    <xsd:element name="ListName" type="xsd:string"
                        minOccurs="0"/>
                    <xsd:element name="Details" type="typens:DetailsArray"
                        minOccurs="0"/>
                </xsd:all>
            </xsd:complexType>
            <xsd:complexType name="DetailsArray">
                <xsd:complexContent>
                    <xsd:restriction base="soapenc:Array">
                        <xsd:attribute ref="soapenc:arrayType"
                            wsdl:arrayType="typens:Details[]"/>
                    </xsd:restriction>
                </xsd:complexContent>
            </xsd:complexType>
            <xsd:complexType name="Details">
                <xsd:all>
                    <xsd:element name="Url" type="xsd:string" minOccurs="0"/>
                    <xsd:element name="Asin" type="xsd:string" minOccurs="0"/>
                    <xsd:element name="ProductName" type="xsd:string"
                        minOccurs="0"/>
                    <xsd:element name="Catalog" type="xsd:string"
                        minOccurs="0"/>
                    <!-- Edited for length -->
                    <xsd:element name="Authors" type="typens:AuthorArray"
                        minOccurs="0"/>
                    <xsd:element name="ListPrice" type="xsd:string"
                        minOccurs="0"/>
                    <xsd:element name="OurPrice" type="xsd:string"
                        minOccurs="0"/>
                    <xsd:element name="UsedPrice" type="xsd:string"
                        minOccurs="0"/>
                    <xsd:element name="NumberOfPages" type="xsd:string"
                        minOccurs="0"/>
                </xsd:all>
            </xsd:complexType>
            <xsd:complexType name="AuthorArray">
                <xsd:complexContent>
                    <xsd:restriction base="soapenc:Array">
                        <xsd:attribute ref="soapenc:arrayType"
                            wsdl:arrayType="xsd:string[]"/>
                    </xsd:restriction>
                </xsd:complexContent>
            </xsd:complexType>
            <xsd:complexType name="AsinRequest">
                <xsd:all>
                    <xsd:element name="asin" type="xsd:string"/>
                    <xsd:element name="tag" type="xsd:string"/>
                    <xsd:element name="type" type="xsd:string"/>
                    <xsd:element name="devtag" type="xsd:string"/>
                    <xsd:element name="offer" type="xsd:string"
                        minOccurs="0"/>
                    <xsd:element name="offerpage" type="xsd:string"
                        minOccurs="0"/>
                    <xsd:element name="locale" type="xsd:string"
                        minOccurs="0"/>
                </xsd:all>
            </xsd:complexType>
        </xsd:schema>
    </wsdl:types>
    <message name="AsinSearchRequest">
        <part name="AsinSearchRequest" type="typens:AsinRequest"/>
    </message>
    <message name="AsinSearchResponse">
        <part name="return" type="typens:ProductInfo"/>
    </message>
    <portType name="AmazonSearchPort">
        <operation name="AsinSearchRequest">
            <input message="typens:AsinSearchRequest"/>
            <output message="typens:AsinSearchResponse"/>
        </operation>
    </portType>
    <binding name="AmazonSearchBinding" type="typens:AmazonSearchPort">
        <soap:binding style="rpc"
            transport="http://schemas.xmlsoap.org/soap/http"/>
        <operation name="AsinSearchRequest">
            <soap:operation soapAction="http://soap.amazon.com"/>
            <input>
                <soap:body use="encoded"
                    encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
                    namespace="http://soap.amazon.com"/>
            </input>
            <output>
                <soap:body use="encoded"
                    encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
                    namespace="http://soap.amazon.com"/>
            </output>
        </operation>
    </binding>
    <service name="AmazonSearchService">
        <port name="AmazonSearchPort" binding="typens:AmazonSearchBinding">
            <soap:address location="http://soap.amazon.com/onca/soap2"/>
        </port>
    </service>
</wsdl:definitions>

Representational State Transfer (REST) is a method of transporting media primarily over the World Wide Web, though it is not restricted to this. It is designed for any hypermedia system—the Web is just the largest. The term REST comes from Roy Fielding’s 2000 doctoral dissertation about the Web. The term defines architectural principles on transfer over systems, but it is loosely tied to transferring data over HTTP without the use of an additional messaging layer, such as SOAP.

The key components for a RESTful design are as follows:

The World Wide Web is a perfect example of a RESTful implementation, as it can be made to conform to the REST principles. HTML has implicit support for hyperlinks built into the language. HTTP has a consistent method (GET, POST, PUT, and DELETE) to access resources from URIs, methods, status codes, and headers. HTTP is stateless (unless cookies are utilized), has the ability to control caching, utilizes the notion of a client and a server, and is layered so that no layer can know anything about another except for its immediate conversation (connection).

For REST applications, the resource that defines its interface is constrained so that fewer types are defined on the network and more resources are defined. You can think of the interface as verbs, and the content types and resource identifiers as nouns. REST defines the nouns to be unconstrained so that clients do not need knowledge of the whole resource. Figure 17-3 shows the REST triangle of nouns, verbs, and content types.

Figure 17-3. The REST triangle of nouns, verbs, and content types

The architecture we use for the applications we build ultimately depends on the web services with which the architecture will interact. When we know that the only interface to a web service is through SOAP, it might naturally be easier to define the architecture of the application to follow SOA. On the other hand, if the web service is RESTful in nature, building the application to follow REST would more likely be in order. Even more likely, one component of an application will be built one way and another component a different way. The application on the whole takes whatever architectural style is needed for the project (client/server, Model-View-Controller [MVC], etc.), while the components follow their own models to be as efficient as possible.

For the most part, any client request for a web service is handled in one of two ways. Requests are made using a hidden <iframe> or <frame> element to handle the sending and receiving, and then the data is collected from the frames. Or, a call is made to a server script that handles the sending and receiving, and the client gets the data from the server-side script’s response.

Why is this? Simply because of the (necessary) limitations placed on JavaScript with respect to calling pages on different domains. This is our sandbox, which we have seen before in this book. The two methods are simply ways of handling any restrictions a client may have.

There are exceptions, of course—in this case, the exception comes when the web services being contacted reside on the same domain as the page being called.

Up to this point, almost all of our examples of client requests to the server have fit a RESTful-like pattern. Unless there is some huge need for a different method, passing parameters to the server to define action and state is an easy way to implement a web service request. What we need to worry about is getting the data from a web service not located on our domain. The same domain communication will look the same, the server handles all of the requests to other servers, or it is the web service—either way, the request will look the same. Example 17-3 shows what the request will generally look like for all calls for a web service.

/*
 * Example 17-3. The client request for a web service.
 */

new Ajax.Request('amazon.php', {
    method: 'get',
    parameters: { asin: '0596528388' },
    onSuccess: distributeResults
});

Once the server sends back the data—in a format that the client will be expecting, no matter where it is from—it will parse and display the results in whatever manner is necessary. I believe I have covered this enough that I can leave it to your imagination as to what to do. For reference and to get some ideas, look over the chapters in Part II.

Say that five times fast! Seriously, using PHP to access web services is fairly simple. The one detail that is necessary to address is whether the web service interfaces with SOAP or REST. This will determine what our server script will look like.

Think of this server-side script as an intermediary between the client and the web service. The client does not have to speak the web service’s language, and in turn the web service does not have to speak the client’s language. Our server script will handle all of the details. The advantage to this is that the intermediary takes care of all the parsing details instead of the client, which should offer some speed improvements.

PHP has a built-in class extension to the language to handle SOAP. Example 17-4 shows how this works.

<?php
/**
 * Example 17-4. A SOAP request to AWS using PHP.
 *
 * This example shows how to create a SOAP request using PHP's SOAP extension to
 * an AWS method.
 */

/* Create a new instance of the SOAP client class */
$client = new SoapClient('http://soap.amazon.com/schemas2/AmazonWebServices.wsdl'),
/* Create the parameters that should be passed */
$params = Array(
    'asin'      => mysql_real_escape_string($_REQUEST['asin']),
    'type'      => 'lite',
    'tag'       => '[associates id]',
    'devtag'    => '[developer token]'
) ;
/* Call the AWS method */
$result = $client->ASINSearchRequest($params);
?>

SOAP functions are capable of returning one or multiple values. When there is only one value, the return value of the method will be a simple variable type. If multiple values are returned, however, the method will return an associative array of named output parameters.

Example 17-4 calls the ASINSearchRequest( ) method that is available with AWS. Other methods are also available, and each provides different search capabilities should the developer need them. Table 17-1 lists all of the methods available with AWS.

The following is an example of what the SOAP request will return:

Array
(
[Details] => Array
(
[0] => Array
(
[Url] => http://www.amazon.com/gp/product/0596528388%3ftag=[associates id]
%26link_code=xm2%26camp=2025%26dev-t=[developer token]
[Asin] => 0596528388
[ProductName] => Ajax: The Definitive Guide
[Catalog] => Book
[Authors] => Array
(
[0] => Anthony T. Holdener III
)
[ReleaseDate] => 15 January, 2008
[Manufacturer] => O'Reilly Media
[ImageUrlSmall] => http://images.amazon.com/images/P/0596528388.01.THUMBZZZ.jpg
[ImageUrlMedium] => http://images.amazon.com/images/P/0596528388.01.MZZZZZZZ.jpg
[ImageUrlLarge] => http://images.amazon.com/images/P/0596528388.01.LZZZZZZZ.jpg
[ListPrice] => $49.99
[OurPrice] => $32.99
[UsedPrice] => $24.50
[Availability] => Usually ships within 24 hours
)
)

Then there is the REST way of handling things. Fortunately for us, AWS supports both SOAP and REST, so if I do not like the SOAP way of using the web service, I can use the REST methods. First, an XML Link must be created to pass to the AWS service. The structure of the XML Link is:

http://xml.amazon.com/onca/xml3?t=[associates id]&dev-t=[developer token]&
[Search Type]=[Search Term]&mode=books&sort=[Sort]&offer=All&type=[Type]&
page=[Page Number]&f=xml

Table 17-2 lists the parameters needed in the XML Link for it to be complete as far as AWS is concerned. Another cool thing Amazon has available for use with its web services is the ability to create the XML Link using its XML Scratch Pad, found at http://www.amazon.com/gp/browse.html/?node=3427431.

The data from a request of this nature will be an XML document with the following structure:

<Details url="http://www.amazon.com/gp/product/0596528388%3ftag=[associates id]
%26link_code=xm2%26camp=2025%26dev-t=[developer token]">
    <Asin>0596528388</Asin>
    <ProductName>Ajax: The Definitive Guide</ProductName>
    <Catalog>Book</Catalog>
    <Authors>
        <Author>Anthony T. Holdener III</Author>
    </Authors>
    <ReleaseDate>1 January, 2008</ReleaseDate>
    <Manufacturer>O'Reilly Media</Manufacturer>
    <ImageUrlSmall>
        http://images.amazon.com/images/P/0596528388.01.THUMBZZZ.jpg
    </ImageUrlSmall>
    <ImageUrlMedium>
        http://images.amazon.com/images/P/0596528388.01.MZZZZZZZ.jpg
    </ImageUrlMedium>
    <ImageUrlLarge>
        http://images.amazon.com/images/P/0596528388.01.LZZZZZZZ.jpg
    </ImageUrlLarge>
    <ListPrice>$49.99</ListPrice>
    <OurPrice>$31.49</OurPrice>
    <Availability>Usually ships in 24 hours</Availability>
    <UsedPrice>$24.50</UsedPrice>
</Details>

We’ve seen how to parse returned XML using PHP before, and Example 17-5 shows this.

<?php
/**
 * Example 17-5. A REST request to AWS using PHP.
 *
 * This example shows how to create a REST request using PHP to an AWS method.
 */

$assoc_id = '[associate id]';
$dev_token = '[developer token]';

$xml_link = sprintf('http://xml.amazon.com/onca/xml3?t=%s&dev-t=%s&AsinSearch=
%s&mode=books&type=lite&f=xml',
    $assoc_id,
    $dev_token,
    urlencode($_REQUEST['asin'])
);

$results = file_get_contents($xml_link);
?>

Once the server has captured the data, whether the request was from SOAP or REST, it should be formatted in such a way that the client can parse it quickly. Using Example 17-5 as the model for getting the data from the server, all we must do is modify the last part to create an XML document the client will use. Example 17-6 shows what this looks like.

<?php
/**
 * Example 17-6. Gathering the AWS response and formatting it for the client.
 *
 * This example shows how to create a REST request using PHP to an AWS method,
 * and how to parse and format the results.
 */

$assoc_id = '[associate id]';
$dev_token = '[developer token]';

$xml_link = sprintf('http://xml.amazon.com/onca/xml3?t=%s&dev-t=%s'
        .'&AsinSearch=%s&mode=books&type=lite&f=xml',
    $assoc_id,
    $dev_token,
    urlencode($_REQUEST['asin'])
);

$results = file_get_contents($xml_link);
$xml = new SimpleXMLElement($results);

/* Was there a problem with the search query? */
if ($xml->faultstring) {
    $response = '<response code="500">'.$xml->faultstring.'</response>';
} else {
    $response = '<response code="200">';
    $response .= '<title>';
    $response .= '<name>'.$xml->details[0]->ProductName.'</name>';
    $response .= '<author>';
    $authors = '';
    /* Loop through authors and concatenate any names */
    foreach ($xml->details[0]->authors->author as $author) {
        /* Should a comma be added? */
        if (strlen($authors))
            $authors .= ', ';
        $authors .= $author;
    }
    $response .= $authors.'</author>';
    $response .= '<date>'.date('F j, Y',
        strottime($xml->details[0]->ReleaseDate)).'</date>';
    $response .= '<publisher>'.$xml->details[0]->Manufacturer.'</publisher>';
    $response .= '<img_src>'.$xml->details[0]->ImageUrlSmall.'</img_src>';
    $response .= '<availability>'.$xml->details[0]->Availability.'</availability>';
    $response .= '<list_price>'.$xml->details[0]->ListPrice.'</list_price>';
    $response .= '<amazon_price>'.$xml->details[0]->OurPrice.'</amazon_price>';
    $response .= '</title>';
    $response .= '</response>';
}
/*
 * Change the header to text/xml so that the client can use the return string
 * as XML
 */
header('Content-Type: text/xml'),
/* Give the client the XML */
print($response);
?>

We have the data formatted the way we want the server to get it, and it should look something like this:

<response code="200">
    <title>
        <name>Ajax: The Definitive Guide</name>
        <author>Anthony T. Holdener III</author>
        <date>January 1, 2008</date>
        <publisher>O'Reilly Media</publisher>
        <img_src>
            http://images.amazon.com/images/P/0596528388.01.THUMBZZZ.jpg
        </img_src>
        <availability>Usually ships in 24 hours</availability>
        <list_price>$49.99</list_price>
        <amazon_price>$31.49</amazon_price>
    </title>
</response>

Notice that the <response> element has a code attribute attached to it. I am using HTTP status codes to show the status of the request, because passing these codes to the client will help it determine what to show the user. Table 17-3 shows possible codes that could be passed to the client.

Now that the data has been sent to the client, it can be parsed easily and the results can be displayed to the user. Figure 17-4 gives an example of how the client could format the data.

Figure 17-4. An example of the formatted results from an AWS request

One way you can make a feed is by writing a script that visits pages and scrapes data from them. Web scraping is not the noblest way to get data, and it could break laws if you take copyrighted material from a site and use it on yours without proper authorization. Laws vary by state and country, but I recommend avoiding this practice and using more readily available information through syndicated feeds.

Using a syndicated web feed to gather information is a good way to create your own web services to use on your site. Feeds can be pulled down by your server script and then disseminated to clients when the information is requested. This is a good solution for quickly collecting headlines and descriptions from a source that might not provide web services to grab information. The only big disadvantage to using syndicated resources is that you are at the mercy of the provider. Whatever content the provider wishes to place in a feed is what you will get; there is no choice on the developer’s part.

What is good about feeds, however, is that you can find feed aggregators to do some of the work for you. Aggregators basically gather feeds from content providers and aggregate them in a number of ways to make it easier to get data for your application. A good example of this is Google Reader, found at http://www.google.com/reader. This application takes feeds from different sources (in real time) and allows subscribers to customize their choices. Using feeds, you keep your application completely up-to-date.

RSS and Atom

There is nothing new about syndication, RSS, or Atom unless you create a new web service that aggregates feeds and sends them to the client. This creates a service that distributes the information you want without you having to be the keeper of the data (and dealing with all of the hassle that goes along with that).

For example, consider this feed from Yahoo! Weather (http://weather.yahooapis.com/forecastrss?p=62221):

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<rss version="2.0" xmlns:yweather="http://xml.weather.yahoo.com/ns/rss/1.0"
        xmlns:geo="http://www.w3.org/2003/01/geo/wgs84_pos#">
    <channel>
        <title>Yahoo! Weather - Belleville, IL</title>
        <link>
            http://us.rd.yahoo.com/dailynews/rss/weather/Belleville_  _IL/*
http://weather.yahoo.com/forecast/62221_f.html
        </link>
        <description>Yahoo! Weather for Belleville, IL</description>
        <language>en-us</language>
        <lastBuildDate>Tue, 13 Mar 2007 11:55 am CDT</lastBuildDate>
        <ttl>60</ttl>
        <yweather:location city="Belleville" region="IL" country="US" />
        <yweather:units temperature="F" distance="mi" pressure="in" speed="mph" />
        <yweather:wind chill="77" direction="210" speed="14" />
        <yweather:atmosphere humidity="50" visibility="1609"
            pressure="30.07" rising="2" />
        <yweather:astronomy sunrise="7:15 am" sunset="7:05 pm" />
        <image>
            <title>Yahoo! Weather</title>
            <width>142</width>
            <height>18</height>
            <link>http://weather.yahoo.com/</link>
            <url>http://l.yimg.com/us.yimg.com/i/us/nws/th/main_142b.gif</url>
        </image>
        <item>
            <title>Conditions for Belleville, IL at 11:55 am CDT</title>
            <geo:lat>38.5</geo:lat>
            <geo:long>-90</geo:long>
            <link>
                http://us.rd.yahoo.com/dailynews/rss/weather/Belleville_  _IL/*
http://weather.yahoo.com/forecast/62221_f.html
            </link>
            <pubDate>Tue, 13 Mar 2007 11:55 am CDT</pubDate>
            <yweather:condition text="Fair" code="34" temp="77"
                date="Tue, 13 Mar 2007 11:55 am CDT" />
            <description>
                <![CDATA[
                <img src="http://l.yimg.com/us.yimg.com/i/us/we/52/34.gif" /><br />
                <b>Current Conditions:</b><br />
                Fair, 77 F<BR /><BR />
                <b>Forecast:</b><BR />
                Tue - Partly Cloudy. High: 81 Low: 58<br />
                Wed - Partly Cloudy. High: 76 Low: 55<br />
                <br />
                <a href="http://us.rd.yahoo.com/dailynews/rss/weather/
Belleville_  _IL/*http://weather.yahoo.com/forecast/62221_f.html">
                    Full Forecast at Yahoo! Weather
                </a><BR/>
                (provided by The Weather Channel)<br/>
                ]]>
            </description>
            <yweather:forecast day="Tue" date="13 Mar 2007" low="58" high="81"
                text="Partly Cloudy" code="30" />
            <yweather:forecast day="Wed" date="14 Mar 2007" low="55" high="76"
                text="Partly Cloudy" code="30" />
            <guid isPermaLink="false">62221_2007_03_13_11_55_CDT</guid>
        </item>
    </channel>
</rss>

Warning

Be careful when elements in an RSS or Atom feed contain namespace prefixes. These elements are harder to traverse, and usually an XPath solution works best.

A little bit of PHP code can turn this feed into a REST web service without any trouble. Example 17-7 shows how to do this.

Example 17-7. Using feeds to distribute information with PHP

<?php
/**
 * Example 17-7. Using feeds to distribute information with PHP.
 *
 * This example shows how to take an RSS feed and strip out the information
 * desired by the application, giving only a minimal amount of data to the
 * client.
 */

/* Get the RSS feed from Yahoo! for my zip code */
$results = file_get_contents('http://weather.yahooapis.com/forecastrss?p=62221'),
$xml = new SimpleXMLElement($results);

/* Create the XML for the client */
$response = '<response code="200">';
$response .= '<weather>';

/* Create the prefix context for the XPath query */
$xml->registerXPathNamespace('y', 'http://xml.weather.yahoo.com/ns/rss/1.0'),
/* Gather the temperature data */
$temp = $xml->xpath('//y:condition'),

/* Fill in information for the client */
$response .= '<temp>'.$temp[0]['text'].', '.$temp[0]['temp'].' &#176;F</temp>';
$response .= '<img>'.$xml->channel->image->url.'</img>';
$response .= '<link>'.$xml->channel->image->link.'</link>';
$response .= '</weather>';
$response .= '</response>';

/*
 * Change the header to text/xml so that the client can use the return string
 * as XML
 */
header('Content-Type: text/xml'),
/* Give the client the XML */
print($response);
?>

You could easily change this code to point to several different sources, aggregate that information, and then send it out for the client to display. The whole point of this is so that an Ajax call can be made—say, every 15 minutes—to update the application with the latest information. Figure 17-5 gives an example of this.

Figure 17-5. Automatic update of weather data in an application

It is all well and good to collect information from different sources using RSS feeds, but how do you know you are getting what you expect? Feed validation services are available to check the validity of a feed so that you can be more certain that your application will work with it. A good idea is to periodically check a feed’s validity to ensure that your aggregation service is working. Better yet, write an application that does the feed validation for you automatically.

There are a number of feed validators to choose from; here are a few to get you started: