Objective

We are talking REST+JSON from browser to the server and back, so we need to report errors nicely. Exception thrown on the server have to be converted to error messages and transmitted to the client in JSON format. Luckily there is a very elegant solution for this in Spring.

HandlerExceptionResolver interface

Spring provides a very handy HandlerExceptionResolver interface for mapping exceptions to views. If you check the documentation (and you should) you will notice that where are couple exception handlers already implemented, but we will create our own. Just because we can.

Implementing JsonExceptionResolver

Our implementation is very basic, but can be enhanced to return more data about where the exception occurred, etc. To implement HandlerExceptionResolver interface we need to provide one method:

package com.lureto.rjf;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ModelAndView;

public class JsonExceptionResolver implements HandlerExceptionResolver {

        @Override
        public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response,
                                                 Object handler, Exception exception ) {
                ModelAndView mav = new ModelAndView();
                mav.setViewName("MappingJacksonJsonView");
                mav.addObject("error", exception.getMessage() );
                return mav;
        }

}

resolveException method returns ModelAndView, to which we add a model object “error” holding the message from the exception, and set the view name. The view in this case is MappingJacksonJsonView. Setting error to the exception message comes in handy when we need to return an error from lets say “saveUser” action – we simply throw exception from the controller method like this: throw new Exception(“USER_EMAIL_NOT_UNIQUE”);

Next we need to hook in our exception resolver into Spring context like this:

<bean class="org.springframework.web.servlet.view.ContentNegotiatingViewResolver">
  <property name="mediaTypes">
    <map>
      <entry key="json" value="application/json" />
    </map>
  </property>
  <property name="defaultContentType" value="application/json" />
  <property name="defaultViews">
    <list>
      <bean name="MappingJacksonJsonView"
        class="org.springframework.web.servlet.view.json.MappingJacksonJsonView" />
    </list>
  </property>
</bean>
   
<bean id="exceptionResolver" class="com.lureto.rjf.JsonExceptionResolver" />

We simply define the bean and name call it exceptionResolver. Spring detects implemented interface and automagicaly routes exceptions to this resolver. We needed to modify our view definition – we gave it name, so we can reference it in the code – “MappingJacksonJsonView”.

Conclusion

Trapping exceptions on the server and converting them to JSON error messages can be done with 4 lines of conde and 1 line of xml. You can use this approach to map all sorts of exceptions to custom error jsp pages, JSON errors or any other view type. Your application users do not have to see an ugly Tomcat 500 error page.

Google App Engine + JAVA + Spring + REST + Mapping Exceptions to Errors for JSON is a post from: Wet Feet - Online Marketing and Technology Blog

Objective

Once you are finished with this article, you will be able to store application data in Google App Engine Data store and consume REST service using flex client.

Common Problems and Solutions

In my personal opinion flash player security model is the biggest piece of bullshit I ever encountered. If you sit down and thing just for 10 seconds about how it is implemented you will have to agree that it provides NO security at all. It just makes impossible so do certain things, that’s all. Adobe needs to drop it now.

Here is the problem that we have with REST and Google app engine: Adobe’s implementation of HTTPService only supports GET and POST, to consume REST we need at least 3 methods: GET, POST and DELETE. We can live without PUT – if id is null JDO will create a new persisted object, if it is set JDO will update it. But we still do not have support for DELETE.

If you are implementing Air Application there are good news: as3httpclientlib – a socket implementation of http client that can do all that we need: HEAD, GET, POST, PUT, DELETE. It depends on as3corelib and as3crypto, so grab those too.

If you are implementing a web application in google app engine, you are out of luck with as3httpclientlib. The reason is that adobe has this perverted understanding about security: since as3httpclientlib utilizes the Socket to implement http client adobe flash player tries to “protect” the server that socket is trying to connect by sending
“<policy-file-request/>” to the 843 port to get a scoket policy file, it that fails it tries the port the socket is trying to connect to. Since this is not a http request, google app engine ignores it, and you can not create sockets in google app engine – they are not supported, so you can not write a simple class to send back what flash player wants. The conclusion: Adobe Flex has not yet made it to Web 2.0, it can not talk REST to the server. But there are workarounds and here is mine:

