class UrlMappings {
   static mappings = {
          // identifies a rest object like /rest/airport/1
	  "/rest/$domain/$id"{
		  controller = "rest"
		  action = [GET:"show", PUT:"create", POST:"update",DELETE:"delete"]
         }
   }
}

The action attribute may be a simple string, a hash map or a closure. Grails calls the following method evaluateNameForValue(Object value, GrailsWebRequest webRequest) to retrieve the value. The method is located within the org.codehaus.groovy.grails.web.mapping.DefaultUrlMappingInfo.

private String evaluateNameForValue(Object value, GrailsWebRequest webRequest) {
        if (value == null) {
            return null;
        }
        String name;
        if (value instanceof Closure) {
            Closure callable = (Closure) value;
            Object result = ((Closure) callable.clone()).call();
            name = result != null ? result.toString() : null;
        } else if (value instanceof Map) {
            Map httpMethods = (Map) value;
            name = (String) httpMethods.get(webRequest.getCurrentRequest().getMethod());
        } else {
            name = value.toString();
        }
        return name;
    }

Due to our knowledge of the action retrieval process, we are able to implement a “_method” emulation. This could look like:

 
class UrlMappings {
   static mappings = {
          // identifies a rest object like /rest/airport/1
	  "/rest/$domain/$id"{
		  controller = "rest"
		  // action = [GET:"show", PUT:"create", POST:"update",DELETE:"delete"]
 
	         action = {
		   // closure will not be invoked with request, log ... therefore we have to do this manually
		  GrailsWebRequest webRequest = (GrailsWebRequest) RequestContextHolder.getRequestAttributes();
		  String method = webRequest.getCurrentRequest().getMethod();
		  String methodParam = webRequest.getCurrentRequest().getParameter("_method");
 
		  // check if we can use _method
		  if (methodParam != null) {
		    methodParam = methodParam.toUpperCase()
 
		    switch (methodParam) {
			case "PUT" :
			case "DELETE" :
			case "POST" :
			case "GET" :
			  method = methodParam;
			break
		  }
		} 
 
		switch (method.toUpperCase()) {
		  case "PUT" : return "create"
			break
		  case "DELETE" : return "delete"
			break
		  case "POST" : return "update"
			break
		  case "GET" : return "show"
			break
		  default:  return "show"
		        break
		}
		return method;
		}
         }
   }
}

I hope that helps all Grails REST developers to enable their services for J2ME.

Right after installation I faced some issues:

Secure your Rest Services

This sounds quite easy due to a simple switch within the SecurityConfig.groovy. Just activate the BasicProcessingFilter. Now grails uses the Http Basic Authentification.

/** use basicProcessingFilter */
basicProcessingFilter = true

At the client side the code would like:

import sun.misc.BASE64Encoder
import groovy.util.XmlSlurper
 
def userid = "john.doe"
def password = "pass"
 
def url = "http://localhost:8080/CandyStreamServer/rest/gps/"
 
def conn = new URL(url).openConnection()
 
if (userid && password) {
	println "set authorization"
 
	// add HTTP authentication
       String encodedAuth = new BASE64Encoder().encode((userid + ":" + password).getBytes()) 
 
	conn.setRequestProperty("Authorization", "Basic " + encodedAuth)
}
 
def slurper = new XmlSlurper()
 
conn.requestMethod = "GET"
conn.doOutput = true
 
println "check connection"
def response
if (conn.responseCode == conn.HTTP_OK) {
	conn.inputStream.withStream {
		response = slurper.parse(it)
	}
} else {
	response = conn.responseCod
}
println response
conn.disconnect()

Retrieve the Current User

On the server side it may necessary to retrieve the current user. Spring Security offers a SecurityContextHolder. Unfortunately the securityContext.getAuthentication().getPrincipal(); does not return the Groovy user object. Instead the Spring Security Plugin uses its own user implementation that holds the Groovy user object. This is required due to Springs dependency on a specific interface.

The plugin provides a org.codehaus.groovy.grails.plugins.springsecurity.GrailsUser interface that extends the org.springframework.security.userdetails.UserDetails interface. To retrieve your Groovy user object just call getDomainClass()

SecurityContext securityContext = SecurityContextHolder.getContext();
def springUser = securityContext.getAuthentication().getPrincipal();
return springUser.getDomainClass()

Abstract:

Der Name der Programmiersprache ist Programm. Dass Groovy als noch junge Sprache viele neue und interessante Sprachkonzepte mitbringt, möchten wir im ersten Teil dieses Papers aufzeigen. Ein weiteres Highlight des ersten Kapitels ist vielleicht die Erkenntnis über die gelungene, nahtlos Integration mit der Java-Plattform. Im folgenden Hauptteil wird insbesondere die Möglichkeit der Meta-Programmierung mit Groovy beschrieben. Es wird auf die Umsetzung des Meta-Object-Protocols eingegangen und erläutert, wie die zugehörigen Konzepte mit Hilfe der Java Virtual Machine umgesetzt werden konnten. Im dritten und letzten Teil wird dem Leser eine implementierte Beispiel-Anwendung vorgestellt. Sie ist wie dieses Paper im Rahmen der Veranstaltung “Metaprogrammierung und Reflection” entstanden und demonstriert eindrucksvoll die Meta-Programmierung in Groovy.

