Simple CRUD with Gaelyk

October 21, 2010 at 7:26 pm | Posted in GAE, Groovy, Search | 5 Comments
Tags: , , , , , , ,

After having written a Grails application for Google App Engine I know exactly what the pain points are in production: Cold startup times make using the application an unenjoyable experience. App Engine calls for a lightweight application with far less JAR baggage and fast startup times. Yesterday I attended Guillaume LaForge’s session “Gaelyk, a lightweight Groovy toolkit for Google App Engine” at SpringOne2GX presenting the nuts and bolts of Gaelyk. The session was reason enough to think about rewriting my application to Gaelyk. To get started I whipped up a simple CRUD example in Gaelyk. All you need to do is to download the Gaelyk template application and you are ready to go. The test application will have four simple use cases: show all entities of a certain type (in my case a “Goal” entity), create new ones, update and delete them.

Gaelyk doesn’t support multiple closures in a controller class to automatically expose URLs by convention like Grails does. Instead you have to define your URL routing for each operation separately.


get  "/goals",                forward:  "/showGoals.groovy"
get  "/goals/add",            forward:  "/WEB-INF/pages/goal.gtpl"
post "/goals/insert",         forward:  "/insertGoal.groovy"
get  "/goals/delete/@id",     forward:  "/deleteGoal.groovy?id=@id"
get  "/goals/edit/@id",       forward:  "/editGoal.groovy?id=@id"
post "/goals/update",         forward:  "/updateGoal.groovy"

To show all Goals I defined a Groovlet named showGoals.groovy that uses the App Engine datastore low-level API to retrieve them and forward to the view goals.gtpl. In the view you can add a new goal or edit/delete existing goals.


import static* "Getting all goals"

def query = new Query("Goal")
PreparedQuery preparedQuery = datastore.prepare(query)
query.addSort("created", Query.SortDirection.DESCENDING)
def goals = preparedQuery.asList(withDefaults())

request.goals = goals

forward '/WEB-INF/pages/goals.gtpl'


<% include '/WEB-INF/includes/header.gtpl' %>


<a href="/goals/add">Add Goal</a>
<table border="1">
     <% request.goals.each { goal -> %>
           <td><a href="/goals/delete/${}">Delete</a> | <a href="/goals/edit/${}">Edit</a></td>
     <% } %>

<% include '/WEB-INF/includes/footer.gtpl' %>

The operations insert and edit share a common view named goal.gtpl. Based on whether the request contains the attribute goal the view will be in insert or edit mode. In case an existing Goal entity was provided the form gets populated with the entity data and is ready to be updated. The Goal to be edited will be retrieved by providing the entity’s ID in the editGoal.groovy Groovlet.


import "Editing goal"

def id = Long.parseLong(
Key key = KeyFactory.createKey("Goal", id)
def goal = datastore.get(key)

request.goal = goal
forward '/WEB-INF/pages/goal.gtpl'


<% include '/WEB-INF/includes/header.gtpl' %>

  def goal = request.getAttribute("goal")
  boolean existingKey = goal?.key
  String action = !existingKey ? 'Add' : 'Update'

<h2>${action} Goal</h2>

<form action="/goals/${!existingKey ? 'insert' : 'update'}" method="POST">
   <table border="0">
            <td><input type="text" name="name" value="${goal?.name ? : ''}"></td>
            <td><input type="text" name="description" value="${goal?.description ? goal.description : ''}"></td>
      <% if(existingKey) { %>
         <input type="hidden" name="id" value="${}">
      <% } %>
   <input type="submit" value="${action}">
   <input type="button" value="Cancel" onclick="javascript:document.location.href = '/goals';">

<% include '/WEB-INF/includes/footer.gtpl' %>

At last we need to implement the Groovlets for persisting the changes to your entity. All of them are quite straight forward to implement. Gaelyk’s abstractions for the datastore work quite nicely.


import "Inserting goal"

def goal = new Entity("Goal") =
goal.description = params.description
goal.created = new Date()

redirect '/goals'


import "Updating goal"

def id = Long.parseLong(
Key key = KeyFactory.createKey("Goal", id)
def goal = datastore.get(key) =
goal.description = params.description

redirect '/goals'


import "Deleting goal"

def id = Long.parseLong(
Key key = KeyFactory.createKey("Goal", id)

redirect '/goals'


RSS feed for comments on this post. TrackBack URI

  1. Good write up. You might even shame me into writing up my own experiences!

    One thing to note is that when you are taking param arguments and adding them to your entity with the same name you can use the following groovy sugar:

    goal << params.subMap(['name', 'description'])


  2. Nice write up!


  3. Great post – I found this really useful for my first gaelyk app.

  4. You can also use this sugar for your goals:

    params.with { = name
    goal.description = description


    goal.with {
    name =
    description = params.description

  5. Very helpful, thanks!

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s

Blog at
Entries and comments feeds.

%d bloggers like this: