Before you can access the Flickr API from your Java code, you need to register for a Flickr API key. Requests for data to the Flickr API require you to pass your API key as a parameter. The Flickr development team uses these API keys to keep track of how often their APIs are being used and for what purposes. Flickr API keys are provided free for noncommercial use, including internal development and testing. If you plan to use your Flickr API key for a commercial project, the Flickr team provides you a key after reviewing your application's intended functionality and use of their data, usually within a few weeks of your application.

Along with the API Key, you receive a key known as the Shared Secret. This key is typically used for Flickr services that require some sort of authentication.

To obtain a Flickr API key, follow these steps:

Figure 15.4. On the API Key Authentication Setup page, copy your Shared Secret and then save it in the text file where you saved your API key. You need to use the Flickr API in your applications.

As mentioned previously, the flickrj Java library contains a set of Java classes that map to the Flickr API. The ArtWeather mashup uses this API to search for photos on the Flickr Web site.

You can download flickrj at http://sourceforge.net/projects/flickrj/. As of this writing, the most recent version of flickrj is 1.1. To download flickrj, follow these steps:

Figure 15.5. The flickrj project page on the SourceForge Web site

Figure 15.6. Currently, there's only one version of flickrj available to download: flickrj 1.1.

Figure 15.7. The flickrj 1.1 release is available to download in a couple of different formats on the download page.

The weather mashup is configured as a typical Spring Web MVC project in Eclipse. You create all the source code as well as the configuration files and Ant build files used to build and deploy the application to JBoss within this Eclipse project. In the weather mashup application, a single Spring controller receives the ZIP code parameter from the client, retrieves the Yahoo! Weather RSS data and the Flickr photo data, packages it all up, and then returns the needed information to the client in a JSP view.

To create the Eclipse project, follow these steps:

Figure 15.8. The New Project selection screen in Eclipse is the first step in creating a new project.

Figure 15.9. The New Spring Project dialog box contains settings for creating a new Spring project.

The libraries needed by this Web application need to be placed in a lib folder below the web/WEB-INF folder. There are five library JAR files that need to be added to the lib folder by using Eclipse's Import from File system dialog box:

You will open the Import from File system dialog box several times. Each time, the steps are the same. To open the Import from File system dialog box, follow these steps:

Figure 15.11. The Import Select dialog box allows you to import resources for your project from a variety of sources.

Use the previous steps whenever you need to open the Import File system dialog box to add libraries to the web/WEB-INF/lib folder. First, add the Spring Framework core library and the Spring Web MVC library by following these steps:

Figure 15.12. The Import File system dialog box lets you bring resources located on your computer into your project. Resources are copied from their original locations into your project's directory structure.

Next, add the JSTL and Jakarta tag library JAR files by following these steps:

Finally, add the Flickr API JAR file by following these steps:

The libraries used by the Web application are now in place. Eclipse also needs to have some of these libraries and one other library on the project's build path to compile the code for the application. To add the required libraries to the build path, follow these steps:

The commons-httpclient.jar file contains the HttpClient Java class, which the controller uses to call the Yahoo! Weather RSS service to retrieve the weather data. Because this JAR file is part of the JBoss distribution, it's not necessary to bundle it in the web/WEB-INF/lib directory of your Web application, but Eclipse does need to reference it on the project's build path.

Figure 15.14. The JAR Selection dialog box lets you select JARs that are external to your Eclipse project to add to the build path. This is useful for adding JARs that are needed only at compile time, not runtime.

The application consists of a single service and a utility class. The utility class is used in parsing the XML retrieved from the Yahoo! Weather RSS feed. The service receives an XML block from this Web service. You can find the XML format of the Yahoo! Weather RSS feed on the Yahoo! developers' site at http://developer.yahoo.com/weather/. This XML structure contains a number of tags, but this application uses information from only a few of them.

To traverse the XML block returned from the RSS call, the application uses XPath expressions. XPath expressions are a way of traversing an XML block by using a language that looks much like a directory path in Windows. The JDK includes classes that allow you to construct XML documents and then construct XPath expressions to find values in those documents. Because the structure of the XML returned from the RSS request has a known structure, XPath expressions are a great way to get to specific values in the XML.

