Getting Started with RESTful Web Services

REpresentational State Transfer (REST) is an architectural style for distributed hypermedia systems, such as the World Wide Web. Central to the RESTful architecture is the concept of resources identified by universal resource identifiers (URIs). These resources can be manipulated using a standard interface, such as HTTP, and information is exchanged using representations of these resources. In this tutorial, you first learn a bit about REST and then you are shown how NetBeans IDE 6.1 supports this architectural style.

Contents

• Introduction
• Generating Entity Classes from a Database
• Generating RESTful Web Services from Entity Classes
• Testing the RESTful Web Services
• Adding a Google Map Feature

To follow this tutorial, you need the following software and resources.

Software or Resource	Version Required
NetBeans IDE	Web & Java EE version 6.1
Java Developer Kit (JDK)	version 6 or version 5
Java EE-compliant web or application server	Tomcat web server 6.0 and/or GlassFish application server v2 Important: If you use Tomcat with this Tutorial, see the NetBeans Wiki on Tomcat with REST

Both Tomcat and GlassFish can be installed with the Web and Java EE distribution of NetBeans IDE. Alternatively, you can visit the GlassFish downloads page or the Apache Tomcat downloads page.

Introduction

RESTful web services are services built using the RESTful architectural style. Building web services using the RESTful approach is emerging as a popular alternative to using SOAP-based technologies for deploying services on the internet, due to its lightweight nature and the ability to transmit data directly over HTTP.

The IDE supports rapid development of RESTful web services using JSR 311 - Java API for RESTful Web Services (JAX-RS) and Jersey, the reference implementation for JAX-RS.

For detailed information, refer to the following:

• JSR 311: JAX-RS: The Java API for RESTful Web Services
• Jersey, the open source JAX-RS (JSR 311) Reference Implementation for building RESTful Web services

In addition to building RESTful web services, the IDE also supports testing, building client applications that access RESTful web services, and generating code for invoking web services (both RESTful and SOAP-based.)

Here is the list of RESTful features provided by the IDE:

1. Rapid creation of RESTful web services from JPA entity classes and patterns.
2. Rapid code generation for invoking web services such as Google Map, Yahoo News Search, and StrikeIron web services by drag-and-dropping components from the RESTful component palette.
3. Generation of JavaScript client stubs from RESTful web services for building RESTful client applications.
4. Test client generation for testing RESTful web services.
5. Logical view for easy navigation of RESTful web service implementation classes in your project.

In this tutorial, you will be shown how the IDE supports you in generating, implementing, and testing RESTful web services.

Generating Entity Classes from a Database

The goal of this exercise is to create a project and generate entity classes from a database.

1. Choose File > New Project. Under Categories, select Web. Under Projects, select Web Application and click Next.
2. Under Project Name, enter CustomerDB.
3. Under Server, select GlassFish. Click through the remaining options and click Finish.
4. Open the Services tab. Under Databases, right-click the Java DB and start it.
5. Right-click the CustomerDB node and choose New > Entity Classes from Database. Alternatively, you can select it from the Persistence category in the New File wizard (Ctrl-N).
6. In the Database Tables panel, select the jdbc/sample data source from the Data Source drop-down field.

   Note: On Tomcat, this data source may not exist. In this case, choose New Data Source from the Data Source drop-down field. The Create Data Source dialog opens. Type jdbc/sample in the JNDI Name field. From the Database Connection drop-down field, select jdbc:derby://hostname:1527/sample [app on APP]. Click OK. The dialog closes and you return to the Database Tables panel. See also the RESTful Service on Tomcat tutorial for NetBeans IDE 6.0.

7. Under Available Tables, select CUSTOMER and then click Add. The DISCOUNT_CODE table, which has a relationship with the CUSTOMER table, is automatically added to the Selected Tables list too. You should now see the following:
   
   

   Click Next.

8. Under Package, type customerdb. You should now see the following:
   
9. Click Create Persistence Unit. The following dialog appears:
   

   Click Create and then click Finish.

10. Look in the Projects window. You should now see the following:
    

Generating RESTful Web Services from Entity Classes

The goal of this exercise is to generate RESTful web services from the entity classes that we generated in the previous section.

1. Right-click the package that contains the entity classes and choose New > RESTful Web Services from Entity Classes.
2. In the New RESTful Web Services from Entity Classes wizard, click Add All. After the entity classes appear in the Selected Entity Classes field, click Next.
3. In the next panel, leave the defaults unchanged, as shown below:
   

   Here you can see everything that the IDE will generate for you. The IDE uses the container-item pattern to generate the resource classes. For example, for the Customer entity class, the IDE generates a container resource called CustomersResource and an item resource called CustomerResource. Also, for each resource class, the IDE generates a converter class used for generating the resource representation from the corresponding entity instance, such as CustomersConverter and CustomerConverter. Furthermore, there is an additional converter class called reference converter, such as CustomerRefConverter, for representing relationships.

   Click Finish.

4. Look in the Projects window. You should now show the following:
   

The RESTful Web Services node in the Projects window displays all the RESTful web services in your project. The value between the square brackets, such as [/customers/], is the value for the URI template. You can also navigate to the source file by doubling clicking on this node. This view also displays all the HTTP methods and Sub-resource locator methods. Again, you can navigate to the methods by double clicking on the nodes.

Now that our entity classes and RESTful web services have been generated, let's test our application. The IDE provides a useful utility for testing RESTful web services. We will make use of it in the next section.

Testing the RESTful Web Services

