Objective

To build flex application with ant without depending on FlexBuilder™ and to have statically linked and dynamically loaded libraries from separate flex projects. Adobe calls them “Component Libraries” and “Runtim Shared Libraries”.

The Problem

Adobe Flex ecosystem is in dark ages of automation and enterprise tools. Their flagship product in automation department is an ant task written by amateur intern. They don’t even bother to escape file paths when the call to mxml compiler are made from this ant task wrapper …(Ask me how I know). So the ant tasks do not work and the documentation for the mxmlc and compc are confusing and cover 50% of the features. But enough about the bad, lets get on to the solution.

I needed to create a pretty sophisticated app: We have a web application that talks JSON to a bunch of REST services. This app depends on some already prebuilt components that come in form of a library. This app also has to function as a stand alone demo application with no internet connection. For this we have split out the rest calls into 2 separate projects – the API (interface definitions) and demo implementation. if a flag is passed in via query parameter to the application it loads demo data in form of exampleDemData RSL.

The Solution

To build all this on maven I needed to create ant build script to produce the main app, html wrapper and demo data
RSL (runtime shared library). Here is how we do it. The project structure is set up like this:

\flexBuilds      ... ( where this build file resides )
\common-flex45   ... ( common components - component library )
\exampleApi      ... ( backend Access API - component library )
\exampleDemoData ... ( demo implementation of the API  - RSL )
\example         ... ( main Application )

For building we will be calling mxmlc and compc compilers ourselves instead of going through the adobe provided ant task wrappers, since they do not expose all the features and do not work if you path has a single space in it.
And now the build script:

<?xml version="1.0"?>
<project name="Example Flex Build" default="buildAll" basedir="../">

  <description>
      Example Flex Build script.
    </description>

  <property name="artifacts.dir" value="${basedir}/flexBuilds/atrifact" />
  <property name="flex.sdk.home" value="/...../sdks/4.5.1" />


  <target name="init">
    <mkdir dir="${artifacts.dir}"/>
    <delete includeemptydirs="true">
      <fileset dir="${artifacts.dir}" includes="**/*" />
    </delete>  
  </target>

  <target name="buildAll" depends="init">
    
    <antcall target="compile-library" >
      <param name="output.dir" value="${artifacts.dir}" />
      <param name="project.dir" value="common-flex45" />
      <param name="extra.stuff" value="" />
    </antcall>
    
    <antcall target="compile-library" >
      <param name="output.dir" value="${artifacts.dir}" />
      <param name="project.dir" value="exampleApi" />
      <param name="extra.stuff" value="" />
    </antcall>
    
    <antcall target="compile-library" >
      <param name="output.dir" value="${artifacts.dir}" />
      <param name="project.dir" value="exampleDemoData" />
      <param name="extra.stuff" value="-directory=true" />
    </antcall>

    <antcall target="compile-webApp" >
      <param name="app.name" value="ExampleApplication" />
      <param name="app.file" 
        value="example/src/com/wetfeetblog/example/ExampleApplication.mxml" />
      <param name="app.title" value="Example Application" />
      <param name="src.dir" value="example" />
      <param name="bin.dir" value="app" />
      <param name="extra.stuff" 
        value="-runtime-shared-library-path=${artifacts.dir}/exampleDemoData.swc,exampleDemoData.swf -verify-digests=false" />
    </antcall>
    <copy file="${artifacts.dir}/exampleDemoData.swc/library.swf" 
        toFile="${artifacts.dir}/app/exampleDemoData.swf"/>

    <echo message="All Flex Apps Compiled!" />
    
  </target>

  <target name="compile-library" >

    <fileset id="sources" dir="${basedir}/${project.dir}/src">
      <include name="**/*.mxml"/>
      <include name="**/*.as"/>
    </fileset>
    
    <pathconvert property="classes" pathsep=" " refid="sources">
      <compositemapper>
        <chainedmapper>
           <globmapper from="${basedir}/${project.dir}/src/*" 
              to="*" handledirsep="true" />
           <mapper type="package" from="*.as" to="*"/>
        </chainedmapper>
        <chainedmapper>
           <globmapper from="${basedir}/${project.dir}/src/*" 
              to="*" handledirsep="true" />
           <mapper type="package" from="*.mxml" to="*"/>
        </chainedmapper>
      </compositemapper>
    </pathconvert>
    
    <exec executable="${flex.sdk.home}/bin/compc" outputproperty="compile.output" dir="${basedir}">
      <arg line="-debug=false -output '${output.dir}/${project.dir}.swc' ${extra.stuff} -library-path+=${project.dir}/libs -library-path+=${artifacts.dir} -source-path ${project.dir}/src/ -include-classes ${classes} " />
    </exec>
    <echo message="${compile.output}" />
    
  </target>

  <target name="compile-webApp" >

    <echo message="Compiling ${app.name}" />
    
    <exec executable="${flex.sdk.home}/bin/mxmlc" outputproperty="compile.output" dir="${basedir}">
      <arg line="-debug=false -show-actionscript-warnings=false -output '${artifacts.dir}/${bin.dir}/${app.name}.swf' -library-path+='${artifacts.dir}' -library-path+=${src.dir}/libs ${extra.stuff} -source-path ${src.dir}/src/ --  ${app.file}" />
    </exec>
    <echo message="${compile.output}" />

    <copy file="${basedir}/${src.dir}/html-template/swfobject.js" 
          todir="${artifacts.dir}/${bin.dir}/"/>
    <copy file="${basedir}/${src.dir}/html-template/playerProductInstall.swf" 
          todir="${artifacts.dir}/${bin.dir}/"/>
    <copy file="${basedir}/${src.dir}/html-template/index.template.html" 
          tofile="${artifacts.dir}/${bin.dir}/index.html"/>
    
    
    <replace file="${artifacts.dir}/${bin.dir}/index.html" 
       value="${app.title}" token="${title}" />
    <replace file="${artifacts.dir}/${bin.dir}/index.html" 
       value="#ffffff" token="${bgcolor}" />
    <replace file="${artifacts.dir}/${bin.dir}/index.html" 
       value="${app.name}" token="${application}" />
    <replace file="${artifacts.dir}/${bin.dir}/index.html" 
       value="${app.name}" token="${swf}" />
    <replace file="${artifacts.dir}/${bin.dir}/index.html" 
       value="100%" token="${width}" />
    <replace file="${artifacts.dir}/${bin.dir}/index.html" 
       value="100%" token="${height}" />
    <replace file="${artifacts.dir}/${bin.dir}/index.html" 
       value="10" token="${version_major}" />
    <replace file="${artifacts.dir}/${bin.dir}/index.html" 
       value="0" token="${version_minor}" />
    <replace file="${artifacts.dir}/${bin.dir}/index.html" 
       value="0" token="${version_revision}" />
    
  </target>


  <target name="deploy-content" >
    <echo message="Deploying ${deploy.local.location} to ${deploy.host} " />
    <sshexec host="${deploy.host}" username="${deploy.user}" 
         password="${deploy.password}" command="rm ${deploy.remote.location}/*" 
         trust="true" failonerror="false"/>
    <scp todir="${deploy.user}:${deploy.password}@${deploy.host}:${deploy.remote.location}/" 
         verbose="true" trust="true" >
      <fileset dir="${deploy.local.location}" />
    </scp>      
  </target>
  