Keywords:

Groovy, Metaprogramming

Groovy Meta Programming Paper

Groovy Meta Programming Slides

import java.util.Date;
 
public class Foo {
    public static void main(String[] args) {
        int start = 1;
        int summe = 0;
 
        for (int i = start; i <= 5; i++) {
            summe += i;
        }
 
        Date now = new Date();
        System.out.println(now.toString() + " Die Summe ist: " + summe);
    }
}

Groovy Iteration Example within Groovy Shell

 
        start = 1
        summe = 0
 
        for (i in start..5) {
            summe += i
        }
 
        now = new Date()
        println "$now Die Summe ist: $summe"

Groovy Map Handling with Closures

map = ["a":1, "b":2]
 
// inline closure
map.each { key, value ->
    map[key] = value*2
}
println map
 
// extern closure
doubler = { key, value ->
    map[key] = value*2
}
map.each(doubler)
println map

Groovy Beans

class Book {
    String title
 
    Book (String theTitle) {
        title = theTitle
    }
    Book plus(Book anotherBook) {
        return new Book(title + ", " + anotherBook.title)
    }
}
Book gina = new Book("Groovy in Action")
// getters are generated automatically 
println gina.getTitle()
 
println ((gina + new Book("Groovy for Experts")).title)

Groovy Duck Typing

 
class Dog {
    def speak() { println "wuff" }
}
class Cat {
    def speak() { println "miau" }
}
def saySomething(somewhat) {
    somewhat.speak()
}
 
saySomething(new Dog())
saySomething(new Cat())

Simple XML Example:

 
class XmlBuilder {
   def out
   XmlBuilder(out) { this.out = out }
   def invokeMethod(String name, args) {
       out << "<$name>"
       if(args[0] instanceof Closure) {
            args[0].delegate = this
            args[0].call()
       }
       else {
           out << args[0].toString()
       }
       out << "</$name>"
   }
}
 
def xml = new XmlBuilder(new StringBuffer())
xml.html {
    head {
        title "Hello World"
    }
    body {
        p "Welcome!"
    }
}
println xml.out

1. Create a new grails application: grails create-app openID

2. Change into directory: cd openID

3. Install Plugin: grails install-plugin openid

4. Create a new controller: grails create-controller User

5. Create logon.gsp at grails-app/views/user

6. Add the following lines of code