Step one – Add persistence management code to the project we created in part 1

First we need to modify our User.java class to support persistence:

import javax.jdo.annotations.IdGeneratorStrategy;
import javax.jdo.annotations.IdentityType;
import javax.jdo.annotations.PersistenceCapable;
import javax.jdo.annotations.Persistent;
import javax.jdo.annotations.PrimaryKey;

@PersistenceCapable(identityType = IdentityType.APPLICATION, detachable="true")
public class User {

    @PrimaryKey
    @Persistent(valueStrategy = IdGeneratorStrategy.IDENTITY)
    private Long id;
    @Persistent
    private String email;
    @Persistent
    private String name;

    // Getter and setters go here......
}

As you can see we have instructed JDO that we will store User objects at application level, added a primary key and its generation strategy and annotated members to be persisted.

Next we need to get hold of a persistence manager factory, since it is a very very costly operation, we wan to do it only once in the lifetime of our application. For this purpose lets create a singleton which will hold this instance for us:

package com.lureto.rjf;

import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManager;
import javax.jdo.PersistenceManagerFactory;

public class PMF {

    private static final PersistenceManagerFactory pmfInstance = 
JDOHelper.getPersistenceManagerFactory("transactions-optional");

    private PMF() {}

    public static PersistenceManager getManager() {
        return pmfInstance.getPersistenceManager();
    }

    public static PersistenceManagerFactory get() {
        return pmfInstance;
    }

}

The last step is to modify our UserContrller.java to actually store and retrieve the User objects from the data store.

package com.lureto.rjf;

import java.io.IOException;
import java.util.List;

import javax.jdo.PersistenceManager;
import javax.jdo.Query;

import org.apache.log4j.Logger;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
@RequestMapping("/user")
public class UserController {

        private static Logger logger = Logger.getLogger( UserController.class );

        @SuppressWarnings("unchecked")
        @ModelAttribute("users")
        @RequestMapping(value = "/", method = RequestMethod.GET)
        public List listUsers() throws IOException {
                PersistenceManager pm = PMF.getManager();
                Query query = pm.newQuery(User.class);
                List users;
                try {
                        users = (List) query.execute();
                } finally {
                        query.closeAll();
                }
                return users;
        }

        @ModelAttribute("user")
        @RequestMapping(value = "/", method = RequestMethod.POST)
        public User saveUser( @RequestBody User user ) throws IOException {
                logger.debug(user);
                PersistenceManager pm = PMF.getManager();
                try {
                    pm.makePersistent(user);
                } finally {
                    pm.close();
                }
                return user;
        }

        @RequestMapping(value = "/{userId}", method = RequestMethod.DELETE )
        public void deleteUser( @PathVariable String userId ) throws IOException {
                deleteUserIntenral(userId);
        }
        
        @RequestMapping(value = "/{userId}/delete", method = RequestMethod.POST )
        public void deleteUser2( @PathVariable String userId ) throws IOException {
                deleteUserIntenral(userId);
        }

        private void deleteUserIntenral( String userId ) throws IOException {
                logger.debug("Deleting user id > "+userId);
        PersistenceManager pm = PMF.getManager();
        try {
                Long id = Long.parseLong(userId);
                User user = pm.getObjectById( User.class, id ); 
            pm.deletePersistent(user);
        } finally {
            pm.close();
        }               
        }
}

As you can see from the code above, saving and getting a list of Users is pretty trivial coding task. You may also notice that we added deleteUser(@PathVariable String userId) method to delete the user when a delete request is made with user id added to the end of the path. To delete the user object first we need to fetch it from the data store and only then ask persistence manager to delete it. We hav two ways to delte the user – sending DELETE requests and sending POST to “/api/user/{userId}/delete”. The post method is there to get around the shortcomings of Actions Scrip 3.

And one last change we need to make to support not so mature flex – to add crossdomain.xml file to /war of our project so flash player security implementation stops throwing security exceptions. Like I said before this adds nothing to the security, but annoys the hell out of the developers. Here is the contents:

