How to catch exceptions in grails REST controllers

Question

If you use a controller to implement rest APIs, you want to deal with any exception thrown and return a generic or specific well formed REST response.

We can't use global error URL mapping method, as the application has a number of APIs and interfaces with different response requirements, and we also don't know which type of Grails' HTTP error codes will be thrown (e.g don't know if it will be a 400, 422, 500 etc). Also, if we used the error page mappings, we won't be able to put relevant data into the JSON response.

E.g. this will generate a GrailsRuntimeException:

class SomeController {
    def payload = request.JSON
    def someMethod() {
        BigDecimal x = new BigDecimal(payload.notExists)
    }

The problem is, it seems impossible to catch any error thrown.

E.g. neither this approach:

def handleRuntimeException(RuntimeException e) {
      render("some JSON error message")
}

Nor this approach:

try {
    :
}
catch (GrailsRuntimeException e) {
        render("some JSON error message")
}

Works - it never catches the error.

Tried GroovyRuntimeException, Exception, MissingMethodException, Throwable etc.

The only solution we can think of is to not do any work in the controller, do everything in a service, where apparently we can catch errors.

This approach:

static mappings = {
    "500"(controller: "error")
}

Is not want we need for several reasons:

1. We have several different APIs in different controllers which would require different response formats.
2. we also have UI controllers, which would want the default error system which shows the stack trace etc.
3. We want to handle the error in the controller where the exception happened, so we can clean up, or at least can log or return the stat which only the controller knows.

Have decided the only way is to move all code into services, and do nothing in the controller except pass the request, and render the resultant string. i.e. all parameter handling, especially number conversion, is done in the service.

Answer 1

It's ironic that the solution that you see as suboptimal that you're settling for is exactly what you should always do. This isn't PHP - don't put logic in Controllers (or GSPs).

Services are by default transactional, so they're a great place to put code that writes to the database since that should always happen in a transaction. They're also excellent for business logic whether it's transactional or not, and you can either annotate individual methods with @Transactional to partition the methods into ones that run in a transaction and ones that don't, or split the services into some that are fully transactional and some that aren't.

If you keep all of the HTTP-related code in the controllers, doing the data binding from params, and calling helper classes (services, domain classes, taglibs, etc.) you get a good separation of concerns, and if the service layer doesn't know anything about params, HttpServletRequest, HTTP sessions, etc. then it's easily reusable in other Grails apps and even in non-Grails apps. They'll also be easier to test, since there isn't so much inter-related code that needs to be mocked and otherwise made test-friendly.

Using this approach, the controllers basically become dumb routers, accepting requests, calling helpers to do the real work, and delegating page rendering or response writing, or redirecting or forwarding.

Answer 2

I am very late to answer this, but I think it might help people stumbling and searching for solution.

Here is one of my blogs explaining Custom exception handling in grails and error responses for RESTfull services

Hope this might help someone

Answer 3

I am using grails 3.2.4 and there is no issue as you have explained here. I have moved all business logics inside the service class and catching exceptions by parent controller trait. Here I am handling this exception in another ParentExceptionController trait which is implemented by classes where such exception is occurring from service class. Example:

UserService {
 boolean create(Map params) {
     throw new InvalidParameterException('some message')
  }

UserController implements ParentExceptionController {
 UserService userService
    userService.create(params.userDetails)
  }

trait ParentExceptionController {
 Object handleInvalidParameterException(InvalidParameterExceoption exception) {
  log.error 'log message'
  respond([message: exception.message])
 }

first and second both are working in my case.