The goal of this exercise is to try out our application.

1. Right-click the project node and choose Test RESTful Web Services. The server starts and the application is deployed. When deployment is complete, the browser displays your application, with a link for each of the web services:
   

On the left-hand side is the set of root resources. Here they are named customers and discountCodes.

2. First select a root resource, such as customers. Click on the Methods drop-down list to select either GET(application/xml) or GET(application/json). Click Test. The result is displayed in the Test Output section:
   

There are 4 tabs in the Test Output section. The Tabular View is a flattened view that displays all the URIs in the resulting document, which you can navigate to by clicking on the links. The Raw View displays the actual data returned. Depending on which mime type you selected (application/xml or application/json), the data displayed will be in either XML or JSON format, respectively. The Headers Tab displays the HTTP header information. There is also a tab called HTTP Monitor, which displays the actual HTTP requests and responses sent and received.

3. Exit the browser and return to the IDE.

Adding a Google Map Feature

The goal of this exercise is to add Google map functionality to our RESTful web services.

1. Open the CustomerResource class in the editor.
2. Add the following methods to CustomerResource:

   @GET
   @ProduceMime("text/html")
   public String getGoogleMap() {
   // Drag and drop the getGoogleMap operation here
   
      return "";
   }
   
   //Gets invoked by going to browser and accessing any customer (ie  /customers/1/googleMap)
   /**
    * Returns sub-resource.
    */
   @Path("googleMap/")
   @GET
   @ProduceMime("text/html")
   public String getGoogleMapResource() {
       return getGoogleMap();
   }

3. Sign up for a Google map key at http://www.google.com/apis/maps/signup.html. The Google map key request dialog has a field for your website's URL. Type http://localhost:8080 in that field.
4. In the IDE, open the Services tab and expand the Web Services node. Under Web Services, expand Google. Under Google, expand Map Service.
   
   
5. Drag the getGoogleMap item and drop it into the body of the getGoogleMap method you created in Step 2, just before the return = null; line. The Customize getGoogleMap SAAS dialog opens. Accept the defaults and click OK.

   The IDE adds the following try block to the getGoogleMap method in the CustomerResource class:

   @Path("googleMap/")
   @GET
   @ProduceMime("text/html")
   public String getGoogleMap() {
       try {
   
           String address = "16 Network Circle, Menlo Park";
           java.lang.Integer zoom = 15;
           String iframe = "false";
   
           RestResponse result = GoogleMapService.getGoogleMap(address, zoom, iframe);
       //TODO - Uncomment the print Statement below to print result.
       //System.out.println("The SaasService returned: "+result.getDataAsString());
       } catch (Exception ex) {
           ex.printStackTrace();
       }
       return null;
   }

   The IDE also creates the following classes and resources in the project:

   • RestConnection – A wrapper around HttpUrlConnection
   • RestResponse – A wrapper for the HTTP response
   • GoogleMapServiceAuthenticator – A class that gets the value for the ApiKey from googlemapserviceauthenticator.properties
   • googlemapserviceauthenticator.properties – A properties file that stores the API key
   • GoogleMapService – A service wrapper containing the wrapper methods that uses RestConnection to make calls to the Google Map service.

6. Replace the try block of the getGoogleMap method with the following:

   @Path("googleMap/")
   @GET
   @ProduceMime("text/html")
   public String getGoogleMap() {
       try {
            Customer c = getEntity();
            String address = c.getAddressline1() + " " + c.getAddressline2() + " " +
                    c.getCity() + " " + c.getState() + " " + c.getZip();
            java.lang.Integer zoom = 15;
            String iframe = "false";
   
            RestResponse result = GoogleMapService.getGoogleMap(address, zoom, iframe);
            return result.getDataAsString();
        //TODO - Uncomment the print Statement below to print result.
        //System.out.println("The SaasService returned: "+result.getDataAsString());
        } catch (Exception ex) {
            ex.printStackTrace();
        } 
        return "";
   }

7. Open googlemapserviceauthenticator.properties. Set the api_key property equal to the API key you got from Google in Step 3.
8. Open the Services tab and start your application server.
9. Right-click the CustomerDB project node and select Test RESTful Web Services. The IDE undeploys and redeploys your project to the server and then opens a browser window with the test client.
10. Click customers in the left sidebar. Test criteria for customers open in the main pane. Leave the defaults and click Test. A table of customers opens.
11. Select a customer from the table, such as customer1. Click on the customer. Test criteria for that customer open in the main pane. From the drop-down menu, select the text/html MIME type. Click Test. GoogleMap of that address opens in the Raw View.

    Note: If GoogleMaps cannot find an address, it shows a zoomed in view of the ocean.

    
    

    

12. You can replace the URL with http://localhost:8081/CustomerDB/resources/customers/2/googleMap, .../3/googleMap, and so on to 25, to see the map location of all customers.

See Also

For more information about using NetBeans IDE 6.0 to develop Java EE applications, see the following resources:

• Creating RESTful Web Service Client Stubs
• Developing JAX-WS Web Service Clients
• Getting Started with JAX-WS Web Services
• Consuming StrikeIron Web Services in Web Applications
• Advanced Web Service Interoperability
• EJB & Web Service Applications Learning Trail
• YouTube: RESTful Web Services, Building and Deploying (Part 1)
• YouTube: NetBeans RESTful Testing and Invoking RESTful Resources (Part 2)

To send comments and suggestions, get support, and keep informed on the latest developments on the NetBeans IDE Java EE development features, join the mailing list.