<?xml version="1.0"?><!DOCTYPE cross-domain-policySYSTEM 
            "http://www.macromedia.com/xml/dtds/cross-domain-policy.dtd">
<cross-domain-policy>
    <allow-access-from domain="*" to-ports="*"/>
    <allow-http-request-headers-from domain="*" headers="*"/>
</cross-domain-policy>

Step two- Create Flex project to consume the service we just upgraded

First create a Flex Web application project:

and then layout the UI to look like this:

And if you lazy like and want it all right now, here is the complete sudo code mxml file:

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" 
      layout="absolute" creationComplete="init()">
  
  <mx:Script>
    <![CDATA[
      import mx.rpc.events.ResultEvent;
      import mx.rpc.events.FaultEvent;
      import mx.rpc.http.HTTPService;
      import mx.managers.PopUpManager;
      import json.JParser;
      import mx.controls.Alert;
      import mx.controls.List;
      
      [Bindable]
      private var users:Array;
      private var uriBase: String = "http://localhost:8080/api/user/";
      private var popupLabel:Label;

      private function init() : void {
        var myUrl : String = Application.application.url;
        if( myUrl.indexOf( "file://" ) != 0 ) 
          uriBase = myUrl.substring( 0, myUrl.lastIndexOf( "/" ) ) + "/api/user/" ;
        refreshUsers()      
      }
      
      private function addNew() : void {
        this.user_id.text = "";
        this.user_email.text = "";
        this.user_name.text = "";
      }

      private function updateEdit() : void {
        this.user_id.text =  this.usersList.selectedItem.id;
        this.user_name.text =  this.usersList.selectedItem.name;
        this.user_email.text =  this.usersList.selectedItem.email;
      }

      private function deleteUser() : void {
        
        if( usersList.selectedItem == null )
          return;
          
        showPopupWait();

        var service: HTTPService = new HTTPService();
        service.contentType = "application/json";
        service.method = "POST";
        service.resultFormat = "text";
        service.url = uriBase + usersList.selectedItem.id + "/delete" ;
        service.useProxy = false;

        service.addEventListener( FaultEvent.FAULT , function(event:FaultEvent):void {
                removePopup();
                Alert.show( event.message.toString() );
            } )      

        service.addEventListener( ResultEvent.RESULT , function(event:ResultEvent):void {
              refreshUsers();           
            } )      

        service.send();

      }
      
      private function saveUser() : void {
        showPopupWait();

        var service: HTTPService = new HTTPService();
        service.contentType = "application/json";
        service.method = "POST";
        service.resultFormat = "text";
        service.url = uriBase;
        service.useProxy = false;

        service.addEventListener( FaultEvent.FAULT , function(event:FaultEvent):void {
                removePopup();
                Alert.show( event.message.toString() );
            } )      

        service.addEventListener( ResultEvent.RESULT , function(event:ResultEvent):void {
              var response: Object = JParser.decode( event.message.body.toString() );
              user_id.text = response.user.id;
              refreshUsers();           
            } )      


        var user:Object = new Object();
        if( this.user_id.text.length > 0 )
          user.id = this.user_id.text
        user.name = this.user_name.text;
        user.email = this.user_email.text;
        
        var json:String = JParser.encode( user );
        var jsonData:ByteArray = new ByteArray();
        jsonData.writeUTFBytes(json);
        jsonData.position = 0;
        var contentType:String = "application/json";

        //client.post(uri, jsonData, contentType);
        
        service.send( jsonData );
      }

      private function refreshUsers() : void {
        showPopupWait();
        
        var service: HTTPService = new HTTPService();
        service.contentType = "application/json";
        service.method = "GET";
        service.resultFormat = "text";
        // add random number to make browser grab new list.... sux, but works.
        service.url = uriBase+"?"+ (new Date).getTime();
        service.useProxy = false;
        
        service.addEventListener( FaultEvent.FAULT , function(event:FaultEvent):void {
                removePopup();
                Alert.show( event.message.toString() );
            } )      

        service.addEventListener( ResultEvent.RESULT , function(event:ResultEvent):void {
              var userList: Object = JParser.decode( event.message.body.toString() );
              users = userList.users as Array ;
                removePopup();
            } )      
        
        service.send();        
      }

      public function showPopup( message:String ) : void {
        if( this.popupLabel == null ) {
          this.popupLabel = new Label();
          this.popupLabel.text =  message ;
          this.popupLabel.setStyle( "fontSize" , "22" );
          this.popupLabel.setStyle( "fontWeight" , "bold" );
          PopUpManager.addPopUp( this.popupLabel, this, true );
          PopUpManager.centerPopUp( this.popupLabel );
        }
      }
      public function showPopupWait() : void {
        this.showPopup( "Please wait.....");
      }
      public function removePopup() : void {
        if( this.popupLabel != null )
          PopUpManager.removePopUp( this.popupLabel );
        this.popupLabel = null;
      }

    ]]>
  </mx:Script>
  
  <mx:DataGrid x="10" y="35" id="usersList" dataProvider="{users}" 
       width="469" height="159" itemClick="updateEdit()">
    <mx:columns>
      <mx:DataGridColumn headerText="ID" dataField="id"/>
      <mx:DataGridColumn headerText="Email" dataField="email"/>
      <mx:DataGridColumn headerText="Name" dataField="name"/>
    </mx:columns>
  </mx:DataGrid>
  <mx:Label x="10" y="10" text="Users" fontSize="14" fontWeight="bold"/>
  <mx:Button x="487" y="59" label="Add New" click="addNew()"/>
  <mx:Button x="487" y="89" label="Delete" width="76" click="deleteUser()"/>
  <mx:Button x="487" y="119" label="Refresh" width="76" click="refreshUsers()"/>
  <mx:Form x="10" y="202" width="469">
    <mx:FormItem label="User ID">
      <mx:TextInput id="user_id" width="353" editable="false"/>
    </mx:FormItem>
    <mx:FormItem label="User Name">
      <mx:TextInput id="user_name" width="353"/>
    </mx:FormItem>
    <mx:FormItem label="User Email">
      <mx:TextInput id="user_email" width="353"/>
    </mx:FormItem>
    <mx:FormItem>
      <mx:Button label="Save" width="96" click="saveUser()"/>
    </mx:FormItem>
  </mx:Form>
  