</project>

Lets examine all the little tricks one by one. We will start with “compile-library” target. It has multiple gotchas. For start compc is dumb enough not to recognize what needs to be compiled in, it needs a full list of classes fed into it to produce a library. But we do not want to list all the classes by hand, so when we add one more we will have to modify our build script. Lets get on with some ant magic.

<target name="compile-library" >

    <fileset id="sources" dir="${basedir}/${project.dir}/src">
      <include name="**/*.mxml"/>
      <include name="**/*.as"/>
    </fileset>
    
    <pathconvert property="classes" pathsep=" " refid="sources">
      <compositemapper>
        <chainedmapper>
           <globmapper from="${basedir}/${project.dir}/src/*" 
              to="*" handledirsep="true" />
           <mapper type="package" from="*.as" to="*"/>
        </chainedmapper>
        <chainedmapper>
           <globmapper from="${basedir}/${project.dir}/src/*" 
              to="*" handledirsep="true" />
           <mapper type="package" from="*.mxml" to="*"/>
        </chainedmapper>
      </compositemapper>
    </pathconvert>
    
    <exec executable="${flex.sdk.home}/bin/compc" outputproperty="compile.output" dir="${basedir}">
      <arg line="-debug=false -output '${output.dir}/${project.dir}.swc' ${extra.stuff} -library-path+=${project.dir}/libs -library-path+=${artifacts.dir} -source-path ${project.dir}/src/ -include-classes ${classes} " />
    </exec>
    <echo message="${compile.output}" />
    
  </target>

For compiling the main app the mxmlc compiler a little bit more sophisticated, so we can show it the main app mxml file and it figures out what needs to be included in the application. But the html wrapper we need to handle by hand, since mxmlc has no capabilities to do so. Luckily there is no code, just some placeholders needs to be replaced with real values. Ant can handle that with no problem.

No the tricky bits come into play when we want our exampleDemoData project to become the RSL. for that we need to specify that we wan the exploded output format, so we add “-directory=true” flag when compiling the library. In the main application we need to add a flag to use this swc as RSL. The flag to do so is “-runtime-shared-library-path=${artifacts.dir}/exampleDemoData.swc,exampleDemoData.swf”. If you want to rebuild the exampleDemoDAta project wihtout rebuilding the main application we need to add “-verify-digests=false” to the main app also, so the rsl version digest is not checked.

And that is it in a nutshel. You may find one more handy target for deploying your freshly built application on a unix based host via scp in this build script.

How to build any Flex project with Ant the right way is a post from: Wet Feet - Online Marketing and Technology Blog

Objective

To have one self containing class that can be plugged into any servlet container. Class will log everything about the request and response, including the payload data coming in and going out.

The Problem

I need to dump out the payload for posts, gets and responses to troubleshoot some issues where data got mismatched between the request and response. Ideal solution would have all this data on one single line. Quick look around gave no off the shelf results, so I put together a quick Filter implementation to capture request and response data.

The biggest challenge is to get the copies of request and response payload for logging and still eave it in tact for servlet processing. I had the write wrappers for input and output streams, as you will see in the inner classes. Here is the code:

package com.your.package.name;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletInputStream;
import javax.servlet.ServletOutputStream;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.io.output.TeeOutputStream;
import org.apache.log4j.Logger;

public class ReqRespDumpFilter implements Filter {

        
        private static final Logger logger = Logger.getLogger(ReqRespDumpFilter.class);
        
        @Override
        public void init(FilterConfig filterConfig) throws ServletException {
        }

        @Override
        public void doFilter(ServletRequest request, ServletResponse response,FilterChain chain) 
                                throws IOException, ServletException {
        try {
                HttpServletRequest httpServletRequest = (HttpServletRequest)request;
                HttpServletResponse httpServletResponse = (HttpServletResponse)response;
        
                Map<String, String> requestMap = this.getTypesafeRequestMap(httpServletRequest);
                BufferedRequestWrapper bufferedReqest = new BufferedRequestWrapper(httpServletRequest);  
                BufferedResponseWrapper bufferedResponse = new BufferedResponseWrapper(httpServletResponse);
        
                final StringBuilder logMessage = new StringBuilder("REST Request - ")
                           .append("[HTTP METHOD:")
                           .append(httpServletRequest.getMethod())                                        
                           .append("] [PATH INFO:")
                           .append(httpServletRequest.getPathInfo())                                        
                           .append("] [REQUEST PARAMETERS:")
                           .append(requestMap)
                           .append("] [REQUEST BODY:")
                           .append(bufferedReqest.getRequestBody())                                        
                           .append("] [REMOTE ADDRESS:")
                           .append(httpServletRequest.getRemoteAddr())
                           .append("]");
        
                chain.doFilter (bufferedReqest, bufferedResponse);        
                logMessage.append(" [RESPONSE:").append( bufferedResponse.getContent() ).append("]");
                logger.debug(logMessage);
        } catch( Throwable a ) {
                logger.error(a);
        }
        }

        
        private Map<String, String> getTypesafeRequestMap(HttpServletRequest request) {
                Map<String, String> typesafeRequestMap = new HashMap<String, String>();
                Enumeration<?> requestParamNames = request.getParameterNames();
                while (requestParamNames.hasMoreElements()) {
                        String requestParamName = (String)requestParamNames.nextElement();
                        String requestParamValue = request.getParameter(requestParamName);
                        typesafeRequestMap.put(requestParamName, requestParamValue);
                }
                return typesafeRequestMap;
        }       
        
        
        @Override
        public void destroy() {
        }

        
        private static final class BufferedRequestWrapper extends HttpServletRequestWrapper {

