Question

We have an application with a plugin which contains a service:

public class TaskService {

    public void doSomething( Task task ) {
        // do something with task
        task.save();
    }
}

This works fine.

---

For our “special” customer with his special requirements we have a second application which contains the plugin from the first application and another plugin with a special service for this customer which extends the original service and overrides some methods:

public class SpecialTaskService extends TaskService{

    @Override
    public void doSomething( Task task ) {
        // do something special with task
        task.save();
    }
}

In every place in the second application where taskService is injected we want to have the SpecialTaskService now (also in the plugin from the first application). So we have added the special service to the resources.groovy under grails-app/conf/spring:

beans = {
        taskService( SpecialTaskService )
}

But now we get an HibernateException when we call “task.save()” in the special service:
org.hibernate.HibernateException: No Hibernate Session bound to thread, and configuration does not allow creation of non-transactional one here

We know that we could inject a SessionFactory into the SpecialService, but when we call sessionFactory.currentSession we get the same Exception.

The exception also occurs when we configure a service in resources.groovy which does not extend another one.

Is there a way to make the special service some kind of “hibernateSessionAware” so that we can call save() and merge() on domain objects?

Answer 1

The original service is transactional, so it keeps a Hibernate session open for the duration of the method call (unless one is already active and it has joined that). So you need to make yours transactional too since you’re just telling Spring to create a plain new instance with taskService(SpecialTaskService)

The simplest thing to do is annotate the class (or individual methods if you prefer):

import org.springframework.transaction.annotation.Transactional

@Transactional
class SpecialTaskService extends TaskService {

   @Override
   void doSomething(Task task) {
      // do something special with task
      task.save()
   }
}

but you can also wrap code blocks or entire methods in withTransaction blocks:

class SpecialTaskService extends TaskService {

   @Override
   void doSomething(Task task) {
      Task.withTransaction { status ->
         // do something special with task
         task.save()
      }
   }
}