Archive for ‘RequestFactory’

December 2, 2011

Intercepting RequestFactory requests

by Stefan

With RequestContext#fire() it is possible to provide a Receiver instance (“Callback”) to handle the result of a request to the server. One could think of some use cases where the same processing should be done for all RequestFactory calls, e.g.

  • Indicate a running request, e.g. change the mouse cursor, display a status or similar.
  • Handle http error codes, e.g. session time-outs or server unavailability.
  • Handle request time-outs.

To intercept all requests made via a RequestFactory it is possible to provide a customized RequestTransport implementation. This is done during the initialization:

import com.google.gwt.core.client.GWT;
import com.google.web.bindery.event.shared.EventBus;
import com.google.web.bindery.event.shared.SimpleEventBus;
import com.google.web.bindery.requestfactory.shared.RequestTransport;

import cleancodematters.requestfactory.tutorial.client.PizzaRequestFactory;

public class CustomTransportDemo {

  public PizzaRequestFactory initializeRequestFactory() {
    
    EventBus eventBus = new SimpleEventBus();
    RequestTransport transport = new CustomRequestTransport();
    
    PizzaRequestFactory factory = GWT.create( PizzaRequestFactory.class );
    factory.initialize( eventBus, transport );
    return factory;
  }
}

CustomRequestTransport extends the DefaultRequestTransport implementation and can do the pre- and post processing for all requests. See this very basic example to change the cursor during a running request:

import com.google.gwt.dom.client.Document;
import com.google.gwt.dom.client.Style.Cursor;
import com.google.web.bindery.requestfactory.gwt.client.DefaultRequestTransport;
import com.google.web.bindery.requestfactory.shared.ServerFailure;

public class CustomRequestTransport extends DefaultRequestTransport {

  @Override
  public void send( String payload, TransportReceiver receiver ) {
    doBeforeSend();
    super.send( payload, wrap( receiver ) );
  }
  
  private TransportReceiver wrap( final TransportReceiver delegate ) {
    return new TransportReceiver() {
      
      public void onTransportSuccess( String payload ) {
        doOnSuccess();
        delegate.onTransportSuccess( payload );
      }
      
      public void onTransportFailure( ServerFailure failure ) {
        doOnFailure( failure );
        delegate.onTransportFailure( failure );
      }
    };
  }

  protected void doBeforeSend() {
    // Some processing before the request is send
    Document.get().getBody().getStyle().setCursor( Cursor.WAIT );
  }

  protected void doOnSuccess() {
    // Some processing on success
    Document.get().getBody().getStyle().setCursor( Cursor.DEFAULT );
  }
  
  protected void doOnFailure( ServerFailure failure ) {
    // Some processing on failure
    Document.get().getBody().getStyle().setCursor( Cursor.DEFAULT );
  }
}
Advertisements
October 1, 2011

Polymorphic entities with GWT 2.4

by Stefan

GWT 2.4 finally adds polymorphism support to the RequestFactory infrastructure (detailed description). Here’s a small example on how to use it.

The scenario is well known from your first OO lesson. A basic class Vehicle is extended by the sub classes Car and Truck. Our back-end service layer allows clients to load a list of vehicles:

public class VehicleProvider {
  public List<Vehicle> getListOfVehicles() {
    return Arrays.asList( new Vehicle(), new Car(), new Truck() );
  }
}

To enable to RequestFactory logic to “know” all subclasses for Vehicle, use the new @ExtraType annotation to reference all known sub-types:

import java.util.List;

import cleancodematters.requestfactory.polymorphism.server.VehicleProvider;

import com.google.web.bindery.requestfactory.shared.ExtraTypes;
import com.google.web.bindery.requestfactory.shared.Request;
import com.google.web.bindery.requestfactory.shared.RequestContext;
import com.google.web.bindery.requestfactory.shared.Service;

