Skip to main content

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.

Comments

Popular posts from this blog

My HSQLDB schema inspection story

This is a simple story of my need to inspect the schema of an HSQLDB database for a participar FOREIGN KEY, and the interesting things I had to do to actually inspect it. I am using an HSQLDB 1.8 database in one of my web applications. The application has been developed using the Play framework , which by default uses JPA and Hibernate . A few days back, I wanted to inspect the schema which Hibernate had created for one of my model objects. I started the HSQLDB database on my local machine, and then started the database manager with the following command java -cp ./hsqldb-1.8.0.7.jar org.hsqldb.util.DatabaseManagerSwing When I tried the view the schema of my table, it showed me the columns and column types on that table, but it did not show me columns were FOREIGN KEYs. Image 1: Table schema as shown by HSQLDB's database manager I decided to search on StackOverflow and find out how I could view the full schema of the table in question. I got a few hints, and they all pointed to

Fuctional Programming Principles in Scala - Getting Started

Sometime back I registered for the Functional Programming Principles in Scala , on Coursera. I have been meaning to learn Scala from a while, but have been putting it on the back burner because of other commitments. But  when I saw this course being offered by Martin Odersky, on Coursera , I just had to enroll in it. This course is a 7 week course. I will blog my learning experience and notes here for the next seven weeks (well actually six, since the course started on Sept 18th). The first step was to install the required tools: JDK - Since this is my work machine, I already have a couple of JDK's installed SBT - SBT is the Scala Build Tool. Even though I have not looked into it in detail, it seems like a replacement for Maven. I am sure we will use it for several things, however upto now I only know about two uses for it - to submit assignments (which must be a feature added by the course team), and to start the Scala console. Installed sbt from here , and added the path

Five Reasons Why Your Product Needs an Awesome User Guide

Photo Credit: Peter Merholz ( Creative Commons 2.0 SA License ) A user guide is essentially a book-length document containing instructions for installing, using or troubleshooting a hardware or software product. A user guide can be very brief - for example, only 10 or 20 pages or it can be a full-length book of 200 pages or more. -- prismnet.com As engineers, we give a lot of importance to product design, architecture, code quality, and UX. However, when it comes to the user manual, we often only manage to pay lip service. This is not good. A usable manual is as important as usable software because it is the first line of help for the user and the first line of customer service for the organization. Any organization that prides itself on great customer service must have an awesome user manual for the product. In the spirit of listicles - here are at least five reasons why you should have an awesome user manual! Enhance User Satisfaction In my fourteen years as a