import groovy.util.ConfigSlurper; //导入依赖的package包/类
/**
 * Set the client properties, such as brokerURL, from a pre-loaded groovy config file.
 *
 * @param leoClient Client object to configure.
 * @return Reference to the configured Client.
 * @throws MalformedURLException if the configuration file url that was set is invalid.
 * @throws InvocationTargetException if the groovy config refers to objects not in the classpath.
 * @throws IllegalAccessException if there is a rights issue accessing settings from the groovy config.
 */
protected Client setClientProperties(Client leoClient) throws MalformedURLException, InvocationTargetException, IllegalAccessException {
    if (clientConfigFile.length != 1) {
        return leoClient;
    }

    ConfigSlurper configSlurper = new ConfigSlurper();
    ConfigObject o = configSlurper.parse(clientConfigFile[0].toURI().toURL());

    Set<Map.Entry> entries = o.entrySet();
    for (Map.Entry e : entries) {
        System.out.println("Setting property " + e.getKey() + " on client to " + e.getValue() + ".");
        BeanUtils.setProperty(leoClient, e.getKey().toString(), e.getValue());
    }

    return leoClient;
}
 

import groovy.util.ConfigSlurper; //导入依赖的package包/类
private ConfigObject loadFromResource(final ConfigSlurper slurper, final String location) {
    final Resource res = resourceLoader.getResource(location);
    if (!res.exists()) {
        LOG.warn("Skip non-existence resource: {}", res);
        return null;
    }
    if (!res.isReadable()) {
        LOG.warn("Resource not readable: {}", res);
        return null;
    }
    final URL url;
    try {
        url = res.getURL();
    }
    catch (IOException e) {
        throw new ConfigException("Not expecting a bad URL from a redable resource: " + res, e);
    }
    return slurper.parse(url);
}
 

import groovy.util.ConfigSlurper; //导入依赖的package包/类
public static Properties getProperties() {

        Properties profileProperties = new Properties();
        String profile = System.getProperty("profile", "test");

        try {
            profileProperties = new ConfigSlurper(profile).parse(new File("src/main/resources/config.groovy").toURI().toURL()).toProperties();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }

        Properties systemProperties = System.getProperties();

        System.out.println("\n[Properties reading] ---------------------------------------------------------");

        for (Map.Entry entry : profileProperties.entrySet()) {
            String key = String.valueOf(entry.getKey());
            System.out.println(key + " = " + entry.getValue());
            if (systemProperties.containsKey(key)) {
                String value = systemProperties.getProperty(key);

                if (!value.isEmpty()) {
                    profileProperties.setProperty(key, value);
                    System.out.println(key + " = " + entry.getValue() + " !!! corrected");
                }
            }
        }
        System.out.println("[Properties reading] ---------------------------------------------------------\n");

        return profileProperties;
    }
 

import groovy.util.ConfigSlurper; //导入依赖的package包/类
/**
 * Parse the groovy configuration file to retrieve the parameters for the annotator.
 *
 * @param configurationFile
 * @throws IOException
 */
protected void parseConfiguration(File configurationFile) throws IOException {
    ConfigSlurper configSlurper = new ConfigSlurper();
    ConfigObject configObject = new ConfigSlurper().parse(FileUtils.readFileToString(configurationFile));

    //Get the name and base configuration
    annotatorName =(String)configObject.get("name");
    ConfigObject configuration = (ConfigObject) configObject.get("configuration");

    //Get the default parameters if specified
    if(configuration.get("defaults") != null) {
        this.defaults = (ConfigObject) configuration.get("defaults");
    }

    // Create the configuration maps and merge in any defaults. .
    for (Object configurationKey: configuration.keySet()) {
        String configurationName = (String)configurationKey;

        // Defaults are handled outside of this loop.
        if ("defaults".equals(configurationName)) {
            continue;
        }

        if (configurationNameParametersMap.containsKey(configurationName)) {
            throw new IllegalArgumentException("ConText configuration file has multiple configurations of the same name: '" + configurationName + "'.");
        }
        ConfigObject contextConfigObject = (ConfigObject) configuration.get(configurationName);
        ConfigObject mergedConfigObject = contextConfigObject.clone();
        mergeDefaults(mergedConfigObject, this.defaults);
        configurationNameParametersMap.put(configurationName, mergedConfigObject);
    }
}
 

import groovy.util.ConfigSlurper; //导入依赖的package包/类
private CompilerConfiguration createCompilerConfiguration(ClassLoader cl) {
  Closure customizer = null;
  Properties properties = new Properties();
  URL url = findConfigurationResource(cl);
  if(url != null) {
    log.trace("Configuring groovy compiler with ${url}");
    try {
      if(url.getFile().toLowerCase().endsWith(".groovy")) {
        ConfigSlurper slurper = new ConfigSlurper();
        slurper.setClassLoader(new GroovyClassLoader(cl));
        ConfigObject cObject = slurper.parse(url);
        Object c = cObject.remove("customizer");
        if (c instanceof Closure<?>) {
          customizer = (Closure) c;
        }
        properties.putAll(cObject.toProperties());
      } else {
        InputStream stream = url.openStream();
        properties.load(stream);
      }
    } catch(Exception e) {
      log.error("Error loading Groovy CompilerConfiguration properties from $url", e);
    }
  } else {
    log.trace("No groovy configuration file found.");
  }

  CompilerConfiguration compilerCfg = new CompilerConfiguration(CompilerConfiguration.DEFAULT);
  if(properties.size() != 0){
    compilerCfg.configure(properties);
  }

  if (customizer != null) {
    Object result = customizer.call(compilerCfg);
    // Expectation: If result isn't a CompilerConfiguration, the original one has been modified
    if(result instanceof CompilerConfiguration)
      compilerCfg = (CompilerConfiguration) result;
  }
  return compilerCfg;
}
 