</mx:Application>

To serialize objects to and from the server we need a JSON library. I chose JSwoof.swc – JSON serializer and parser. I found it to be a little better qauality then the one in as3corelib, but you can use either one.

Once you get the project compiling, start your google app engine project locally, mine is configured to listen on port 8080, and then you can run the flex project. For the lazy (like me) here is the full project all ready to go.

Conclusion

Adding persistence support in google app engine project is not hard, you just need to read documentation carefully.

The harder part is to get flex talking to these services. Like any closed source solution you are at mercy of company making it, like we see in this particular case. Unfortunately there are no better alternative to FLex for building nice looking af functional web application, we just need to deal with its shortcomings.

You can check out the working application at rest-json-flex.appspot.com

In step 3 we will add session management, user authentication and authorization to our google app engine REST application.

Goolge app engine + java + spring + REST + JSON + Flex – Part 2 is a post from: Wet Feet - Online Marketing and Technology Blog

Once you are finished with this article, you will be able to implement REST services in Google Apps Engine using JAVA, Spring 3.0 and JSON. In the next part you will learn how to add flex application to consume the services.

Step one – Getting all required libraries: Google App Engine SDK, Spring and JSON serializer

If you are using Eclipse (my favorite IDE), you can install google plugin from here. If you choose to go another route, you need to download the sdk, create the project and join us back in the next section. Once you install the plugin, restart eclipse and you can see these buttons

you can proceed to the next section.

Step Two – Create new project

Go to new project wizzard

and select Web application project under google. you should get to the project settings screen

choose your project name (can be anything, not necessarily you google application name) and you base package, click finish and you should see the following project structure:

Step Three – Add Spring Support

Go to springsource.org and download latest 3.0 release, unzip it into a folder where you keep your java libs. Copy the following Jars into war\WEB-INF\llib directory:

1. org.springframework.asm-3.0.x.jar
2. org.springframework.beans-3.0.x.jar
3. org.springframework.context-3.0.x.jar
4. org.springframework.core-3.0.x.jar
5. org.springframework.expression-3.0.x.jar
6. org.springframework.oxm-3.0.x.jar
7. org.springframework.web-3.0.x.jar
8. org.springframework.web.servlet-3.0.x.jar

Also grab your favorite version of log4j.jar and commons-logging-1.1.1.jar. The trick with the commons-logging is to rename it to something like commons-fix-logging-1.1.1.jar, google app engine replaces this jar with its own version with crippled packages, by providing different name we keep both versions and make spring happy. Once you copied the jars, open project preferences and add those jars to the build library path.

Now lets get to the fun part – configuring spring.

Lets get rid of the generated servlet – just delete it. And open web.xml. My generated one looks like this:

<?xml version="1.0" encoding="utf-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5">
        <servlet>
                <servlet-name>Rest_json_flex</servlet-name>
                <servlet-class>com.lureto.rjf.Rest_json_flexServlet</servlet-class>
        </servlet>
        <servlet-mapping>
                <servlet-name>Rest_json_flex</servlet-name>
                <url-pattern>/rest_json_flex</url-pattern>
        </servlet-mapping>
        <welcome-file-list>
                <welcome-file>index.html</welcome-file>
        </welcome-file-list>
</web-app>

The final version should look like this:

<?xml version="1.0" encoding="utf-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5">

        <context-param>
                <param-name>log4jConfigLocation</param-name>
                <param-value>/WEB-INF/log4j.properties</param-value>
        </context-param>
        <listener>
                <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
        </listener>

    <servlet>
        <servlet-name>rest-json-flex</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>rest-json-flex</servlet-name>
        <url-pattern>/api/*</url-pattern>
    </servlet-mapping>

        <welcome-file-list>
                <welcome-file>index.html</welcome-file>
        </welcome-file-list>
        
</web-app>

As you can see I have moved log4j.properties from src to WEB-INF location. I like all my config files in one place, you can leave it in src or move it somewhere else, just adjust the path accordingly.  Second section defines Spring dispatcher servlet, then we map this servlet to /api/* path. All requests with this pattern will get routed to spring dispathcer servlet.

Step Four – Add JSON support

I looked around for good java JSON library and found couple good candidates. Since Spring uses Jackson JSON I decided to go the same route. Grab the library from here and put jackson-core-1.2.1.jar and jackson-mapper-1.2.1.jar file into projects WEB-INF/lib directory. Choose your favorite license when you downloading the jars.

Step Five – Configure Spring

To configure Spring servlet we need to create servletname-servlet.xml file for spring bean configuration. Our file has to be named rest-json-flex-servlet.xml.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p" 
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <context:component-scan base-package="com.lureto.rjf"/>
    
    <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
        <property name="messageConverters">
                <list>
                        <ref bean="jsonHttpMessageConverter"/>
                </list>
        </property>
        </bean>

    <bean id="jsonHttpMessageConverter"  class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter" />

        <bean class="com.lureto.rjf.spring.MyContentNegotiatingViewResolver">
                <property name="mediaTypes">
                        <map>
                                <entry key="json" value="application/json" />
                        </map>
                </property>
                <property name="defaultContentType" value="application/json" />
                <property name="defaultViews">
                        <list>
                                <bean class="com.lureto.rjf.spring.JsonView" />
                        </list>
                </property>
        </bean>
        
</beans>

First we tell String to scan “com.lureto.rjf” package for any bean annotations.

<context:component-scan base-package="com.lureto.rjf"/>

Next we define message converter to convert messages sent to the server into beans using MappingJacksonHttpMessageConverter

<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
        <property name="messageConverters">
                <list id="beanList">
                <ref bean="jsonHttpMessageConverter"/>
                </list>
        </property>
</bean>
<bean id="jsonHttpMessageConverter"  class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter" />

The last part tells spring to render messages sent from the server to the client using JsonView. Here we need to do some bug fixing, as you may have noticed the classes used are from “com.lureto.rjf.spring” and not from “org.springframework.web”.

<bean class="com.lureto.rjf.spring.MyContentNegotiatingViewResolver">
        <property name="mediaTypes">
                <map>
                        <entry key="json" value="application/json" />
                </map>
        </property>
        <property name="defaultContentType" value="application/json" />
        <property name="defaultViews">
                <list>
                        <bean class="com.lureto.rjf.spring.JsonView" />
                </list>
        </property>
</bean>

MyContentNegotiatingViewResolver.java – at the moment of writing this the 3.0.0.RC1 version of ContentNegotiatingViewResolver has bug with the list being singleton.

package com.lureto.rjf.spring;

import java.util.Arrays;
import java.util.List;

import javax.servlet.http.HttpServletRequest;

import org.springframework.http.MediaType;
import org.springframework.web.servlet.view.ContentNegotiatingViewResolver;

public class MyContentNegotiatingViewResolver extends ContentNegotiatingViewResolver {

        protected List<MediaType> getMediaTypes(HttpServletRequest request) { 
                List<MediaType> result = super.getMediaTypes(request); 
                if (result.size() == 1) 
                        result = Arrays.asList(result.get(0)); 
                return result; 
        }

        
}

JsonView.java – is a copy org.springframework.web.servlet.view.json.MappingJacksonJsonView with one change:

@Override
protected void renderMergedOutputModel(Map<String, Object> model,
                HttpServletRequest request,
                HttpServletResponse response) throws Exception {
        model = filterModel(model);
        JsonGenerator generator = objectMapper.getJsonFactory().createJsonGenerator(response.getWriter());
        if (prefixJson) {
                generator.writeRaw("{} && ");
        }
        objectMapper.writeValue(generator, model);
}

I had to change response.getOutputStream() to response.getWriter(), since jetty’s implementation of setting content type and encoding uses writer, if you try grabbing a stream after that, you will get an exception.

Step Six – Lets write a little bit of code

First lets define a model object that we will send across the wire. Here is my User.java class:

public class User {

        private long id;
        private String email;
        private String name;
        
        public long getId() {
                return id;
        }
        public void setId(long id) {
                this.id = id;
        }
        public String getEmail() {
                return email;
        }
        public void setEmail(String email) {
                this.email = email;
        }
        public String getName() {
                return name;
        }
        public void setName(String name) {
                this.name = name;
        }
}

And implement the controller to send and receive data. Here is my UserController.java:

package com.lureto.rjf;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import org.apache.log4j.Logger;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
@RequestMapping("/user")
public class UserController {

        private static Logger logger = Logger.getLogger( UserController.class );
        
        @ModelAttribute("users")
        @RequestMapping(value = "/", method = RequestMethod.GET)
        public List<User> listUsers() throws IOException {    
                List<User> users = new ArrayList<User>();
                
                User user = new User();
                user.setId(10001);
                user.setEmail("user.one@gmail.com");
                user.setName("User UNO");
                
                users.add(user);
                
                return users;
        }
        
        @ModelAttribute("user")
        @RequestMapping(value = "/", method = RequestMethod.POST)
        public User saveUser( @RequestBody User user ) throws IOException {
                logger.debug(user);
                return user;
        }
}

Lest go step my step through this and look at what all these little thing do.
We have marked our class as @Controller which indicates to sprign framework that this is a controller class. @RequestMapping(“/user”) indicates that this controller will handle requests that start with /user, /api/user to be precise, since spring servlet is configured to handle /api/* mappings.

@ModelAttribute("users")
@RequestMapping(value = "/", method = RequestMethod.GET)
public List<User> listUsers() throws IOException {

Here we define a methow which will be invoked when /api/user/ path gets called with GET method. If you running standard config http://localhost:8080/api/user/ would be the url to hit in the browser. @ModelAttribute(“users”) tells spring to put the object returned by this method into users model attribute for the view. Since we have wired everything in xml configuration, if we return the object it will be rendered by default view which serializes beans into JSON strings.
Our method for receiving json objects looks like this:

@ModelAttribute("user")
@RequestMapping(value = "/", method = RequestMethod.POST)
public User saveUser( @RequestBody User user ) throws IOException {
        logger.debug(user);
        return user;
}

@RequestBody annotation tells Spring framework to take request body and convert it into a bean using message converter. We have a single message converter defined in xml configuration file to be MappingJacksonHttpMessageConverter.

Conclusion

As you can see there is little code to write. In next Spring release the 2 bugs we fixed ourselves will probably be fixed, so this project will have only 2 source files, 3 xml files and 2 properties files. All the work is done by Spring framework, we just need to worry about the business logic and model.
Full project can be downloaded from here.
In the next part we will add flex project, so we can read the json object returned and post user object to the server.

UPDATE – October 27, 2009

Uncaught exception from servlet
java.lang.NullPointerException
        at com.google.apphosting.runtime.security.shared.RuntimeVerifier.isInspectable(RuntimeVerifier.java:302)
        at com.google.apphosting.runtime.security.shared.intercept.java.lang.Class_.getEnclosingMethod(Class_.java:237)
        at org.codehaus.jackson.map.util.ClassUtil.isLocalType(ClassUtil.java:88)
        at org.codehaus.jackson.map.deser.BeanDeserializerFactory.isPotentialBeanType(BeanDeserializerFactory.java:613)
        at org.codehaus.jackson.map.deser.BeanDeserializerFactory.createBeanDeserializer(BeanDeserializerFactory.java:61)
        at org.codehaus.jackson.map.deser.StdDeserializerProvider._createDeserializer(StdDeserializerProvider.java:248)
        at org.codehaus.jackson.map.deser.StdDeserializerProvider._createAndCacheValueDeserializer(StdDeserializerProvider.java:181)
        at org.codehaus.jackson.map.deser.StdDeserializerProvider.findValueDeserializer(StdDeserializerProvider.java:100)
        at org.codehaus.jackson.map.ObjectMapper._findRootDeserializer(ObjectMapper.java:1069)
        at org.codehaus.jackson.map.ObjectMapper._readMapAndClose(ObjectMapper.java:1002)
        at org.codehaus.jackson.map.ObjectMapper.readValue(ObjectMapper.java:818)
        ...... SNIP ......

After deploying to app engine I found out that jackson json library is using some unsupported introspection calls and had to make a fix inside jackson library to make it run inside google app engine. I have updated the jars inside the project to catch the exception and let parser to continue on its way. Here is the fix:

public static String isLocalType(Class<?> type)
{
        try {
                // one more: method locals, anonymous, are not good:
                if (type.getEnclosingMethod() != null) {
                        return "local/anonymous";
                }

                /* But how about non-static inner classes? Can't construct
                 * easily (theoretically, we could try to check if parent
                 * happens to be enclosing... but that gets convoluted)
                 */
                if (type.getEnclosingClass() != null) {
                        if (!Modifier.isStatic(type.getModifiers())) {
                                return "non-static member class";
                        }
                }
        } catch (  Exception exc ) {}
        return null;
}

