REST with Spring 3.0, Spring MVC and Dojo. Part 3 - POST and JSR-303 validation

In the third part of the series we will take a look at handling POST requests from REST in Spring MVC, and also at validation. And - not just any validation but JSR-303 validation! There's a trick to it though, I have to be honest. I will explain this later.
We will also look at sending POST requests with Dojo.

You need Java 6 for this and I am also using JBoss 6.0.0.M1.

POST requests are the C in CRUD. What it means is you use it to create new items. Please see this little table.

Operation	REST method	Sample URI
Return item(s)	GET	/books (all books) /books/ (all books) /books/12 (one book with ID = 12)
Create a new item	POST	(you pass the ID in the object itself) /books /books/
Update an item	PUT	(you pass the ID in the object itself) /books /books/
Delete an item	DELETE	/books/12 (book with ID = 12)

As you can see, in the POST or PUT case we are not passing the ID. Instead, we will pass the entire object! Spring MVC makes it possible for us to retrieve the object straight from REST and does all the binding for us.

Also, some of the URIs are identical across the methods. That's perfectly correct - it's the method (POST, PUT) that makes the distinction. You don't have to do any additional handling in your controller methods (actions).

Let us take a look at the controller then. The code should be familiar by now.

@RequestMapping(value = "/books", method = RequestMethod.POST)
    public BookTO handleBookSave(HttpServletResponse response,
            @RequestBody @Valid BookTO bookTO) {
        BooksBean booksBean = Factory.getBooksBean();
        return booksBean.saveBook(bookTO);
    }

First, notice the RequestMapping annotation and the URI that it handles (/books). Second, notice the method - it's POST which means it's supposed to handle the create case.

It's a controller method which means it's an entry point to handle REST requests and - as promised - it already retrieves an object! How does it happen? Well, that's thanks to the RequestBody annotation. It does auto-binding for us and also does type validation.

What is the Valid annotation for? It tells Spring to do JSR-303 on that object when binding. It uses Hibernate constraints, to be precise (the previously mentioned type checking is independent of this and happens with or without the Valid annotation). Please take a look at this TO object that we validate and note the validation annotations needed for JSR-303.

import javax.validation.constraints.NotNull;
import org.hibernate.validator.constraints.Length;

public class BookTO {
    // ...
    @NotNull @Length(min = 20)
    public String getName() {
        return name;
    }
}

See? It's pretty easy. But... Yeah, there's a problem with it - it doesn't work. That's right, it doesn't work. What's the problem with it? Take a look at the controller code. We have two annotations on the method argument (@Valid and @RequestBody) and when combined, Spring ignores the Valid annotation. It's a bug and it has already been submitted to Spring JIRA. Let's hope this get resolved when Spring 3.1 comes out; I'm keeping my eye on it.

Let's also look at the Dojo part of the story.

function saveBook(bookName) {
    var newBook = {
            "name":bookName
    };
    var actualContent = dojo.toJson(newBook);
    
    //Save.
    var deferred = this._request("rawXhrPost", {
        url: "http://localhost:8080/restsample-0.0.1-SNAPSHOT/rest/books.json",
        handleAs: "json",
        postData: actualContent,
        headers: { "Content-Type": "application/json"}
    });
    deferred.addCallback(this, function(value) {
        alert("Saved! " + value.bookTO.name);
    });
    deferred.addErrback(this, function(value) {                
          alert("Error: "  + value);
    });    
}

We first create an object to pass - the fields have to match the TO object fields (the names have to be the same).

Then we use dojo.toJson to convert this object to a JSON string.

Next, we call our RESTful service. Notice the method - it's rawXhrPost as we need it raw for binding to work. We also pass the object (well, it's a string at this point) as postData. For PUT requests we will use, you guessed it, putData.

And that's all! Download the sample code for this article if you wish.

1. REST with Spring 3.0, Spring MVC and Dojo. Part 1 - GET
2. REST with Spring 3.0, Spring MVC and Dojo. Part 2 - GET from Dojo perspective
3. REST with Spring 3.0, Spring MVC and Dojo. Part 3 - POST and JSR-303 validation
4. REST with Spring 3.0, Spring MVC and Dojo. Part 4 - PUT (updating objects)
5. REST with Spring 3.0, Spring MVC and Dojo. Part 5 - DELETE