Jak korzystać z zewnętrznego pliku konfiguracyjnego w Grails .groovy 3

Question

sekcji 24.3 w Externalized Configuration wskazuje plik .properties lub .yml mogą być wykorzystywane do zewnętrznego config, ale chciałbym mój zewnętrzny config być plik .groovy podobnie jak mój plik application.groovy które już przeszły konwersję z .yml. Jak mogę to zrobić?

Grails wersja 3.2.0.M2

UPDATE:

udało mi się dostać tę pracę na podstawie odpowiedzi udzielonej przez @Michal_Szulc

Uwaga że ConfigSlurper potrzebne bieżące środowisko działać poprawnie. Należy również zauważyć, że zmiany te należy wprowadzić do pliku my_grails_app/grails-app/init/my_grails_app/Application.groovy, a nie do pliku my_grails_app/grails-app/conf/application.groovy, który można uzyskać po przekonwertowaniu z konfiguracji .yml na konfigurację .groovy.

package my_grails_app 

import grails.boot.GrailsApp 
import grails.boot.config.GrailsAutoConfiguration 
import org.springframework.context.EnvironmentAware 
import org.springframework.core.env.Environment 
import org.springframework.core.env.MapPropertySource 

class Application extends GrailsAutoConfiguration implements EnvironmentAware { 
    static void main(String[] args) { 
     GrailsApp.run(Application, args) 
    } 

    @Override 
    void setEnvironment(Environment environment) { 
     def appName = grails.util.Metadata.current.getApplicationName() 

     // The value of this environment variable should be the absolute path to an external .groovy config file like /opt/my_grails_app/my_grails_app-config.groovy. 
     def envVarName = "MY_GRAILS_APP_CONFIG" 

     // If you don't want to use an environment variable you can specify your external .groovy config file here, but the environment variable will still be checked first. 
     def dfltAppConfigFileName = "/opt/${ appName }/${ appName }-config.groovy" 
     def appConfigFile = null 
     def loadDfltConfig = false 

     // Try to load config specified by the environment variable first 
     println "Checking the environment variable ${ envVarName } for the configuration file location..." 
     def envVarVal = System.getenv(envVarName) ?: System.getProperty(envVarName) 
     if(envVarVal) { 
      appConfigFile = new File(envVarVal) 
      if(!appConfigFile.exists()) { 
       println "The configuration file ${ appConfigFile } specified by the environment variable ${ envVarName } does not exist. Checking for the default configuration file ${ dfltAppConfigFileName } instead..." 
       appConfigFile = null 
       loadDfltConfig = true 
      } 
     } else { 
      println "The environment variable ${ envVarName } which specifies the configuration file to be loaded does not exist. Checking for the default configuration file ${ dfltAppConfigFileName } instead..." 
      appConfigFile = null 
      loadDfltConfig = true 
     } 

     // Try loading the default config file since we couldn't find one specified by the environment variable 
     if(loadDfltConfig) { 
      appConfigFile = new File(dfltAppConfigFileName) 
      if(!appConfigFile.exists()) { 
       println "The default configuration file ${ dfltAppConfigFileName } does not exist." 
       appConfigFile = null 
      } 
     } 

     // Load the config file if it exists, otherwise exit 
     if(appConfigFile) { 
      println "Loading configuration file ${ appConfigFile }" 
      def config = new ConfigSlurper(environment.activeProfiles.first()).parse(appConfigFile.toURI().toURL()) 
      environment.propertySources.addFirst(new MapPropertySource("${ appName }-config", config)) 
     } else { 
      println "No configuration file found. Exiting." 
      System.exit(1) 
     } 

Answer 1

znalazłem this thread i notowanie przez Graeme Rocher:

Grails 3 wykorzystuje źródła własności koncepcja Wiosny, więc będzie to rozwiązać właściwości z systemu, środowiska i wreszcie zastosowania . yml/application.groovy

i kod: Clyde Balneaves:

class Application extends GrailsAutoConfiguration implements EnvironmentAware { 
    static void main(String[] args) { 
    GrailsApp.run(Application) 
    } 

    @Override 
    void setEnvironment(Environment environment) { 
    //Set up Configuration directory 
    def krakenHome = System.getenv('KRAKEN_HOME') ?: System.getProperty('KRAKEN_HOME') ?: "/opt/kraken" 

    println "" 
    println "Loading configuration from ${krakenHome}" 
    def appConfigured = new File(krakenHome, 'KrakenConfig.groovy').exists() 
    println "Loading configuration file ${new File(krakenHome, 'KrakenConfig.groovy')}" 
    println "Config file found : " + appConfigured 

    if (appConfigured) { 
     def config = new ConfigSlurper().parse(new File(krakenHome, 'KrakenConfig.groovy').toURL()) 
     environment.propertySources.addFirst(new MapPropertySource("KrakenConfig", config)) 
    } 
    } 
} 

Answer 2

Może można także spróbować w ten sposób (przesłanianie metody Run)

import grails.boot.GrailsApp 
import grails.boot.config.GrailsAutoConfiguration 
import grails.util.Environment 
import grails.util.Holders 
import org.springframework.boot.CommandLineRunner 

class Application extends GrailsAutoConfiguration implements CommandLineRunner { 

    static void main(String[] args) { 
     GrailsApp.run(Application, args) 
    } 

    @Override 
    void run(final String... args) throws Exception { 
     println "Running in ${Environment.current.name}" 

     // Get configuration from Holders. 
     def config = Holders.getConfig() 
     def locations = config.grails.config.locations 
     locations.each { 
      String configFileName = it.split("file:")[1] 
      File configFile = new File(configFileName) 
      if (configFile.exists()) { 
       config.merge(new ConfigSlurper(Environment.current.name).parse(configFile.text)) 
      } 
     } 
    } 
}