The first class needed by the application is a class that implements one of the XML interfaces in the JDK: NamespaceContext. One of the tags in the RSS XML that contains information needed by the application is <yweather:forecast>. The yweather portion of this tag is known as the prefix that stands for an XML namespace. A namespace is a way of grouping XML that belongs to a specific area of functionality. You've already seen examples of namespaces in use in some of the JSP views in this book. The JSTL core tag library uses the namespace prefix c. When you see the tag <c:out> in a JSP page, it means the out tag of the c namespace. Namespaces are defined by uniform resource identifiers, or URIs, in the XML file — typically, by using another XML namespace prefix, xmlns, as an attribute of the opening XML tag. A URI is used to specify a location or name for some resource on the Internet. A URL used to navigate to a Web page is one example of a URI. For example, in the Yahoo! Weather RSS feed, the yweather namespace is defined by using the attribute xmlns:yweather=http://xml.weather.yahoo.com/ns/rss/1.0 in the outermost tag in the file, <rss>.

By default, the XPath classes in the JDK use the default empty namespace when evaluating XPath expressions. If you want the XPath classes in the JDK to know about other namespaces, you need to provide them a class that implements the NamespaceContext interface, which provides methods for the retrieval of XML namespace prefixes and URIs. The XPath classes search all the namespaces they're aware of when evaluating XPath expressions.

To create a YWeatherNamespaceContext class that implements the NamespaceContext controller, follow these steps:

Figure 15.15. The New Java Class dialog box walks you through the creation of a new Java class that implements the NamespaceContext interface.

Figure 15.16. The Implemented Interfaces Selection dialog box

Here's the code listing for the YWeatherNamespaceContext class:

package com.wiley.jfib.ch15.mashup.util;
import java.util.Iterator;

import javax.xml.XMLConstants;
import javax.xml.namespace.NamespaceContext;

/**
 *
 */

/**
 * @author Chuck
 *
 */
public class YWeatherNamespaceContext implements NamespaceContext {

   private String namespaceUri;
   private String prefix;

   /**
    *
    */
   public YWeatherNamespaceContext(String namespaceUri, String
   prefix) {
           this.namespaceUri = namespaceUri;
           this.prefix = prefix;
     }

     /* (non-Javadoc)
      * @see javax.xml.namespace.NamespaceContext#getNamespaceURI(jav
    a.lang.String)
      */
     @Override
     public String getNamespaceURI(String prefix) {
             if(this.prefix.equals(prefix))
                     return namespaceUri;
             else
                     return XMLConstants.NULL_NS_URI;
     }

     /* (non-Javadoc)
      * @see javax.xml.namespace.NamespaceContext#getPrefix(java.lang.
    String)
      */
     @Override
     public String getPrefix(String namespaceURI) {
            if(this.namespaceUri.equals(namespaceURI))

return prefix;
          else
                    return XMLConstants.DEFAULT_NS_PREFIX;
     }

     /* (non-Javadoc)
      * @see javax.xml.namespace.NamespaceContext#getPrefixes(java.
    lang.String)
      */
     @Override
     public Iterator getPrefixes(String namespaceURI) {
            // Useful to implement if you have more
            // than one namespace prefix
            return null;
     }

}

The YWeatherNamespaceContext class defines a URI field and a prefix field that are set in the constructor when the class is instantiated. These are set in the service class at the time when the XPath classes are created.

To create the ArtWeatherService class, follow these steps:

Here's the code listing for the ArtWeatherService class:

/**
 *
 */
package com.wiley.jfib.ch15.mashup.service;

import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathFactory;

import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.httpclient.methods.GetMethod;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;
import org.w3c.dom.Document;

import com.aetrion.flickr.Flickr;
import com.aetrion.flickr.photos.Photo;
import com.aetrion.flickr.photos.PhotoList;
import com.aetrion.flickr.photos.SearchParameters;
import com.wiley.jfib.ch15.mashup.util.YWeatherNamespaceContext;

/**
 * @author Chuck
 *
 */
public class ArtWeatherService implements Controller {
     private String apiKey = "abcdefghijkl";
     private String sharedSecret = "mnopqrst";
     private Flickr flickr;
     private final static String YAHOO_STRING = "Yahoo! Weather - ";

