Before starting the creation of the client, we need to add some Jersey libraries to the project classpath since they provide the client API and JSON classes that we're going to use:

Also, we need to add references to TheaterBO to properly manipulate the response of our REST Web Service. As we did with StoreBO in the previous chapter, we need to add a reference to the project for design-time compilation, and some tags to the project's MANIFEST.MF file to link them at runtime. Let's do so:

The Store project is now ready and you can start implementing the web service client.

Now that the Store project has the correct libraries, we can create the client that is going to consume the API exposed at http://localhost:7001/theater/api/exhibition/q. In order to achieve this, we must:

So, in the Store project, create a new Java class named TheaterClient under the package com.packt.theater.client, decorate it with @Named and add a method to retrieve a JAX-RS handler:

private WebResource getClient() {
   final Client client = Client.create();
   return client.resource(ENDPOINT);
}

The endpoint referenced above is going to be retrieved from a deployment descriptor, web.xml, using CDI. Add these lines just after the class declaration:

@Resource(lookup="theaterServiceEndpoint")
private String ENDPOINT;

Now, open your web.xml file and add this block at the end of the web-app tag:

<env-entry>
   <env-entry-name>theaterServiceEndpoint</env-entry-name>
   <env-entry-type>java.lang.String</env-entry-type>
   <env-entry-value>http://localhost:7001/theater/api
   </env-entry-value>
</env-entry>

The last step is to create a method, getExhibitionByMovie, that receives a movie ID as parameter and returns a list of exhibitions, executing the call to the REST Web Service exposed by the Theater module. Here's how the final code of the TheaterClient class should look like:

@Named
public class TheaterClient {
   @Resource(lookup="theaterServiceEndpoint")
   private String ENDPOINT;

   private WebResource getClient() {
      final Client client = Client.create();
      return client.resource(ENDPOINT);
   }
   
   public List<Exhibition> getExhibitionByMovie(int movieId) {
      if (null == ENDPOINT) {
         return null;
      }
      
      final List<Exhibition> exhibition = (List<Exhibition>)getClient()
         .path("exhibition")
         .path("q")
         .queryParam("movie", String.valueOf(movieId))
         .accept(MediaType.APPLICATION_XML)
         .get(ClientResponse.class)
         .getEntity(new GenericType<List<Exhibition>>() {});
      
      return exhibition;
   }
}

Now, we must change the SearchManager bean to call the brand new client proxy and add variables to deal with this new data.

The SearchManager class already has methods that list theaters (getTheaters) and movies (getMovies), and now we need to update the bean to include a method that will call TheaterClient and receive a list of available exhibitions of the selected movie:

The complete class should look like this:

@Named("search")
@SessionScoped
public class SearchManager implements Serializable {
   private static final long serialVersionUID = 1L;

   @PersistenceContext(unitName="StoreBO")
   EntityManager em;

   @Inject
   private transient TheaterClient theaterClient;
   
   private List<Theater> theaters;
   private List<Movie> movies;
   private List<Exhibition> exhibitions;

   private int movie;
   private int theater;
   private int exhibition;

   // Change listener for Movie selectOneMenu
   public void handleMovieChange() {
      if (movie != 0) {
         exhibitions = theaterClient.getExhibitionByMovie(movie);
      } else {
         exhibitions = null;
      }
   }

   @SuppressWarnings("unchecked")
   public List<Theater> getTheaters() {
      if (theaters == null)
         theaters = em.createNamedQuery(Theater.findAll).
         getResultList();

      return theaters;
   }

   @SuppressWarnings("unchecked")
   public List<Movie> getMovies() {
      if (movies == null)
         movies = em.createNamedQuery(Movie.findAll).
         getResultList();

      return movies;
   }
}

// Other getters and setters omitted

The web page that displays the search form needs to be updated with the exhibition dates retrieved from the Theater module. To accomplish this without refreshing the whole page, we will rely on some Ajax (Asynchronous JavaScript and XML) features provided by JavaServer Faces. This can be accomplished by firing an Ajax call when the user selects an entry from the Movies drop-down menu:

The resulting page should look like this:

The Exhibition drop-down menu is being populated by the results returned by the exhibition RESTful web service, hosted by the Theater application. Every time the movie list changes, a new call is made and the exhibition list is refreshed. For a real-world scenario, many considerations would need to be taken into account, such as latency, caching, security, and other strategies. Some of these strategies will be explored in the following chapters.