JT’s Blog

Gotchas with Groovy Exceptions

I ran into a little gotcha with Groovy exceptions today. I seemed like my catch block was not catching the exception type I was throwing in my code.

Lets say I’ve defined my own exception as

class NotFoundException extends Exception {
}

And I have a method call as:

    def getApplication(def params)  {
        def application = Application.get(params?.id)
 
        if (!application) {
            throw new NotFoundException()
        }
        application
    }

In my case this the above is a method in a service which is injected into a Grails controller. In my controller, I want to handle any exceptions that pop, rather than going boom to the web tier. My controller code looks something like this:

    def approve = {
 
        def returnMap = [:]
 
        returnMap.success = true
 
        try {
            def application = applicationService.approve(params)
 
            returnMap.message = "Application for ${application.firstName} ${application.lastName} has been approved."
 
        } catch (NotFoundException e) {
            returnMap.success = false
            returnMap.message = 'Application not found.'
 
            log.error("Failed to find application")
            log.error(params.dump())
 
        } catch (e) {
            returnMap.success = false
            returnMap.message = 'Error updating application. See logs for details'
 
            log.error("Failed to find application")
            log.error(e)
            log.error(e.cause)
 
            e.stackTrace.each {
                log.error(it)
            }
        }
 
        render returnMap as JSON
    }

I want the above code catch the error and provide sometime of informational message to the client by setting the returnMap.message property.

The problem I encountered in my catch block was that it was always falling through to the final catch block. The catch block for the NotFoundExcpetion was getting skipped.

Turns out, the exception was getting thrown as a “UndeclaredThrowableException” and not a NotFoundException. Since the types did not match, my catch block was getting skipped.

The solution to this is to declare the exception on your method. Then the exception will propagate properly. I guess its the price you have to pay for the Groovyness of Groovy.

The corrected code (note the throws declaration) :

    def getApplication(def params) throws NotFoundException {
        def application = Application.get(params?.id)
 
        if (!application) {
            throw new NotFoundException()
        }
        application
    }

This entry was posted on Tuesday, March 8th, 2011 at 2:06 pm and is filed under Uncategorized. The entry is tagged under You can follow any responses to this entry through the RSS 2.0 feed. You can leave a response, or trackback from your own site.