Smart GWT + Restful Spring MVC

I’ve been a fan of REST-ful development for a while now. Developing an application with a REST API layer will allow it to integrate effortlessly with other external applications. It also allows for really easy separation of view and server technologies. Usually the best way to accomplish this is using the Model and Controller parts of Spring MVC. You can find a small tutorial on using Spring MVC in a RESTful way here.

On the other hand, I’m also a fan of Smart GWT. It’s suite of widgets makes it a breeze to put together a business application in an environment where the app will be maintained by other Java developers.

It is difficult to integrate Spring with Smart GWT Datasource objects, due to the fact that most Datasource implementations do not use standard REST calls and expect very specific responses. So lets go step by step and get our Smart GWT view talking to our REST-ful Spring Controller.

So first, I assume that the reader already knows how to set up an annotation-driven Spring project. Lets create a controller that interacts with Person objects.

public class Person implements Serializable {
 private Integer id;
 private String name;

 public Integer getId() {
  return id;
 }

 public void setId(Integer id) {
  this.id = id;
 }

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }
}

@Controller
@RequestMapping("/person")
public class PersonController {
 @RequestMapping(value="/", method=RequestMethod.GET)
 public @ResponseBody List<Person> getAllPersons() {
  // Return a list of Person objects
 }

 @RequestMapping(value="/", method=RequestMethod.PUT)
 public @ResponseBody Person updatePerson(@ModelAttribute Person person) {
  // The person object will only have the fields that are
  // being updated populated + the primary key.
  // The method should return a full object with the same primary key.
 }

 @RequestMapping(value="/", method=RequestMethod.POST)
 public @ResponseBody Person createPerson() {
  // This should create a new person with a new primary key
 }

 @RequestMapping(value="/id/{id}", method=RequestMethod.DELETE)
 public @ResponseBody Person deletePerson(@PathVariable("id") Integer id) {
  // This should delete a person and return the deleted person object
 }
}

Now, once we have a proper controller, lets hook up GWT Datasource to properly interact with our REST-ful Person controller. GWT has a special RestDatasource that is already set up to interact with custom URLs. However, by default it expects very specific URLs and very specific request methods. By default it is not configured to use PUT and DELETE methods. Only POSTs and GETs are supported out of the box. Thankfully, there are also a lot of configuration options that are built into this class, and we can modify it to fit our purposes. Lets extend the GWT RestDataSource to make restful calls to Spring controllers, and abstract that logic away so that we can easily create new datasources that can interact with Spring controllers in REST-ful fashion.

public abstract class AbstractRestDataSource extends RestDataSource {
 public AbstractRestDataSource(String id) {
  setID(id);
  setClientOnly(false);

  //set up FETCH to use GET requests
  OperationBinding fetch = new OperationBinding();  
  fetch.setOperationType(DSOperationType.FETCH);
  DSRequest fetchProps = new DSRequest();
  fetchProps.setHttpMethod("GET");
  fetch.setRequestProperties(fetchProps);

  //set up ADD to use POST requests
  OperationBinding add = new OperationBinding();  
  add.setOperationType(DSOperationType.ADD);  
  add.setDataProtocol(DSProtocol.POSTPARAMS);

  //set up UPDATE to use PUT 
  OperationBinding update = new OperationBinding();  
  update.setOperationType(DSOperationType.UPDATE);  
  DSRequest updateProps = new DSRequest();
  updateProps.setHttpMethod("PUT");
  update.setRequestProperties(updateProps);

  //set up REMOVE to use DELETE
  OperationBinding remove = new OperationBinding();  
  remove.setOperationType(DSOperationType.REMOVE);  
  DSRequest removeProps = new DSRequest();
  removeProps.setHttpMethod("DELETE");
  remove.setRequestProperties(removeProps);  

  //apply all the operational bindings
  setOperationBindings(fetch, add, update, remove);

  init();
 }

 @Override
 protected Object transformRequest(DSRequest request) {
  super.transformRequest(request);

  //now post process the request for our own means
  postProcessTransform(request);

  return request.getData();
 }

 /*
  * Implementers can override this method to create a 
  * different override.
  */
 @SuppressWarnings("rawtypes")
 protected void postProcessTransform(DSRequest request) {
  StringBuilder url = new StringBuilder(getServiceRoot());

  Map dataMap = request.getAttributeAsMap("data");
  if(request.getOperationType() == DSOperationType.REMOVE) {
   //in case of remove, append the primary key
   url.append(getPrimaryKeyProperty()).append("/").
    append(dataMap.get(getPrimaryKeyProperty()));
  } else if(request.getOperationType() == DSOperationType.UPDATE) {
   appendParameters(url, request);
  }

  request.setActionURL(URL.encode(url.toString()));
 }

 /*
  * This simply appends parameters that have changed to the URL
  * so that PUT requests go through successfully. This is usually
  * necessary because when smart GWT updates a row using a form,
  * it sends the data as form parameters. Most servers cannot
  * understand this and will simply disregard the form data
  * sent to the server via PUT. So we need to transform the form
  * data into URL parameters.
  */
 @SuppressWarnings("rawtypes")
 protected void appendParameters(StringBuilder url, DSRequest request) {
  Map dataMap = request.getAttributeAsMap("data");
  Record oldValues = request.getOldValues();
  boolean paramsAppended = false;

  if(!dataMap.isEmpty()) {
   url.append("?");
  }

  for(Object keyObj : dataMap.keySet()) {
   String key = (String) keyObj;
   if(!dataMap.get(key).equals(oldValues.getAttribute(key)) || isPrimaryKey(key)) {
    //only append those values that changed or are primary keys
    url.append(key).append('=').append(dataMap.get(key)).append('&');
    paramsAppended = true;
   } 
  }

  if(paramsAppended) {
   //delete the last '&'
   url.deleteCharAt(url.length()-1);
  }
 }

 private boolean isPrimaryKey(String property) {
  return getPrimaryKeyProperty().equals(property);
 }
 
 /*
  * The implementer can override this to change the name of the
  * primary key property.
  */
 protected String getPrimaryKeyProperty() {
  return "id";
 }

 protected abstract String getServiceRoot();
 protected abstract void init();
}

Now we’ve set up an abstract REST-ful DataSource that will talk to a Spring controller using all 4 REST methods. Now all we need to do is implement it and we can hook it up to any ListGrid or other Smart GWT widgets and ADD, UPDATE, FETCH and REMOVE will correctly correspond to our Spring controller’s methods.

public class PersonDataSource extends AbstractRestDataSource {
 private static PersonDataSource instance = null;
 
 public static PersonDataSource getInstance() {
  if(instance == null) {
   instance = new PersonDataSource("personEditDS");
  }
  
  return instance;
 }
 
 private PersonDataSource(String id) {
  super(id);
 }
 
 protected void init() {
  setDataFormat(DSDataFormat.JSON);
  setJsonRecordXPath("/");
  
  DataSourceField idField = new DataSourceField("id", FieldType.INTEGER, "ID");
  idField.setPrimaryKey(true);
  idField.setCanEdit(false);
  DataSourceField nameField = new DataSourceField("name", FieldType.TEXT, "Name");
  
  setFields(idField, nameField);
 }

 @Override
 protected String getServiceRoot() {
  return "person/";
 }
}

Now that everything is in order, we can simply hook it up to a ListGrid and edit, add, and delete rows and it will work successfully with our controller.

About these ads