Can I force a grails dev server to reload when any code recompiles?

compilation, grails, groovy, tomcat

Solution

CRITICAL UPDATE

I was able to get what you were looking for. Laying it down step wise:

REQUIREMENT - When `Helper` class is modified, `service` class should be refreshed to refer to the modified helper class.

SETUP

//src/groovy
class SampleHelper {
    String name = 'Heisenberg'

    def sayMyName(){
        "$name"
    }
}

//grails-app/service
import javax.annotation.PostConstruct
class SampleService {
    String cachedName

    @PostConstruct
    def initIt(){
        cachedName = new SampleHelper().sayMyName()
    }

    def serviceMethod() {
        cachedName
    }
}

//controller
class SampleController {
    def sampleService

    def index() {
        render sampleService.serviceMethod()
    }
}

PROBLEM STATEMENT When `name` in helper class is updated to `Gus`, the class refreshes but the service class is still referencing to the old instance of `SampleHelper`. Result, name still shows `Heisenberg`.

SOLUTION

- Watch the helper class.

- Refresh the service class `onChange` of helper class.

This can be achieved by using the Pluginator plugin in the application which gives the flexibility to watch a file and do something `onChange` event.

- Install the plugin.

- Add the below `ApplicationPlugin.groovy` under `grails-app/conf`.

as

class ApplicationPlugin {
    //Watch the helper class
    def watchedResources = "file:./src/groovy/**/*.groovy"

    //Re-Register the bean (service class) onChange of Helper Class
    //This can be generalized more.
    def onChange = { event ->
        if (event.source) {
            def beans = beans {
                sampleService(SampleService) { bean ->
                    bean.autowire =  true
                }
            }
            if (event.ctx) {
                event.ctx.registerBeanDefinition(
                        "sampleService",
                        beans.getBeanDefinition("sampleService"))
            }
        }
    }
}

- PROBLEM STATEMENT should be fixed after the above steps followed.

NOTE

- This process might be resource intensive if followed for all classes and artefacts.

OLD & Valid Answer

I am unable to recreate your problem in Grails 2.2.0. Below is the setup I have (correct me if I am wrong anywhere):

//src/groovy
class MyHelper{
    def sayMyName(){
        "Heisenberg"
    }
}

//service
import javax.annotation.PostConstruct
class MyService {
    def myHelper

    @PostConstruct
    def initIt(){
        myHelper = new MyHelper()
    }

    def serviceMethod() {
        myHelper.sayMyName()
    }
}

//controller (to test)
class MyController {
    def myService

    def index() {
        render myService.serviceMethod()
    }
}

Steps:

- Run the initial setup. (`run-app`)

- Hit the controller to see "Heisenberg"

- Modify `MyHelper.sayMyName()` to return "Walter White" instead of "Heisenberg"

- Hit the controller again and see "Walter White"

Observation:

- I would rather make `MyHelper` a bean and use (inject) it in the service class for use.

Entry to `resources.groovy` as follows:

beans = {
    myHelper(com.example.MyHelper)
}

Service class becomes:

class MyService {
    def myHelper

    def serviceMethod() {
        myHelper.sayMyName()
    }
}

- Now, referring to field in `MyHelper` in the service class will give an issue because the bean has been instantiated already in the container

Regarding Bonus Question:

I am unable to recreate the problem either in Grails 2.2.0

//domain
class MyDomain {
    String name
}

//controller action
def add(){
    def myDomain = new MyDomain(name: 'Testing').save(flush: true)
    render myDomain.properties
}

- Change the domain, add `String email`

- Save Domain class.

- Modify action to add `email` in `MyDomain` (obviously a new row will be created).

- Save Controller.

- Hit the action again.

- See the result.

Problem

Original source