Thursday, April 09, 2009

Closures in lieu of inner classes in Groovy

Groovy does not support inner classes, at least not in version 1.6 . Having done Java coding for many years, I have become accustomed to using inner classes to encapsulate small related functionality, especially when it is needed for callbacks or some sort of configuration.

Now that I am learning Groovy, and writing a Twitter client, I needed to use inner classes, only to find out that Groovy does not support them. However, we can use closures and maps to simulate inner classes in Groovy. Before I explain this technique, I must say that it is simply a workaround, and at least in my opinion a not-so-good solution.

For this example I will show how I implemented a Jetty Handler using closures instead of an anonymous inner class. Jetty is a Java web server which supports Servlets and JSP's. I often use Jetty in my unit tests, because it can be started in-memory from an API call. Jetty can be configured in code with handlers, so that it will use these handlers to service a web request.

In the code below, I have created a simple unit test which makes a GET request and tests that the response is "Hello World". Offcourse this is a very trivial test, and would not be useful in production.

Here is the setUp() method from the test case, HelloWorldTest.groovy . I have not showed the entire test case for the sake of brevity.


Server _server //Jetty Server

@Override

public void setUp() {
//configure Jetty Server

_server = new Server(8080)

_server.setHandler(JettyHandlerFactory.getHelloWorldHandler())
_server.start()
}



We set the handler to mock HttpRequests in the call _server.setHandler() . The code below shows how JettyHandlerFactory.groovy uses closures instead of inner classes to implement the handler.


import org.mortbay.jetty.handler.AbstractHandler;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;



public class JettyHandlerFactory{



public static AbstractHandler getHelloWorldHandler() {

//define the closure for a method of the inner class

def handle = { String target,

HttpServletRequest req,

HttpServletResponse res,

int dispatch ->

res.setContentType('text/html')

res.setStatus(HttpServletResponse.SC_OK)


def builder = new groovy.xml.MarkupBuilder(res.getWriter())

builder.html {

head {}

body('Hello World') {



}

}

req.setHandled(true)

}



//define a Map for the method name and closure

def handlerMethods = ['handle' : handle]

return handlerMethods as AbstractHandler

}


}




Because Groovy does not support anonymous inner classes, what we had to do was to create a closure called handle. This closure contains the that will be run when the handle method of the handler is invoked. The name of the closure does not necessarily have to be handle. It is names this just to increase readability.

Then we create a Map called handlerMethods to hold closures for all the methods we want to override in AbstractHandler. In this case we want to override just one method; handle. The keys in the Map must be strings which are named to the method names we want to override. The values must be the closures which implement the method. These closures must accept input parameters that the method accepts. The closure above accepts 4 input parameters.

Finally the class is created by converting the Map into a class using the
return handleMethods as AbstractHandler
invocation.

No comments: