groovy - ¿Cómo acceder a la configuración de Grails en Grails 2.0?




grails-2.0 (6)

Puede acceder a la configuración de grails

  1. En el controlador

    class DemoController {
        def grailsApplication
    
        def demoAction = {
            def obj = grailsApplication.config.propertyInConfig
        }
    }
    
  2. En servicios:

    class DemoService {
        def grailsApplication
    
        def demoMethod = {
            def obj = grailsApplication.config.propertyInConfig
        }
    }
    
  3. En taglib:

    class DemoTaglib {
        def grailsApplication
    
        static namespace = "cd"
    
        def demoMethod = {
    
            def obj = grailsApplication.config.propertyInConfig
    
            out << obj    
        }
    }
    

Puede llamar a este método de taglib como <cd:demoMethod/>

  1. En vista :

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

Obtuve el último hito de Grails 2.0 y veo una advertencia de desactivación para la clase ConfigurationHolder :

org.codehaus.groovy.grails.commons.ConfigurationHolder

El mensaje de desaprobación simplemente dice "Usar inyección de dependencia", lo cual no es muy útil para mí. Entiendo la inyección de dependencia, pero ¿cómo puedo conectar un bean con la configuración adecuada de Grails para poder acceder a él en tiempo de ejecución? Necesito acceder a la configuración desde otros lugares que no sean mis Controladores y Etiquetas (como BootStrap ).


Otra forma no obsoleta de obtener la configuración es:

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

Esto funciona en situaciones donde no hay un padre inyectado disponible, como clases de servlet o métodos estáticos.


Una alternativa a grailsApplication es la clase Holders ,

import grails.util.Holders

def config = Holders.config

Usted obtiene la configuración directamente de los titulares, no necesita inyección, lo cual es bueno para las clases de utilidad, etc.


  • Si lo necesita en un artefacto que admita la inyección de dependencia, simplemente inyecte la aplicación grailsApplication

    class MyController {
        def grailsApplication
    
        def myAction = {
            def bar = grailsApplication.config.my.property
        }
    }
    
  • Si lo necesita en un bean en, por ejemplo, src/groovy o src/java , conf/spring/resources.groovy usando 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'
        }
    }
    
  • En cualquier otro lugar, probablemente sea más fácil pasar el objeto de configuración a la clase que lo necesita o pasar las propiedades específicas que se necesitan.

    // 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)
        }
    }
    

Actualizar:

Burt Beckwith recientemente escribió un par de publicaciones en el blog sobre esto. Uno analiza el uso de getDomainClass() desde dentro de las clases de dominio, mientras que el otro ofrece la opción de crear su propia clase de titular (si ninguna de las soluciones anteriores es apropiada).


Para acceder desde la clase de dominio hazlo:

import grails.util.Holders

// more code

static void foo() {
  def configOption = Holders.config.myProperty
}

Agregando a @Patrick su respuesta, que me ayudó mucho, recientemente descubrí otro truco.

Si agrega muchos tarros al classpath todo en una línea, las cosas pueden volverse ilegibles. ¡Pero puedes hacer lo siguiente!

#!/bin/bash
//bin/true && OPTS="-cp blah.jar -Dmyopt=value"
//bin/true && OPTS="$OPTS -Dmoreopts=value2"
//usr/bin/env groovy $OPTS "$0" [email protected]; exit $?

println "inside my groovy script"

Deje volar su imaginación sobre la complejidad de una línea de comando que puede descomponer de esta manera en piezas manejables

Maarten