How to access Grails configuration in Grails 2.0?

grails groovy grails-2.0

52,399

Solution 1

If you need it in an artifact that supports dependency injection, simply inject grailsApplication

class MyController {
    def grailsApplication

    def myAction = {
        def bar = grailsApplication.config.my.property
    }
}

If you need it in a bean in, say, src/groovy or src/java, wire it up using conf/spring/resources.groovy

// src/groovy/com/example/MyBean.groovy
class MyBean {
    def grailsApplication

    def foo() {
        def bar = grailsApplication.config.my.property
    }
}

// resources.groovy
beans = {
    myBean(com.example.MyBean) {
        grailsApplication = ref('grailsApplication')
        // or use 'autowire'
    }
}

Anywhere else, it's probably easiest to either pass the configuration object to the class that needs it, or pass the specific properties that are needed.

// src/groovy/com/example/NotABean.groovy
class NotABean {
    def foo(def bar) {
       ...
    }
}

// called from a DI-supporting artifact
class MyController {
    def grailsApplication
    def myAction = {
        def f = new NotABean()
        f.foo(grailsApplication.config.my.property)
    }
}

Update:

Burt Beckwith recently wrote a couple of blog posts on this. One discusses using getDomainClass() from within domain classes, while the other offers the option of creating your own holder class (if none of the solutions above are appropriate).

Solution 2

An alternative to grailsApplication is the Holders class,

import grails.util.Holders

def config = Holders.config

You get config directly off of Holders, no injection needed, which is nice for utility classes, etc.

Solution 3

you can inject "grailsApplication" into your source file. here is a sample conf/Bootstrap.groovy

class BootStrap {

    def grailsApplication

    def init = { servletContext ->
        println grailsApplication.config
    }

    def destroy = {
    }
}

Solution 4

Another non-deprecated way to get the config is:

    ApplicationContext context = ServletContextHolder.servletContext.
        getAttribute(GrailsApplicationAttributes.APPLICATION_CONTEXT) 
        as ApplicationContext
    ConfigObject config = context.getBean(GrailsApplication).config

This works in situations where there is no injected parent available, such as servlet classes or static methods.

Solution 5

You can access grails configuration

In Controller

class DemoController {
    def grailsApplication

    def demoAction = {
        def obj = grailsApplication.config.propertyInConfig
    }
}

In services :

class DemoService {
    def grailsApplication

    def demoMethod = {
        def obj = grailsApplication.config.propertyInConfig
    }
}

In taglib :

class DemoTaglib {
    def grailsApplication

    static namespace = "cd"

    def demoMethod = {

        def obj = grailsApplication.config.propertyInConfig

        out << obj    
    }
}

You can call this method of taglib in view as <cd:demoMethod/>

In view :

 <html>
     <head><title>Demo</title></head>
 <body>
     ${grailsApplication.config.propertyInConfig}
 </body>

 </html>

View more solutions

52,399

Author by

Polaris878

Updated on August 25, 2020

Comments

Polaris878 over 3 years
I have obtained the latest Grails 2.0 milestone, and I am seeing a deprecation warning for the ConfigurationHolder class:
```
org.codehaus.groovy.grails.commons.ConfigurationHolder
```
The deprecation message simply says "Use dependency injection instead" which is not very helpful to me. I understand dependency injection, but how can I wire up a bean with the proper Grails configuration so I can access it at runtime? I need to access the configuration from places other than my Controllers and Tags (such as BootStrap).
Polaris878 over 12 years

Rob, very helpful answer. Thanks.
Andrew almost 11 years

This is probably the most straightforward way, since there's a direct 1:1 mapping to the deprecated class.
Alexander Suraphel over 9 years

When is grails.util.Holders preferable to injecting grailsApplication?
James McMahon over 9 years

@AlexanderSuraphel when you don't want to have Spring control the lifecycle of your bean. For instance, a utility class with public static methods.
Bilal Ahmed Yaseen over 8 years

how can we use it in external javascript file?