import groovy.util.ConfigSlurper; //导入依赖的package包/类
/**
 * Parse the groovy config files, and return the listener objects that are defined in them.
 *
 * @param configs   the groovy config files to slurp
 * @return   the list of listeners that are defined in the groovy configs.
 * @throws MalformedURLException if the configuration file url that was set is invalid.
 */
public static List<UimaAsBaseCallbackListener> getListeners(File...configs) throws MalformedURLException {
    ConfigSlurper configSlurper = new ConfigSlurper();
    List<UimaAsBaseCallbackListener> listeners = new ArrayList<UimaAsBaseCallbackListener>();

    for (File config: configs) {
        ConfigObject configObject = configSlurper.parse(config.toURI().toURL());
        if (configObject.get("listener") != null ) {
            listeners.add((UimaAsBaseCallbackListener) configObject.get("listener"));
        }
    }
    return listeners;
}
 

import groovy.util.ConfigSlurper; //导入依赖的package包/类
/**
 * Parse the groovy config file, and return the reader object. This must be a BaseLeoCollectionReader.
 *
 * @param config   the groovy config file to slurp
 * @return   the reader defined in the groovy config.
 * @throws MalformedURLException if the configuration file url that was set is invalid.
 */
public static BaseLeoCollectionReader getReader(File config) throws MalformedURLException {
    ConfigSlurper configSlurper = new ConfigSlurper();

    ConfigObject configObject = configSlurper.parse(config.toURI().toURL());
    if (configObject.get("reader") != null ) {
        return (BaseLeoCollectionReader) configObject.get("reader");
    }
  return null;
}
 

import groovy.util.ConfigSlurper; //导入依赖的package包/类
/**
 * Load the config file(s).
 *
 * @param environment name of the environment to load
 * @param configFilePaths paths the config files to load, local or remote
 * @return ConfigObject with accumulated variables representing the environment
 * @throws IOException if there is a problem reading the config files
 */
public static ConfigObject loadConfigFile(String environment, String... configFilePaths) throws IOException {
    ConfigSlurper slurper = new ConfigSlurper(environment);
    ConfigObject config = new ConfigObject();
    ClassLoader cl = ClassLoader.getSystemClassLoader();
    for (String filePath : configFilePaths) {
        InputStream in = cl.getResourceAsStream(filePath);
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        IOUtils.copy(in, out);
        String resourceAsString = out.toString();
        config.merge(slurper.parse(resourceAsString));
    }
    return config;
}
 

import groovy.util.ConfigSlurper; //导入依赖的package包/类
private void loadFromLocation(final ConfigSlurper slurper, final ConfigObject configObject, final String location) {
    LOG.info("Load from: {}", location);
    final ConfigObject cobj;
    if (location.startsWith(LOCATION_PREFIX_CLASS)) {
        cobj = loadFromClass(slurper, location.substring(LOCATION_PREFIX_CLASS.length()));
    }
    else {
        cobj = loadFromResource(slurper, location);
    }
    if (cobj != null) {
        resolveScriptValues(configObject, cobj);
        configObject.merge(cobj);
    }
}
 

import groovy.util.ConfigSlurper; //导入依赖的package包/类
private ConfigObject loadFromClass(final ConfigSlurper slurper, final String classname) {
    final Class<?> scriptClass;
    try {
        scriptClass = resourceLoader.getClassLoader().loadClass(classname);
    }
    catch (final ClassNotFoundException e) {
        LOG.warn("Class not found: {}", classname);
        return null;
    }
    return slurper.parse(scriptClass);
}
 

import groovy.util.ConfigSlurper; //导入依赖的package包/类
public static Config getConfig(String env, File config) throws IOException {
  ConfigObject configObject = new ConfigSlurper(env).parse(readGroovyConfigScript(config));
  Config stormConf = new Config();
  Map flatten = configObject.flatten();
  stormConf.putAll(flatten);

  Map<String, Class> dataTypes = new HashMap<String, Class>();
  dataTypes.put("topology.workers", Integer.class);
  dataTypes.put("topology.acker.executors", Integer.class);
  dataTypes.put("topology.message.timeout.secs", Integer.class);
  dataTypes.put("topology.max.task.parallelism", Integer.class);
  dataTypes.put("topology.stats.sample.rate", Double.class);

  // this will convert built in properties as storm uses old school properties
  for (Field field : stormConf.getClass().getFields()) {
    if (Modifier.isStatic(field.getModifiers())
      && Modifier.isPublic(field.getModifiers())) {
      String property = field.getName().toLowerCase().replace('_', '.');
      if (property.startsWith("java.")) {
        // don't mess with Java system properties here
        continue;
      }

      Object override = flatten.get(property);
      if (override != null) {
        stormConf.put(property, override);
        System.out.println("Overrode property '" + property + "' with value [" + override + "] from Config.groovy of type " + override.getClass().getName());
      }
      String system = System.getProperty(property, null);
      if (system != null) {
        if (dataTypes.containsKey(property)) {
          Class aClass = dataTypes.get(property);
          try {
            Method valueOf = aClass.getMethod("valueOf", String.class);
            stormConf.put(property, valueOf.invoke(aClass, system));
            System.out.println("Overrode property '" + property + "' with value [" + stormConf.get(property) + "] from -D System property of type " + aClass.getName());
          } catch (Exception e) {
            throw new RuntimeException(e.getMessage(), e);
          }
        } else {
          stormConf.put(property, system);
          System.out.println("Overrode property '" + property + "' with String value [" + system + "] from -D System property");
        }
      }
    }
  }

  return stormConf;
}