        private ByteArrayInputStream bais = null;
        private ByteArrayOutputStream baos = null;
        private BufferedServletInputStream bsis = null;
        private byte[] buffer = null;
 

        public BufferedRequestWrapper(HttpServletRequest req) throws IOException {
            super(req);
            // Read InputStream and store its content in a buffer.
            InputStream is = req.getInputStream();
            this.baos = new ByteArrayOutputStream();
            byte buf[] = new byte[1024];
            int letti;
            while ((letti = is.read(buf)) > 0) {
                this.baos.write(buf, 0, letti);
            }
            this.buffer = this.baos.toByteArray();
        }

        
        @Override
        public ServletInputStream getInputStream() {
            this.bais = new ByteArrayInputStream(this.buffer);
            this.bsis = new BufferedServletInputStream(this.bais);
            return this.bsis;
        }

        

        String getRequestBody() throws IOException  {
            BufferedReader reader = new BufferedReader(new InputStreamReader(this.getInputStream()));
            String line = null;
            StringBuilder inputBuffer = new StringBuilder();
            do {
                line = reader.readLine();
                if (null != line) {
                        inputBuffer.append(line.trim());
                }
            } while (line != null);
            reader.close();
            return inputBuffer.toString().trim();
        }

    }


    private static final class BufferedServletInputStream extends ServletInputStream {

        private ByteArrayInputStream bais;

        public BufferedServletInputStream(ByteArrayInputStream bais) {
            this.bais = bais;
        }

        @Override
        public int available() {
            return this.bais.available();
        }

        @Override
        public int read() {
            return this.bais.read();
        }

        @Override
        public int read(byte[] buf, int off, int len) {
            return this.bais.read(buf, off, len);
        }
 

    }
        
    public class TeeServletOutputStream extends ServletOutputStream {

        private final TeeOutputStream targetStream;

        public TeeServletOutputStream( OutputStream one, OutputStream two ) {
                targetStream = new TeeOutputStream( one, two);
        }
        
                @Override
                public void write(int arg0) throws IOException {
                        this.targetStream.write(arg0);
                }
                
                public void flush() throws IOException {
                        super.flush();
                        this.targetStream.flush();
                }

                public void close() throws IOException {
                        super.close();
                        this.targetStream.close();
                }               
    }
    
    
    
    public class BufferedResponseWrapper implements HttpServletResponse {

        HttpServletResponse original;
        TeeServletOutputStream tee;
        ByteArrayOutputStream bos;

        public BufferedResponseWrapper(HttpServletResponse response) {
                original = response;
        }

        public String getContent() {
                        return bos.toString();
                }
        
        public PrintWriter getWriter() throws IOException {
                return original.getWriter();
        }

        public ServletOutputStream getOutputStream() throws IOException {
                if( tee == null ){
                        bos = new ByteArrayOutputStream();
                        tee = new TeeServletOutputStream( original.getOutputStream(), bos );
                }
                return tee;

        }

                @Override
                public String getCharacterEncoding() {
                        return original.getCharacterEncoding();
                }

                @Override
                public String getContentType() {
                        return original.getContentType();
                }

                @Override
                public void setCharacterEncoding(String charset) {
                        original.setCharacterEncoding(charset);
                }

                @Override
                public void setContentLength(int len) {
                        original.setContentLength(len);
                }

                @Override
                public void setContentType(String type) {
                        original.setContentType(type);
                }

                @Override
                public void setBufferSize(int size) {
                        original.setBufferSize(size);
                }

                @Override
                public int getBufferSize() {
                        return original.getBufferSize();
                }

                @Override
                public void flushBuffer() throws IOException {
                        tee.flush();
                }

                @Override
                public void resetBuffer() {
                        original.resetBuffer();
                }

                @Override
                public boolean isCommitted() {
                        return original.isCommitted();
                }

                @Override
                public void reset() {
                        original.reset();
                }

                @Override
                public void setLocale(Locale loc) {
                        original.setLocale(loc);
                }

                @Override
                public Locale getLocale() {
                        return original.getLocale();
                }

                @Override
                public void addCookie(Cookie cookie) {
                        original.addCookie(cookie);
                }

                @Override
                public boolean containsHeader(String name) {
                        return original.containsHeader(name);
                }

                @Override
                public String encodeURL(String url) {
                        return original.encodeURL(url);
                }

                @Override
                public String encodeRedirectURL(String url) {
                        return original.encodeRedirectURL(url);
                }

                @SuppressWarnings("deprecation")
                @Override
                public String encodeUrl(String url) {
                        return original.encodeUrl(url);
                }

                @SuppressWarnings("deprecation")
                @Override
                public String encodeRedirectUrl(String url) {
                        return original.encodeRedirectUrl(url);
                }

                @Override
                public void sendError(int sc, String msg) throws IOException {
                        original.sendError(sc, msg);
                }

                @Override
                public void sendError(int sc) throws IOException {
                        original.sendError(sc);
                }

                @Override
                public void sendRedirect(String location) throws IOException {
                        original.sendRedirect(location);
                }

                @Override
                public void setDateHeader(String name, long date) {
                        original.setDateHeader(name, date);
                }

                @Override
                public void addDateHeader(String name, long date) {
                        original.addDateHeader(name, date);
                }

                @Override
                public void setHeader(String name, String value) {
                        original.setHeader(name, value);
                }

                @Override
                public void addHeader(String name, String value) {
                        original.addHeader(name, value);
                }

                @Override
                public void setIntHeader(String name, int value) {
                        original.setIntHeader(name, value);
                }

                @Override
                public void addIntHeader(String name, int value) {
                        original.addIntHeader(name, value);
                }

                @Override
                public void setStatus(int sc) {
                        original.setStatus(sc);
                }

                @SuppressWarnings("deprecation")
                @Override
                public void setStatus(int sc, String sm) {
                        original.setStatus(sc, sm);
                }

    }
        
}

web.xml configuration

You need to add filter declaration to your web.xml and configure filter mapping for specific url(s).