     @Override
     public ModelAndView handleRequest(HttpServletRequest arg0,
                       HttpServletResponse arg1) throws Exception {
              String zipCode = arg0.getParameter("zip");
               // if a zip code is not given, send this back to the view
               // so that it knows not to display the non-existent forecast
               if(zipCode == null || zipCode.length() != 5)
                       return new ModelAndView(
                               "WEB-INF/jsp/artweather.jsp",
                               "entry",
                               "true");
               else
              {
                       Map<String,String> model = buildModelForZipCode(zipCode);
                         return new ModelAndView("WEB-INF/jsp/artweather.jsp",
                                 "model",model);
              }

}

          public Map<String,String> buildModelForZipCode(String zipCode)
            throws Exception {
            Map<String,String> model = new HashMap<String,String>();
            String request = "http://weather.yahooapis.com/forecastrss?p=" + zipCode;

            HttpClient client = new HttpClient();
            GetMethod method = new GetMethod(request);

            // Send GET request
            int statusCode = client.executeMethod(method);

            if (statusCode != HttpStatus.SC_OK) {
                    System.err.println("Method failed: " + method.getStatusLine());
            }
            InputStream rstream = null;

            // Get the response body
            rstream = method.getResponseBodyAsStream();

            //Process response

         Document response = DocumentBuilderFactory.newInstance()
                    .newDocumentBuilder().parse(rstream);

            XPathFactory factory = XPathFactory.newInstance();
            XPath xPath=factory.newXPath();

         xPath.setNamespaceContext(
                    new YWeatherNamespaceContext(
                            "http://xml.weather.yahoo.com/ns/rss/1.0" ,"yweather"));
           //Get each xpath expression as a string

        String cityState = (String)xPath.evaluate("/rss/channel/title",
                   response, XPathConstants.STRING);
           if(cityState != null && cityState.indexOf(YAHOO_STRING) == 0)
           {
                   cityState = cityState.replaceAll(YAHOO_STRING, "");
           }
           String todayCondition = (String)xPath.evaluate(
                   "/rss/channel/item/forecast[1]/@text",
                   response, XPathConstants.STRING);
           String todayHigh = (String)xPath.evaluate(
                   "/rss/channel/item/forecast[1]/@high",
                   response, XPathConstants.STRING);
           String todayLow = (String)xPath.evaluate(
                   "/rss/channel/item/forecast[1]/@low",
                   response, XPathConstants.STRING);

String tomorrowCondition = (String)xPath.evaluate(
                   "/rss/channel/item/forecast[2]/@text",
                   response, XPathConstants.STRING);
           String tomorrowHigh = (String)xPath.evaluate(
                   "/rss/channel/item/forecast[2]/@high",
                   response, XPathConstants.STRING);
           String tomorrowLow = (String)xPath.evaluate(
                   "/rss/channel/item/forecast[2]/@low",
                   response, XPathConstants.STRING);

           model.put("cityState", cityState);
           model.put("todayCondition", todayCondition);
           model.put("todayHigh", todayHigh);
           model.put("todayLow", todayLow);
           model.put("todayPhotoUrl", getFlickrPhotoUrl(todayCondition));

           model.put("tomorrowCondition", tomorrowCondition);
           model.put("tomorrowHigh", tomorrowHigh);
           model.put("tomorrowLow", tomorrowLow);
           model.put("tomorrowPhotoUrl", getFlickrPhotoUrl(tomorrowCondition));

           return model;
        }

           /**
            *
            * @param weatherCondition
            * @return
            * @throws Exception
            */
           private String getFlickrPhotoUrl(String weatherCondition) throws Exception
           {
                // now get a Flickr image for each of the condition strings
                   String photoUrl = "";
                flickr = new Flickr(apiKey);
                   flickr.setSharedSecret(sharedSecret);
                   SearchParameters params = new SearchParameters();
                   params.setText(weatherCondition);
                   PhotoList photos = flickr.getPhotosInterface().search(params, 10, 1);
                   for(Object p : photos)
                   {
                           Photo photo = (Photo)p;
                           if(photo.isPublicFlag())
                           {
                                   photoUrl = "http://farm"
                                           + photo.getFarm()
                                           + ".static.flickr.com/"
                                           + photo.getServer()
                                           + "/"

+ photo.getId() + "_"
                                           + photo.getSecret()
                                           + "_m.jpg";
                                    break;
                           }
                   }

                   return photoUrl;
           }
    }