Goolge app engine + java + spring + REST + JSON + Flex – Part 1 is a post from: Wet Feet - Online Marketing and Technology Blog

I have been inching to try out google app engine and its capabilities, but did not wan to give up the spring. So to day I am starting on my prototype involving Goolge app engine + java + spring + REST + JSON.

The end product will be spring mvc app running in google app engine handling GET, POST, PUT and DELETE http requests with JSON objects in and out utilizing JDO and seesions. This will give me a platform to write clients in Objective C for Ipod/Iphone (aka Coco Touch), Android, Flex, Ajax and maybe couple more platforms.

I am writing this while I am downloading Spring 3.0RC1. Will try to give daily updates if I can. If my prototype works as expected (all the research points to yes), I will have sample project available for download. There will be some trouble getting Flex to talk REST, since it only supports GET and POST and like most Adobe development stuff is not of the greatest maturity……. (opening new tab to check if we have new version of flex… still beta). Anyhow, Flex REST part will be interesting, I have already done some hacking in that area and it can be done – I have to write http client by hand, but who does not like an interesting challenge?

So here you have it. Next update when I have Spring 3 mvc inside google app engine up and running.

The part 1 is now online.

The part 2 is now online.

The part 3 is now online

The part 4 is now online

Goolge app engine + java + spring + REST + JSON is a post from: Wet Feet - Online Marketing and Technology Blog