<openid:css />
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
<meta name="layout" content="main" />
<title>Login</title>
<openid:css />
</head>
<body>
<h1>Login</h1>
<openid:hasLoginError>
<div class="errors">
<ul>
<li><openid:renderLoginError /></li>
</ul>
</div>
</openid:hasLoginError>
<openid:form success="[action:'loggedin']">
<openid:input size="30" value="http://" /> (e.g. http://username.myopenid.com)
<br/>
<g:submitButton name="login" value="Login" />
</openid:form>
</body>
</html>

7. Edit UserController and add

class UserController {
def login = { }
def loggedin = { redirect(uri:'/') }
}

8. Call grails run-app

9. Open your web browser at http://localhost:8080/openID/User/login.gsp

10. Use your OpenID account to log on like Yahoo OpenID.

Check out http://docs.codehaus.org/display/GRAILS/OpenID+Plugin for further information about the Grails openID plugin

This demo illustrates how to read an XML file into Groovy objects. As the background I used the student lecture management. It stores students, assigned lectures with results and specific details about the lecture itself. The students are stored within a studenten node which itself contains a node for every student. A student may have a name, birthday and its assignments.

The second major node is the lehrveranstaltungen node that contains details about the lectures. The student assignments and the lectures are linked via identifier.

The following XML file is used as xml input:

<?xml version="1.0" encoding="UTF-8"?>
<studentenverwaltung
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="studentenverwaltung.xsd"
xmlns="http://www.hpi.uni-potsdam.de/studentenverwaltung">
<studenten>
<student geburtstag="19821221" matrikelnummer="123456">
<vorname>John</vorname>
<nachname>Doe</nachname>
<belegungen>
<belegung lehrveranstaltung="_12" note="1.0"/>
</belegungen>
</student>
<student geburtstag="19821221" matrikelnummer="654321">
<vorname>Alice</vorname>
<nachname>Doe</nachname>
<belegungen>
<belegung lehrveranstaltung="_12" note="1.0"/>
</belegungen>
</student>
</studenten>
<lehrveranstaltungen>
<lehrveranstaltung id="_12" belegungspunkte="6">
<titel>Datenorientiertes XML</titel>
<dozent>Martin von Löwis</dozent>
<beschreibung>
Das ist eine ganz nützliche Veranstaltung.
</beschreibung>
</lehrveranstaltung>
</lehrveranstaltungen>
</studentenverwaltung>


This whole document with two students will be read into 3 classes:

• Student,
• Belegung and
• Lehrveranstaltung

These classes are quite small compared to Java classes:

class Student{
      String geburtstag
      String matrikelnummer
      String vorname
      String nachname
      def belegungen = []
 
      String toString() {
          "Student: $vorname $nachname nMartrikelnummer: $matrikelnummer) nBelegungen: $belegungen"
      }
}
 
class Belegung {
	  Lehrveranstaltung lehrveranstaltung
	  String note
 
	  String toString(){
		  "nLehrveranstaltung: $lehrveranstaltung  Note: $note"
 
	  }
}
 
class Lehrveranstaltung {
      String  id
      int     belegungspunkte
      String  titel
      String  dozent
      String  beschreibung
 
      String toString(){
    	  "$titel ($dozent)"
      }
}

Now the XML processing starts. At first we have to initialize the Namespace and load the XML file into a variable.

// create namespace
def ns = new groovy.xml.Namespace("http://www.hpi.uni-potsdam.de/studentenverwaltung", 'ns')
def root = new XmlParser().parse(new File('studies.xml'))

After parsing the xml document it’s easy to iterate over the nodes with Groovy. A syntax like

root[ns.studenten][ns.student].each { xmlstudent ->
...
}

reads all Stutent nodes within the Studenten node. The called each method iterates over the result list and provide the xmlstudent variable to access the current student within the following code block. With the help of this code block it is easy to read the student vales into a new object.

// read core data
	student = new Student(
		vorname:             xmlstudent[ns.vorname].text(),
		nachname:           xmlstudent[ns.nachname].text(),
		matrikelnummer:  xmlstudent.'@matrikelnummer',
		geburtstag:          xmlstudent.'@geburtstag'
	)

The constructor behavior is special compared to Java. Groovy allows to initialize class members via the constructor. Additionally the instruction xmlstudent.’@matrikelnummer’ reads the xml attribute matrikelnummer from the xml student node.

The second task is to read in all lecture assignments for the student. This task is more complex because the lectures are stored within it’s own node. For that reason we have to iterate over all assignments stored within the belegung nodes and use the assigned lecture link to find the right lecture.

// read belegungen
xmlstudent[ns.belegungen][ns.belegung].each { belegung ->
...
}

To include the content of the lecture node we have to search for this lecture node now. The required lecture link is taken from the lehrveranstaltung attribute of the current assignment. This lecture lookup is written like:

// read lecture
xmlLehr = root[ns.lehrveranstaltungen][ns.lehrveranstaltung].find{
	it.'@id' == belegung.'@lehrveranstaltung'
}

With this lecture node it is possible to fill the student class with the student’s assignments.

// read assignment
student.belegungen += new Belegung(
	note : belegung.'@note',
	lehrveranstaltung : new Lehrveranstaltung(
		id					:xmlLehr.'@id',
		belegungspunkte		:xmlLehr.'@belegungspunkte',
		titel				:xmlLehr[ns.titel].text(),
		dozent				:xmlLehr[ns.dozent].text(),
		beschreibung		:xmlLehr[ns.beschreibung].text()
	)
)

These few lines of code are enough to read a namespace xml into Groovy. The iteration over all nodes and the simple attributes access is useful to keep the amount of code low. If you are interested to try out the whole example you are welcome to download the attached zip file that contains the Eclipse project with all required files.

Download:


Code Sample

Besides all marketing I used Groovy for quite some time and I think it’s a great scripting language for Java. If you are new to Groovy you should read the book: “Dierk Koenig: Groovy in Action”. After 2 days of working with Groovy you will become a real Groovy developer. And the best about Groovy is that your old Java code can be reused.

Get the stuff workig

Although Groovy is available as a separate package here, I would recommend to use Groovy in combination with Eclipse. This works easily on Mac and Windows and fits to Java programmers most due to the familiar Eclipse environment. Compared to Eclipse the Groovy scripting console shipped with the Groovy libraries called “Groovy Console” is only useful to write simple Code snippets. If your project becomes bigger the Eclipse environment is more powerful.

After a properly set up of Eclipse, open it and go to Help -> Software Updates -> Find and Install -> Search For New Features. Now add a New Remote Site… and insert “Grovvy Plugin” and “http://dist.codehaus.org/groovy/distributions/update/” as URL. Confirm the data with OK. Now check the newly added Site and press Finish.

The following screen will ask you to Select the Features to Install. Just select the Groovy check box and press Next. Finally accept the license agreement and press Next. Confirm the default location with Finish. Now the plugin download starts.

After the Groovy plugin installation, it’s easy to start with Groovy. At first you create a new Java project and add a new Groovy class. Afterwards Eclipse asks you to add the Groovy runtime to the Java project and confirm this question with Yes. Within this project you can use Java and Groovy classes interchangeable. This is the best thing about Groovy runtime because it is a simple Java jar file.

class HelloWorld {
   static void main(args) {
 
   }
}

Add println “Hello World” and open the Run Dialog. Currently the dialog does not find Groovy main classes. Therefore you have to add it manually. After a click on Run the Console outputs: Hello World

To sum up: it’s so simple to run Groovy code.