In this class, the handleRequest() method receives the zip parameter from the client request. It passes off the zip parameter to a method called buildModelForZipCode(). This method does a few things:

The view for the ArtWeatherService is a JSP file named artweather.jsp. This JSP file extracts the values from the model map and then uses them to construct the application interface. To create the artweather.jsp file, follow these steps:

Here's the code listing for the artweather.jsp file:

<?xml version="1.0" encoding="ISO-8859-1" ?>
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">

<head>
      <meta http-equiv="Content-Type" content="text/html;
charset=ISO-8859-1" />
      <title>ArtWeather - More Than Just a Forecast</title>
</head>
<body>
       <div style="text-align: center; font-family: Verdana; font-
weight: bold; font-size: 24pt; width: 100%; background-color:
black; color: white">
             ArtWeather - More Than Just a Forecast
             <br/>
             <img src="blank.png" height="100px"/>
       </div>
       <div style="text-align: center; cwidth: 100%; background-
color: black; color: white">
             <c:if test="${empty param.entry}">
             <span style="font-weight: bold">Forecast for <c:out
value='${model["cityState"]}'/></span><br/>
             <table border="0" width="100%">
                    <tr>
<td>
   <img src="<c:out value='${model["todayPhotoUrl"]}'/>"/>
</td>
<td>
   <img src="<c:out value='${model["tomorrowPhotoUrl"]}'/>"/>
</td>
                          </tr>
                          <tr>
<td>For Today<br/>
<c:out value='${model["todayCondition"]}'/><br/>
High: <c:out value='${model["todayHigh"]}'/><br/>
Low: <c:out value='${model["todayLow"]}'/>
</td>
<td>For Tomorrow<br/>
<c:out value='${model["tomorrowCondition"]}'/><br/>
High: <c:out value='${model["tomorrowHigh"]}'/><br/>
Low: <c:out value='${model["tomorrowLow"]}'/>
</td>
                       </tr>
               </table>
               </c:if>
<form method="post"
   action="/artweather/artweather.htm">
   <input type="text" size="5" maxlength="5"
         name="zip" id="zip"
         style="font-family: Verdana;
         font-weight: bold; font-size: 18pt"/>
   <br/>
   <input type="submit"
         style="font-family: Verdana;
         font-weight: bold; font-size: 12pt"/>

</form>
   <span style="font-size: 8pt">
      Weather data provided by
      <a href="http://weather.yahoo.com">
             Yahoo! Weather
      </a><br/>
      Photos retrieved from
      <a href="http://flickr.com">Flickr</a>.
      All photos are the property of their
      owners. ArtWeather claims no ownership.
   </span>
            </div>
   </body>
</html>

This JSP page first checks for the existence of an entry parameter, which the controller places in the model in the case where no ZIP code is passed in; that means this is the initial visit to the application. If the entry parameter exists, the JSP page displays only the text field for typing the ZIP code and the button to submit it to the server. If the entry parameter isn't present, the JSP page renders the images and labels for the weather forecast and then uses JSTL <c:out> tags to retrieve the values from the model map to populate them with data.

The final development pieces are the two Web application configuration files: web.xml and spring-dispatcher-servlet.xml. These two files are a standard part of all Spring Web MVC applications.

First, create spring-dispatcher-servlet.xml by following these steps:

Here's the code listing for the spring-dispatcher-servlet.xml file:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
   <bean name="/artweather.htm"
   class="com.wiley.jfib.ch15.mashup.service.ArtWeatherService"/>
</beans>

This configuration file simply creates the Spring bean definition for the ArtWeatherService class and then maps a URL to it.

Now create the web.xml configuration file by following these steps:

Here's the code listing for web.xml:

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4"
          xmlns="http://java.sun.com/xml/ns/j2ee"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
          http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" >
  <servlet>
    <servlet-name>spring-dispatcher</servlet-name>
    <servlet-class>
          org.springframework.web.servletDispatcherServlet
    </servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>

  <servlet-mapping>
    <servlet-name>spring-dispatcher</servlet-name>
    <url-pattern>*.htm</url-pattern>
  </servlet-mapping>
</web-app>

This configuration file defines the Spring DispatcherServlet and then maps it to a URL pattern that says that any URL ending in .htm is handled by this servlet.

The application code is complete. Now you need to create the Ant build script and build properties files to build and deploy the application. To create these two files, follow these steps:

The properties contained in the artweather-build.properties file are used by the build.xml build file, so first edit the artweather-build.properties file to match this code listing:

# Ant build properties for artweather
src.dir=src
web.dir=web
build.dir=${web.dir}/WEB-INF/classes

name=artweather

appserver.home=${env.JBOSS_HOME}/server/default
appserver.lib=${appserver.home}/lib
deploy.path=${appserver.home}/deploy

This properties file contains properties for the Java source and Web file directories in the project, the build output directory, the application name, the JBoss home, and the application deployment path.

Now edit the build.xml file to match this code listing:

<?xml version="1.0" encoding="UTF-8"?>
<project name="artweather" basedir="." default="usage">
   <property environment="env"/>
    <property file="artweather-build.properties"/>

   <path id="cp">
       <fileset dir="${web.dir}/WEB-INF/lib">
            <include name="*.jar"/>
        </fileset>
        <fileset dir="${appserver.lib}">
            <include name="servlet*.jar"/>
        </fileset>
        <pathelement path="${build.dir}"/>
    </path>

    <taskdef resource="flexTasks.tasks"
           classpath="${FLEX_HOME}/ant/lib/flexTasks.jar"/>

     <target name="usage">
       <echo message=""/>

<echo message="${name} build file"/>
        <echo message="-----------------------------------"/>
        <echo message=""/>
        <echo message="Available targets are:"/>
        <echo message=""/>
        <echo message="build     --> Build the Java code and the Flex app"/>
        <echo message="build-and-deploy      --> Deploy application as a WAR file"/>
        <echo message=""/>
    </target>

    <target name="build" description="Compile main source tree java files">
        <mkdir dir="${build.dir}"/>
    <javac destdir="${build.dir}" source="1.5" target="1.5"
          debug="true" deprecation="false" optimize="false"
          failonerror="true">
           <src path="${src.dir}"/>
           <classpath refid="cp"/>
        </javac>
        <mxmlc file="${APP_ROOT}/ArtWeather.mxml"
               keep-generated-actionscript="false">
      <load-config
                  filename="${FLEX_HOME}/frameworks/flex-config.xml"/>
            <source-path path-element="${FLEX_HOME}/frameworks"/>
               <services>web/WEB-INF/services-config.xml</services>
                    </mxmlc>
            </target>
            <target name="build-and-deploy" depends="build"
           description="Deploy application as a WAR file">
                <war destfile="${name}.war"
                    webxml="${web.dir}/WEB-INF/web.xml">
                      <fileset dir="${web.dir}">
                           <include name="**/*.*"/>
                      </fileset>
                </war>
                <copy todir="${deploy.path}" preservelastmodified="true">
                        <fileset dir=".">
                            <include name="*.war"/>
                   </fileset>
                </copy>
          </target>
</project>

The Ant build script builds the application and then deploys it to the JBoss server. You need to add the build script to the Ant view to run it. To add the build script to the Ant view, follow these steps:

Click the arrow next to the build file entry in the Ant view to expand it to see the available build targets. The three targets you saw in the build.xml file appear here. Now double-click the build-and-deploy target to run it. The build-and-deploy target first launches the build target to compile the code, packages the application into a WAR file, and then deploys it to the JBoss server.

Once the application has been deployed successfully, you can start up JBoss to see the application in action. To start JBoss and test your application, follow these steps:

In the next section, you learn how to create a Flex version of this application. Not much changes about the Java code, but the front end is completely different. Leave this project open in Eclipse, as you will add to it in the next section.

Figure 15.17. The initial entry into the ArtWeather application shows only the title, text field, and form submission button. The other fields that hold the data returned from the server are hidden because the entry parameter was returned in the model.