{"id":29308,"date":"2015-10-30T18:28:15","date_gmt":"2015-10-30T12:58:15","guid":{"rendered":"http:\/\/www.tothenew.com\/blog\/?p=29308"},"modified":"2022-01-11T11:23:18","modified_gmt":"2022-01-11T05:53:18","slug":"intercept-grails-service-class-method-calls","status":"publish","type":"post","link":"https:\/\/www.tothenew.com\/blog\/intercept-grails-service-class-method-calls\/","title":{"rendered":"Intercept Grails Service class method calls"},"content":{"rendered":"

I was trying to intercept method calls of a Grails Service class for a little while. Adding interceptors to Controllers is really easy and I wanted to intercept calls to one of the methods in a Service class in a similar fashion. But adding interceptors to Grails Service Classes is not as straightforward as for Controllers. After doing some research I came up with two solutions.<\/p>\n

Problem statement<\/strong>: Default flush mode in Grails 2.3 is AUTO, but for some Service Classes we needed the default flush mode as COMMIT. We can change default flush mode for whole application by specifying it in grails-app\/conf\/DataSource.groovy<\/code>. Rather than changing it for whole application we wanted to change it for some selected Service classes only.<\/p>\n

How to do it?<\/strong>
\nBefore going for solution, lets see our sample domain model and demo service class for our example.<\/p>\n

Domain Class:<\/p>\n

[code lang=”groovy”]
\npackage com.ttnd.demo<\/p>\n

class Group {<\/p>\n

String name
\n String assignedRepId
\n Date activationDate
\n Date deactivationDate<\/p>\n

static mapping = {
\n table(name: "_group")
\n }<\/p>\n

static constraints = {
\n deactivationDate nullable: true
\n }<\/p>\n

@Override
\n public String toString() {
\n return "Group{ $name(id: $id) }"
\n }
\n}
\n[\/code]<\/p>\n

Service Class:<\/p>\n

[code lang=”groovy”]
\npackage com.ttnd.demo<\/p>\n

import grails.transaction.Transactional
\nimport groovy.util.logging.Log4j
\nimport org.hibernate.FlushMode<\/p>\n

@Log4j
\n@Transactional
\nclass GroupService {<\/p>\n

def grailsApplication<\/p>\n

public Group persistGroup(Group group) {<\/p>\n

FlushMode flushMode = grailsApplication.mainContext.sessionFactory.currentSession.flushMode
\n log.debug("Flush mode for current Session: ${flushMode}")<\/p>\n

if (group.validate()) {
\n group.save(failOnError: true)
\n } else {
\n log.error("Error while saving Group Object $group")
\n }<\/p>\n

return group
\n }
\n}
\n[\/code]<\/p>\n

Bootstrap some data:<\/p>\n

[code lang=”groovy”]
\nimport com.ttnd.demo.Group
\nimport com.ttnd.demo.GroupService<\/p>\n

class BootStrap {<\/p>\n

GroupService groupService<\/p>\n

def init = { servletContext ->
\n Group group = new Group(name: "Admin", assignedRepId: "USR-00-12", activationDate: new Date())
\n groupService.persistGroup(group)
\n }<\/p>\n

def destroy = {
\n }
\n}
\n[\/code]<\/p>\n

1. First Solution – Using MetaInjection<\/strong>
\nWith this approach, we have to look up the Grails services<\/a> and override the invokeMethod() for the Service classes. Here before invoking the original method, we will modify the default flush mode for the\u00a0current session. We will also add logging code so we can log when we enter and exit the method.<\/p>\n

We will put our code in grails-app\/conf\/BootStrap.groovy<\/code> of our Grails application. After the above mentioned changes, here it is how the Bootstrap.groovy code will look like –<\/p>\n

[code lang=”groovy”]
\nimport com.ttnd.demo.Group
\nimport com.ttnd.demo.GroupService
\nimport org.hibernate.FlushMode<\/p>\n

class BootStrap {<\/p>\n

def grailsApplication
\n GroupService groupService<\/p>\n

def init = { servletContext ->
\n setupServiceInterceptor()<\/p>\n

Group group = new Group(name: "Admin", assignedRepId: "USR-00-12", activationDate: new Date())
\n groupService.persistGroup(group)
\n }<\/p>\n

def destroy = {
\n }<\/p>\n

private void setupServiceInterceptor() {
\n grailsApplication.serviceClasses.each { serviceClass ->
\n serviceClass.metaClass.invokeMethod = { name, args ->
\n delegate.log.info "Invoking $name in ${delegate.class.name}"
\n def metaMethod = delegate.metaClass.getMetaMethod(name, args)
\n try {
\n FlushMode flushMode = grailsApplication.mainContext.sessionFactory.currentSession.flushMode
\n delegate.log.debug("Inside setupServiceInterceptor: Flush mode for current Session: ${flushMode}")
\n grailsApplication.mainContext.sessionFactory.currentSession.setFlushMode(FlushMode.COMMIT)<\/p>\n

def result = metaMethod.invoke(delegate, args)
\n delegate.log.info "Execution completed for method $name with result [$result]"
\n return result
\n } catch (Exception ex) {
\n delegate.log.error "Exception occurred during execution of $name: ${ex.message}"
\n throw ex
\n }
\n }
\n }
\n }
\n}
\n[\/code]<\/p>\n

When we run the application, it will print the following logs:<\/p>\n

[code lang=”groovy”]
\n2015-10-30 17:39:14,482 [localhost-startStop-1] INFO demo.GroupService – Invoking persistGroup in com.ttnd.demo.GroupService$$EnhancerBySpringCGLIB$$d26dc9bf
\n2015-10-30 17:39:14,511 [localhost-startStop-1] DEBUG demo.GroupService – Inside setupServiceInterceptor: Flush mode for current Session: AUTO
\n2015-10-30 17:39:14,593 [localhost-startStop-1] DEBUG demo.GroupService – Inside GroupService.persistGroup(): Flush mode for current Session: COMMIT
\n2015-10-30 17:39:14,714 [localhost-startStop-1] INFO demo.GroupService – Execution completed for method persistGroup with result [Group{ Admin(id: 1) }]
\n[\/code]<\/p>\n

2. Second Solution – Using Spring AOP<\/strong>
\nInstead of using MetaInjection we can use Spring AOP Interceptors. Don’t worry if you are not familiar with Spring AOP. For this basic example, you are not required to have an expertise in Spring AOP.<\/p>\n

Key definitions of some AOP concepts that we are going to use here:<\/p>\n