<filter>
                <filter-name>RRDumpFilter</filter-name>
                <filter-class>com.your.package.name.ReqRespDumpFilter</filter-class>
        </filter>
         
        <filter-mapping>
                <filter-name>RRDumpFilter</filter-name>
                <url-pattern>/*</url-pattern>
        </filter-mapping>

Conclusion

Now you can have your pie and eat it too. I mean see your request and response payload without adding logging of it in every servlet/controller/resource/endpoint/etc. Tested with java 1.6 in Tomcat 6. Dependency on commons-io to provide TeeOutputStream implementation and log4j, but you can substitute.

Servlet Filer to Log Request and Response Payload is a post from: Wet Feet - Online Marketing and Technology Blog

Upon arrival parking lot look very very wet! And it was still raining, 40 degrees and 15mph wind gusts. Ouch!

I was working the course first run and driving second. (Autocross events are volunteer based, so everybody has to contribute) After two hours in the middles of a very windy wet and cold parking lot, was my turn to drive.

My first run was a spin-out 75.447+2. I came in too fast into very tight corner and the rear end overtook the front. Now that I think about it, my car was too tail happy, I think I had my tire pressures too high for such a cold day. Enjoy the video.

On the second run I took on a passenger, he completely blocked the camera view, so there is no video. I took it easier and finished the run in 59.276

Third run Turned out to be my best of the day – 57.852 Enjoy!

On the second and third runs something in the front suspension was banging very loudly, so on the lasts run I did not go as hard as on the Third one. Result 58.207.

Here are some pictures from the event

2011 March 6, SCCA Atlanta Autocross @ Turner Field is a post from: Wet Feet - Online Marketing and Technology Blog

Objective

This article will show you how to implement a full text search in Google App Engine using JDO. I tried my hand at this couple month ago, but after watching this presentation I decided to do it properly.

The Problem

In my first attempt I managed to get the search working, but after watching Brett Slatkin’s presentaion I realized where the problem is. In short deserializing a list of strings (which is our search index) is a very costly operation, but he presented with a solution. Bellow you will find my solution to this problem.

Data Model

For this example we will use such data model: we have Customer (name, contact, notes) which has a list of Addresses and Phones. We need ability to find customer by name, address or phone.

@PersistenceCapable(identityType = IdentityType.APPLICATION, detachable="true")
public class Customer {
    @PrimaryKey
    @Persistent(valueStrategy = IdGeneratorStrategy.IDENTITY)
    private Long id;

    @Persistent
    private String name;
    @Persistent
    private String contactName;
    @Persistent
    private String comments;

    @Persistent(mappedBy = "customer")
    @Element(dependent = "true")
    private List<Address> addresses = new ArrayList<Address>();

    @Persistent(mappedBy = "customer")
    @Element(dependent = "true")
    private List<Phone> phones = new ArrayList<Phone>();

    @Persistent(dependent="true")
    private CustomerIndex index;

   // getters and setter go here....
}

@PersistenceCapable(identityType = IdentityType.APPLICATION, detachable="true")
public class Address {
    @PrimaryKey
    @Persistent(valueStrategy = IdGeneratorStrategy.IDENTITY)
    private Key id;
    @Persistent
    private String type;
    @Persistent
    private String line1;
    @Persistent
    private String line2;
    @Persistent
    private String city;
    @Persistent
    private String state;
    @Persistent
    private String zip;
    @Persistent
    private Customer customer;

   // getters and setter go here....
}

@PersistenceCapable(identityType = IdentityType.APPLICATION, detachable="true")
public class Phone {
   @PrimaryKey
    @Persistent(valueStrategy = IdGeneratorStrategy.IDENTITY)
    private Key id;
    @Persistent
    private String type;
    @Persistent
    private String phone;
    @Persistent
    private Customer customer;

   // getters and setter go here....
}

If you paid attention you notice that we have an interesting child in the Customer class called CustomerIndex. Here it is:

@PersistenceCapable(identityType = IdentityType.APPLICATION, detachable="true")
public class CustomerIndex {
    @PrimaryKey
    @Persistent(valueStrategy = IdGeneratorStrategy.IDENTITY)
    private Key id;
    @Persistent
    private Set<String> index;

   // getters and setter go here....
}

Search Approach

Here is the theory of what we gonna do: Since deserializing of List properties is a very very costly operation (and we do not care abut the data it holds anyway) we move customer search index property into a Child object. We will perform a search on this Child and we will get only the keys of the child objects. This way we do not have to incur the penalty of deserializing our search index (the search happens on the index). Once we have our child object keys we will load Parent objects with those keys. We can do this because a child key is a composite key and always includes parent key.
To make our search more usable we will use Lucenen and SnowballAnalyzer for word stemming.
Here is the method that gives us the Set of words. We use it to generate the index of searchable words as well as search phrases.

protected Set<String> getIndex( String input, int maxTokens ) {
  Set<String> returnSet = new HashSet<String>();
  try {
    Analyzer analyzer =  new SnowballAnalyzer( org.apache.lucene.util.Version.LUCENE_30,"English", stopWords());
    TokenStream tokenStream = analyzer.tokenStream( "content", new StringReader(input) );
    while ( tokenStream.incrementToken() && (returnSet.size() < maxTokens) ) {
      if( tokenStream.hasAttribute( TermAttribute.class ) ) {
        TermAttribute attr = tokenStream.getAttribute( TermAttribute.class );
        logger.debug( attr.term() );
        returnSet.add( attr.term() );
      }
    }
  }catch( Exception exc ) {
    logger.equals(exc);
  }
  return returnSet;
}

Here is our search method:

public List<Customer> searchCustomers( String search1, Long entityId ) throws IOException {
  PersistenceManager pm = PMF.getManager();

  Set<String> search = getIndex(search1, 3);
  Query query = pm.newQuery("SELECT id FROM " + CustomerIndex.class.getName() );
  query.setFilter("index == param0");
  query.declareParameters("String param0");

  Query query2 = pm.newQuery(Customer.class);
  query2.setFilter("id == keyParam");
  query2.declareParameters("com.google.appengine.api.datastore.Key keyParam");

  List<Customer> custs = null;
  List<Key> keys;
  List<Key> parents = new ArrayList<Key>();

  try {
    keys = (List<Key>) query.execute( search );
    for( Key k : keys){
      parents.add( k.getParent() );
  }
  custs = (List<Customer>) query2.execute( parents );
  for( Customer cust : custs ) {
    for( Address addr : cust.getAddresses() )
      logger.debug( addr.getId() );
    for( Phone ph : cust.getPhones() )
      logger.debug( ph.getId() );
    }
  } catch ( Exception exc ) {
    logger.error(exc);
  } finally {
    query.closeAll();
    query2.closeAll();
    pm.close();
  }
  return custs;
}

You will notice that we walk the address and Phone lists for each customer to load them form Storage. We do that so we can ship them over the wire. UI in this case is a Flex client, so we do JSON serialization of the results.

Conclusion

Text searching can be implemented in GAE and to boot it can be implemented efficiently. Just remember before you store this Customer record you need to build out the CustomerIndex object with the set of words that we will search on. I just concat all the properties to one string and Lucene build the set for me by calling my getIndex().

Google App Engine – Full Text Search with JDO – Revisited is a post from: Wet Feet - Online Marketing and Technology Blog

Objective

This post will show you how to use Spring JDBC Template to perform real world CRUD operations. I hope I can show you that you do not need overweight Hibernate to interact with database of your choice.

The Problem Domain

Almost all application I have coded needed to store and get data of some sort. In most cases it was relational database. With hibernate being all the rage these days I have used it in multiple projects with varying degree of problems and success. In my personal opinion hibernate tries to solve a problem that really is not there. If you can not wire SQL you should not be using Hibernate or be doing any software development.

I advise the use of Spring JDBC templates. In essence Spring JDBC Template will offload all the mundane steps of database access from you shoulders only requiring you to write SQL and move data from result set into your model objects. Here is how Spring documentation describes responsibilities:

CRUD Example with Spring JDBC Template

For this example you will need spring-core, spring-tx and spring-aop components. We will use spring-tx to manage the transaction so we can get back the auto generated IDs of the persisted objects and aop to set up the transaction management. Here is meat for spring configuration file:

<bean id="propertyPlaceholder" 
      class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer" >
  <property name="location" value="/WEB-INF/config.properties" />
</bean>

<bean id="mysqlDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" 
      destroy-method="close">
  <property name="driverClass" value="com.mysql.jdbc.Driver"/>
  <property name="jdbcUrl" value="${database.url}"/>
  <property name="user" value="${database.user}"/>
  <property name="password" value="${database.password}"/>
  <property name="initialPoolSize" value="${database.connections.start}"/>
  <property name="maxPoolSize" value="${database.connections.max}"/>  
  <property name="idleConnectionTestPeriod" value="270" />
</bean>

<bean id="txManager" 
      class="org.springframework.jdbc.datasource.DataSourceTransactionManager" >
  <property name="dataSource" ref="mysqlDataSource" />
</bean>

<tx:advice id="txAdvice" transaction-manager="txManager">
  <tx:attributes>
    <!-- all methods starting with 'get' are read-only -->
    <tx:method name="get*" read-only="true"/>
    <tx:method name="list*" read-only="true"/>
      <!-- other methods use the default transaction settings (see below) -->
      <tx:method name="*"/>
    </tx:attributes>
</tx:advice>

<aop:config>
  <aop:pointcut id="uOwnerDataSvcOperation" 
      expression="execution(* com.es.rto.dao.UOwnerDataServiceImpl.*(..))"/>
  <aop:advisor advice-ref="txAdvice" pointcut-ref="uOwnerDataSvcOperation"/>
</aop:config>

<bean id="namedTemplate" 
    class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
  <constructor-arg index="0" ref="mysqlDataSource"/>   
</bean>

<bean id="qandADao" class="com.es.rto.dao.QandADao" >
  <property name="jdbcTemplate" ref="namedTemplate" />
</bean>

<bean id="uOwnerDataSvc" class="com.es.rto.dao.UOwnerDataServiceImpl" >
  <property name="qandADao" ref="qandADao" />
</bean>

First thing we do we load our config.properties file where we have database configuration defined. Second we define a pooled data source to connect to mysql database. Third bean is a transaction manager that is watching our data source from the step two. Next we set up our transaction manager. We instruct transaction manager that methods starting with “get” and “list” are read only. This means that they will not be subject to transaction management. Then we define named jdbc template and pass in the data source as first constructor argument and then pass in the template into our own DAO bean.

Why do we need Transaction Management?

When we create a new row in a mysql table with autoincrement id value we need a way to get that auto generated id. To do so we need to query the database using same connection. When we use jdbcTemplate.update() or jdbcTemplate.query() it will check out a connection form the pool execute the query, process the results and return this connection to the pool. So if we do update() and then get() to query “SELECT LAST_INSERT_ID()” we will get another connection, which is a problem since we need to do this on the same connection to get the right id. This is where the transaction comes in. Instead of releasing connection back to the pool spring will hold on to it until we are done with it.

Java code side of the Spring JDBC template

We will use 3 beans to illustrate the scenario: question, answer and user.

public class Question {
        private long questionId;
        private long categoryId;
        private long userId;
        private long areaId;
        private String question;
        private String verifyKey;
        private Date created;
        private User user;
        private List<Answer> answers;
        private long answerCount;
        private String name;
        // getters and setters omited...
}

public class Answer {
        private long answerId;
        private long questionId;
        private long userId;
        private String answer;
        private String verifyKey;
        private String url;
        private Date created;
        private User user;
        private String name;
        // getters and setters omited...
}

public class User implements Serializable {
        private long id;
        private String email;
        private String retypeE;
        private String name;
        private String password;
        private String password2;
        private String verifyKey;
        private boolean buyer;
        private boolean seller;
        private boolean active;
        private boolean privacy;
        private int pageSize = 20;
        private String next;
        private boolean administrator;
        // getters and setters omited...
}

Here are the 2 classes that do all the work:

public class QandADao {

  private final Logger logger = Logger.getLogger(QandADao.class);
  protected NamedParameterJdbcTemplate jdbcTemplate = null;
  

  @SuppressWarnings("unchecked")
  public List<Question> getQuestions( String search, int page, int step ) {
    try {
      MapSqlParameterSource params = new MapSqlParameterSource( "search", "%"+search+"%" );
      String sql = "SELECT q.*, count( a.answer_id ) as answers, u.name, u.seller  FROM users u, questions q LEFT JOIN answers a "+
      "ON  a.question_id = q.question_id WHERE a.answer LIKE :search AND q.user_id = u.id "+
      "GROUP BY q.question_id, q.category_id, q.user_id, q.question, q.created, q.area_id, u.name, u.seller "+  
      "UNION "+
      "SELECT q.*, count( a.answer_id ) as answers, u.name, u.seller  FROM users u, questions q LEFT JOIN answers a "+ 
      "ON  a.question_id = q.question_id WHERE q.question LIKE :search AND q.user_id = u.id "+
      "GROUP BY q.question_id, q.category_id, q.user_id, q.question, q.created, q.area_id, u.name, u.seller "+
      "LIMIT "+(step*(page-1))+", "+step;
      logger.debug( sql );
      return jdbcTemplate.query(sql, params, new RowMappers.QuestionsMapper());
    } catch ( DataAccessException exc ) {
      logger.error("FAILED to get Question List", exc);
      return new ArrayList<Question>();
    }
  }

  public Question saveQuestion( Question question ) {
    try {
      BeanPropertySqlParameterSource namedParameters = new BeanPropertySqlParameterSource(question);
      String sql;
      if( question.getQuestionId() == 0 )
        sql = "INSERT INTO questions ( category_id, user_id, question, area_id, uname ) VALUES ( :categoryId, :userId, :question, :areaId, :name )";
      else
        sql = "UPDATE questions SET question=:question, category_id=:categoryId, area_id=:areaId WHERE question_id=:questionId";
      logger.debug( sql );
      jdbcTemplate.update(sql, namedParameters);
      if( question.getQuestionId() == 0 )
        question.setQuestionId( this.getInsertedID() );
        
    } catch ( DataAccessException exc ) {
      logger.error("SAVE answer FAILED!", exc);
      throw exc;
    }
    return question;
  }

  protected long getInsertedID() {
    return jdbcTemplate.queryForLong( "SELECT LAST_INSERT_ID()" , new MapSqlParameterSource());
  }
  
}

public class RowMappers {

  public static final class QuestionMapper implements RowMapper {
      public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
        Question q = new Question();
        q.setQuestionId(rs.getLong( "question_id" ));
        q.setCategoryId(rs.getLong( "category_id" ));
        q.setUserId(rs.getLong( "user_id" ));
        q.setAreaId( rs.getLong("area_id"));
        q.setQuestion( rs.getString("question"));
        q.setCreated( rs.getTimestamp( "created" ) );
        q.setName( rs.getString("uname") );
        User u = new User();
        u.setName( rs.getString("name") );
        u.setSeller( rs.getBoolean("seller") );
        u.setId(q.getUserId());
        q.setUser(u);
      return q;
    }
  } 
}

So what is going on here? Lets look at the QuestionMapper. It implements one method – mapRow. Its hob is to process a single row of the result set. As you see here we create a Question bean and a User bean which is included in the Questions bean. It can not be more strait forward then this.

QandADao is the class where all the magic happens. First lets examine the getQuestions() method. First we define query parameter(s) using MapSqlParameterSource class. We simply put the values in the map and jdbc template will pull them out by the key. Next we write our sql query. In this case iti is pretty complex to pull out any questions where either question or the answer have the thing we are searching for. We use union to be able to pull out the questions without the answers. Lastly we call query method on the jdbc template and we pass in our query, parameters and the row mapper instance. Spring takes care of all the plumbing. What we get out of this call is a list of Question objects.

saveQuestion() method is not much different. In this case we use BeanPropertySqlParameterSource which maps bean properties to sql parameters. If you define a sql parameter “name” your bean should have “getName()” method. Instead of calling query() we call update() on the jdbc template which only takes sql and the parameters.

Conclusion

You may have noticed that the effort to use the Spring approach to JDCB is very simple, flexible and powerful. You have all the control in all the right places! You write the sql with all the performance hints and tweaks, you write code how to transfer results to the domain objects the way you need it or like it. I only mentioned about one tenth of the options you have with spring. Read The Fine Manual (RTFM) to explore the full potential.

Spring JDBC Template – A leaner alternative to fat Hibernate is a post from: Wet Feet - Online Marketing and Technology Blog

Objective

I just wanted to share my thoughts about the frameworks in the Flex environment. You may have noticed that I am in love with Spring when I write Java code, but how about Flex? For a simple example application I go with KISS (keep it stupid simple) approach, but for serious data driven app I utilize a framework.

How to choose a framework that works for You

Firs of all you need to know what you are looking for, because if you do not know where you are going, any path will take you there. When I first started to p[lay with Flex about 3 years ago, I noticed that I need to add some structure to the application. Since I was already using Spring I started looking for a framework. At that point in time there where only two alternatives worth looking at: Cairngorm (heavily pushed by Adobe) and PureMVC.

To select a framework I used both framework to build a simple sample application. After spending a day on the exercise I chose PureMVC. PureMVC solution was cleaner, it suited my need better and I felt that it did a better job at structuring the application. I stuck with PureMVC fro quite a while, Until couple month ago I decided to take a look of something better came along.

All the hype was around this English word "Mate", meaning friend or buddy. Even some developers around me have deep religious belief that Mate will save the world. So I had to take a deeper look at this framework. I build a simple application to get a feel for the framework and found that I do not like quite a lot of things about Mate.

First of all everything is done in the sudo code called MXML. I like writing code, I like to have control and make things exactly like they should be and generated code not allays works exactly like I need it to. Then I started looking into some other aspects of the Mate framework and found a better solution. If you are interested in a deeper reading about what I do not like about mate here are couple posts from Shaun that I agree with:

AS3 Dependency Injection and [Autowire]
Another Architectural Framework, But Why?

After looking around I chose to use Robotlegs Framework. It gave me exactly what I needed: dependency injection, mediators and proxies. What you need for your application may be completely different and you may choose another framework, but give robotlegs a good look over to see if it will fit your need too.

Conclusion

Select a framework with a particular need in mind, don’t just use one because Adobe pushed it or your mate recommended it. Understand framewrok’s pros and cons and choose the one that give you the most bang per line of code or xml if that is your coding flavor.

Let me know in the comments which other framework you have used and would recommend to others.

Flex Frameworks – PuremVC, Mate, Cairngorm and Robotlegs is a post from: Wet Feet - Online Marketing and Technology Blog

Objective

This article will show you how to implement a simple search in Google App Engine using JDO engine including searching in child objects.

The Problem Domain

In my application I need to search for data and you probably need to do the same in yours. In Google App Engine you can not query for properties of the child objects. In SQL world this means you can not use “where” clause. So how we can not construct a query which looks at child objects. So how can we implement search in such restrictive environment?

The Solution

I came up with a very simple solution – I created an “index” property where I store all the data that I need to search on. Let’s say we have a Customer bean that has multiple addresses and phones. We want to be able to search on address, phone and customer name. Here are our beans:

@PersistenceCapable(identityType = IdentityType.APPLICATION, detachable="true")
public class Customer implements Serializable {
    private static final long serialVersionUID = -3665292067832675548L;

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

    @Persistent(mappedBy = "customer")
    @Element(dependent = "true")
    private List<Address> addresses = new ArrayList<Address>();

    @Persistent(mappedBy = "customer")
    @Element(dependent = "true")
    private List<Phone> phones = new ArrayList<Phone>();

    @Persistent
    private List<String> index;

    // Getters and Setter go here...
}

@PersistenceCapable(identityType = IdentityType.APPLICATION, detachable="true")
public class Address {
    @PrimaryKey
    @Persistent(valueStrategy = IdGeneratorStrategy.IDENTITY)
    private Key id;
    @Persistent
    private String type;
    @Persistent
    private String name;
    @Persistent
    private String line1;
    @Persistent
    private String line2;
    @Persistent
    private String city;
    @Persistent
    private String state;
    @Persistent
    private String zip;
    @Persistent
    private Customer customer;

    // Getters and Setter go here...
}

@PersistenceCapable(identityType = IdentityType.APPLICATION, detachable="true")
public class Phone {
    @PrimaryKey
    @Persistent(valueStrategy = IdGeneratorStrategy.IDENTITY)
    private Key id;
    @Persistent
    private String type;
    @Persistent
    private Number phone;
    @Persistent
    private Customer customer;

    // Getters and Setter go here...
}

In the Customer bean we defined an “index” property which is a String array. We will put all our searchable words int this index, so later we can construct a query. Before we save our customer we want to populate index property like this:

public void rebuildIndex() {
        index = new ArrayList<String>();
                
        Iterator<Address> it = this.addresses.iterator();
        while( it.hasNext() ) {
                Address ad = it.next();
                if( ad.getLine1() != null ){
                        String[] idx = ad.getLine1().split(" ");
                        for( int i = 0 ; i < idx.length ; i++ )
                                index.add( idx[i] );
                }
                if( ad.getLine2() != null ){
                        String[] idx = ad.getLine2().split(" ");
                        for( int i = 0 ; i < idx.length ; i++ )
                                index.add( idx[i] );
                }
        }

        Iterator<Phone> it2 = this.phones.iterator();
        while( it2.hasNext() ) {
                Phone ph = it2.next();
                if( ph.getPhone() != null )
                        index.add( ph.getPhone().toString() );
        }

        String[] idx = name.split(" ");
        for( int i = 0 ; i < idx.length ; i++ )
                index.add( idx[i] );
                
        idx = contactName.split(" ");
        for( int i = 0 ; i < idx.length ; i++ )
                index.add( idx[i] );
                
}

Now we have all our searchable words from child beans and parent bean in one property we can search on. Here is how my search method looks like:

@SuppressWarnings("unchecked")
@ModelAttribute("custs")
@RequestMapping(value = "/{search}", method = RequestMethod.GET)
public List<Customer> searchCustomers( @PathVariable String search, HttpSession session)
                                          throws IOException {
    PersistenceManager pm = pmf.getManager();
    Query query = pm.newQuery(Customer.class);
    query.setFilter("index == searchParam");
    query.declareParameters("String searchParam");
    List<Customer> custs;
    try {
        custs = (List<Customer>) query.execute( search );
    } finally {
        query.closeAll();
    }
    return custs;
}

Conclusion

We found an easy way around the big table JDO implementation limitation in Google App Engine. It is a simple and strait forward workaround, but it has couple drawbacks: we can only search on full words and we duplicate data using more storage space. In my book storage is cheap so that is not a big concern for me.

As I progress more with my projects on Google App Engine, I will surely revisit the search topic and post about other solutions to this challenge.

If you have a better solution please post it in the comments, I would love to give it a try!

Google App Engine + JAVA + JDO = Simple Search is a post from: Wet Feet - Online Marketing and Technology Blog

Objective

This article will show you how to persist real world data in Google App Engine. You will learn how to handle inheritance and one-to-many owned relationships in your model objects and store them correctly in the big table implementation of JDO.

The Problem Domain

In my application I need to segregate data by the customer this data belongs to. We will use inheritance in model objects, so all of them will have customer id defined in the base class. We will make the JDO save base class properties in the sub class “table”. We will also learn how to instruct Google App Engine JDO to handle customers with multiple addresses and phone numbers for us. If we define the relationship between model objects correctly JDO will manage storing/retrieving/deleting of these lined objects without our involvement.

Inheritance in Model Classes

First let’s define a superclass for all our model classes:

package com.yourcorp.here;

import java.io.Serializable;

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

@PersistenceCapable(identityType = IdentityType.APPLICATION, detachable="true")
@Inheritance(strategy=InheritanceStrategy.SUBCLASS_TABLE)
public class ModelBase implements Serializable{

    @PrimaryKey
    @Persistent(valueStrategy = IdGeneratorStrategy.IDENTITY)
    private Long id;
    @Persistent
    protected Long customerId;

    private static final long serialVersionUID = 3039288063578312662L;

    // getters & setters go here
}

What we done here is defined Model Base class that has two properties – ID and customerID and marked them as persistent. We also annotated that our class is persistence capable and defined Inheritance strategy. In this case we chose to use Subclass Table. What this means is that ID and customerID properties will be saved in the table of the class that inherits this one. You can read more about inheritance strategies here.

Now lets define our User class:

package com.yourcorp.here;

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

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

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

    @Persistent
    private String email;
    @Persistent
    private String name;
    @Persistent
    private String password;

    private static final long serialVersionUID = 3039288063578312662L;

    // getters & setters go here
}

When you persist an instance of this User class in the big table it will have id, customerId, email, name and password properties in the single user “table”.

One-to-many relationships in Google App Engine JDO

For this example lets define a customer class that has a list on phone and address objects:

package com.yourcorp.here;

import java.util.ArrayList;
import java.util.List;

import javax.jdo.annotations.IdentityType;
import javax.jdo.annotations.PersistenceCapable;
import javax.jdo.annotations.Persistent;
import javax.jdo.annotations.Element;

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

    @Persistent
    private String name;
    @Persistent
    private String contactName;
    @Persistent
    private String comments;

    @Persistent(mappedBy = "customer")
    @Element(dependent = "true")
    private List<Address> adresses = new ArrayList<Address>();

    @Persistent(mappedBy = "customer")
    @Element(dependent = "true")
    private List phones = new ArrayList();

    private static final long serialVersionUID = 3039288063578312662L;

    // getters &amp; setters go here
}

As you can tell we have defined two lists and annotated them to be persistent. (mappedBy = “customer”) defines this relationship as “owned” – meaning the customer property of the Address and Phone object will hold the reference tho this customer object.
And here is an example of the address object:

package com.yourcorp.here;

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

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

    @PrimaryKey
    @Persistent(valueStrategy = IdGeneratorStrategy.IDENTITY)
    private Key id;
    @Persistent
    private String type;
    @Persistent
    private String name;
    @Persistent
    private String line1;
    @Persistent
    private String line2;
    @Persistent
    private String city;
    @Persistent
    private String state;
    @Persistent
    private String zip;
    @Persistent
    private Customer customer;

    private static final long serialVersionUID = 3039288063578312662L;

    // getters & setters go here
}

You may also notice @Element(dependent = “true”) which means that when the customer object is deleted JDO will delete these child objects for you automatically.

Conclusion

JDO simplifies your life when you need to store and retrieve data if you know how to define all these relationships correctly. Compare the effort required to store and retrieve the same object from your favorite relational database, without using the monster called hibernate……

Google App Engine + JAVA + JDO + Inheritance + One-To-Many Relationships is a post from: Wet Feet - Online Marketing and Technology Blog

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

After reading this post you will be able to implement robust user authentication and authorization scheme without replicating code to check if user is logged in and if the are authorized to perform a certain action.

The Problem Domain

You, like me, face the same problem with each web application – user authentication and authorization. Who is logged in? Can they delete this entity? Can they see this report? How to solve this problem without copy pasting same piece of code to every servlet/action/controller/whatever? If you are using spring MVC there is a very elegant and powerful solution – Interceptors.

You can have as many interceptors as you like, I usually have one for security and maybe one more for some other task. Interceptor fires before your controller/action gets invoked. If it returns true the flow can continue, if it returns false the execution stops right there – request has been handled by the interceptor.

Step One – Adding an interceptor to our application form part 1

First lets code our interceptor. I named it SessionInerceptor.

package com.lureto.rjf;

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

import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

public class SessionInterceptor extends HandlerInterceptorAdapter {

    public boolean preHandle( HttpServletRequest request, HttpServletResponse response, Object handler) 
                                     throws Exception {
        User user = (User)request.getSession().getAttribute( Constants.SESSION_USER );
        String uri = request.getRequestURI();
        String base = request.getContextPath();
        uri = uri.substring( base.length() );
        if( user == null && !uri.startsWith("/api/login") ) {
                request.getSession().invalidate();
                response.setContentType("application/json");
            response.getWriter().write("{\"error\":\"SESSION-EXPIRED\"}");
            return false;
        }
        return true;
    }
        
}

As you see we are extending HandlerInterceptorAdapter class by implementing preHandle() method. If you need you can use postHandle() to perfor some action after the main handler has finished work. My implementation for this example is pretty simple – check only if the user is present in the session. If no user is present and user is not trying to log in, send back an error. In pure web application you probably would want to send a redirect to the login page.

Now lets add this interceptor to the Spring MVC stack by adding these 5 lines to our rest-json-flex-servlet.xml file.

<bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping">
        <property name="interceptors">
                <bean class="com.lureto.rjf.SessionInterceptor"/>
        </property>
</bean>

One more thing – we need to enable session in google app engine. Add this line to your appengine-web.xml

<sessions-enabled>true</sessions-enabled>

Step 2 – Implement Login Controller

Now we have our SessionInterceptor stopping us from accessing the services, we need to ad the way to log in. My inplementation of LoginController:

package com.lureto.rjf;

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

import javax.jdo.PersistenceManager;
import javax.jdo.Query;
import javax.servlet.http.HttpServletRequest;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
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("/login")
public class LoginController {

        private static Logger logger = Logger.getLogger( LoginController.class );
        
        @Autowired
        private PMF pmf;
        
        @SuppressWarnings("unchecked")
        @ModelAttribute("user")
        @RequestMapping(value = "/", method = RequestMethod.POST)
        public User login( @RequestBody User user, HttpServletRequest request ) throws IOException {
                logger.debug(user);
                
                // Hardcoded for demo website
                if( user.getName().equalsIgnoreCase("user1") && user.getPassword().equals("password1") ) {
                        user.setId(1001);
                        user.setEmail("fake@email.com");
                        request.getSession(true).setAttribute( Constants.SESSION_USER , user);
                        return user;
                }
                
        PersistenceManager pm = pmf.getManager();

                Query query = pm.newQuery("select from com.lureto.rjf.User " +
                                "where password == passwordParam && name == nameParam " +
                                "parameters String passwordParam, String nameParam");
                
                List<User> users;
                try {
                        users = (List<User>) query.execute( user.getPassword(), user.getName() );
                        if( users.size() > 0 ) {
                                User luser = users.get(0);
                                request.getSession(true).setAttribute( Constants.SESSION_USER , luser);
                                return luser;
                        }
                } finally {
                        query.closeAll();
                }

        return null;
        }
        
        public PMF getPmf() {
                return pmf;
        }

        public void setPmf(PMF pmf) {
                this.pmf = pmf;
        }
        
}

What happens here is very strait forward: we construct a query to the big table to find a user matching supplied name and password. If we find one, we create a session and put our user object there. Our SessionInterceptor expects to find this user there once we try access /api/user/ endpoints.
Since Spring is scanning this package and we are using annotation, we do not need to add this controller to the xml file.

Step 4 – Enhance existing User bean to support permissions

Here is my User.java

@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;
    @Persistent
    private String password;
    @Persistent
    private List<String> permissions;
        
    public User() {
        permissions = new ArrayList<String>();
    }
    
    // getters and setters here
}

Step 5 – Add Login Screen to Flex application

This is how the finished screen looks like, once you log in, you end up in this screen.

Full source code for JsonRestClient.mxml.

Step 6 – User Authorization Implementation

As you see from all the work we have done to this point we are not checking for user permissions. I intentional left it out. The best solution will depend on your particular application. In this case, we need to come up with the permission convention first. I would probably use “action-uri” convention. So to be able to get the user list you need to have “GET-user” permission, to update it would be “POST-user”, etc. You may come up with something better for your situation.

Conclusion

Interceptors in Spring is the perfect way of moving user authentication and authorization code form controllers into centralized place. This makes your controllers cleaner. You already know that the right user with right permissions is performing this action.

Source Code for Java part can be found Here.

Demo application can be found here. (check the LoginController in Step 2 to figure out the user + password to log in )

Leave me a comment what permission checking convention you would use.

Best of Luck!
Tomas

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