@Service(value=VehicleProvider.class)
// Reference CarProxy and TruckProxy which extend VehicleProxy
@ExtraTypes( {CarProxy.class, TruckProxy.class} )
public interface VehicleRequestContext extends RequestContext {
  Request<List<VehicleProxy>> getListOfVehicles();
}

That’s it. You can find the full example on github.

June 18, 2011

Tutorial GWT Request Factory – Part II

by Stefan

In the first part of the tutorial we set up EntityProxy classes for our back-end entities pizza and ingredient. A PizzaRequestContext was introduced that represents the client-side facade for the PizzaDao in the back-end.

Now, a natural next step is to write some kind of controller logic that uses the PizzaRequestContext to communicate with the back-end. Let’s call this controller PizzaManager:

package cleancodematters.client;

import com.google.web.bindery.requestfactory.shared.Receiver;

public class PizzaManager {

  private final PizzaRequestFactory factory;

  public PizzaManager( PizzaRequestFactory factory ) {
    this.factory = factory;
  }

  public void findById( Long id, Receiver<PizzaProxy> receiver ) {
    factory.context().findById( id ).with( "ingredients" ).fire( receiver );
  }
}

The manager gets a RequestFactory instance passed into the constructor. This is a good idea as creating the RequestFactory requires a GWT#create() call which doesn’t work in plain JUnit tests. See my previous post on how to use GIN get the instance injected automatically.

How can we test the implementation of findById() with plain JUnit tests? One approach is to use a mocked PizzaRequestFactory instance. In our test we then have to ensure that the method chain factory.context().findById( id ).with( "ingredients" ).fire( receiver ) is called correctly. This test code is hard to write and also tied very closely with implementation details. In general, fluent interfaces are nice to read (but often violate the Law of Demeter, btw) but testing this code with mocks can be really cumbersome.

A better approach in my view is to use GWT’s RequestFactory infrastructure and replace the transport layer with some “in memory” processing that is independent of the browser infrastructure. Fortunately, GWT already provides a class for this: InProcessRequestTransport. This approach has another advantage: We also test the error-prone reference of nested entities (with( "ingredients" ) in the example).

read more »

June 4, 2011

Tutorial GWT Request Factory – Part I

by Stefan

Update 30.12.2012: All examples are reviewed and updated to GWT 2.5. Enjoy!
Update 24.09.2011:
I finally managed to push the complete tutorial project to github. It is based on GWT 2.4. 2.5. Looking forward to your feedback.

The first part of this tutorial describes how to set up a Request Factory (RF) based client-server communication in GWT. In contrast to the example at GWT home, a classic DAO pattern is used at the server-side with a clear separation between entity (passive, stateful) and dao/service (active, stateless). As this is not the default way, some additional helper classes (“locators”) need to be implemented. However, I think the benefit of a cleaner architecture is worth the price of some additional lines of code.

The second part will deal with testing RF-based classes in the GWT client.

Prerequisites

You should have the GWT SDK installed and a GWT compatible project in the IDE of your choice available. To make the example run you need some additional libraries on the classpath:

  • org.json.*
  • a JSR 303 Bean Validation implementation, e.g. hibernate-validator

When using Maven, simply add these dependencies:

<dependency>
    <groupId>org.json</groupId>
    <artifactId>json</artifactId>
    <version>20090211</version>
</dependency>

<!-- Validation API -->
<dependency>
    <groupId>javax.validation</groupId>
    <artifactId>validation-api</artifactId>
    <version>1.0.0.GA</version>
</dependency>

<!-- Validation Implementation -->
<dependency>
 <groupId>org.hibernate</groupId>
 <artifactId>hibernate-validator</artifactId>
 <version>4.3.0.Final</version>
</dependency>

<!-- Need some logging provider for SLF4J -->
<dependency>
 <groupId>ch.qos.logback</groupId>
 <artifactId>logback-classic</artifactId>
 <version>0.9.30</version>
</dependency>

Without Maven you can use gwt-servlet-deps.jar from the GWT SDK (containing the JSON packages) and download the hibernate-validator jar with its dependencies.

read more »