object ConfigFactory
Contains static methods for creating Config instances.
See also ConfigValueFactory which contains static methods for converting Java values into a ConfigObject. You can then convert a ConfigObject into a Config with ConfigObject.toConfig().
The static methods with "load" in the name do some sort of higher-level operation potentially parsing multiple resources and resolving substitutions, while the ones with "parse" in the name just create a ConfigValue from a resource and nothing else.
You can find an example app and library <a on GitHub. Also be sure to read the package overview which describes the big picture as shown in those examples.
- Alphabetic
- By Inheritance
- ConfigFactory
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @IntrinsicCandidate() @native()
- def defaultApplication(options: ConfigParseOptions): Config
Like defaultApplication() but allows you to specify parse options.
Like defaultApplication() but allows you to specify parse options.
- options
the options
- returns
the default application configuration
- Since
1.3.0
- def defaultApplication(loader: ClassLoader): Config
Like defaultApplication() but allows you to specify a class loader to use rather than the current context class loader.
Like defaultApplication() but allows you to specify a class loader to use rather than the current context class loader.
- loader
class loader to look for resources in
- returns
the default application configuration
- Since
1.3.0
- def defaultApplication(): Config
Obtains the default application-specific configuration, which defaults to parsing
application.conf,application.json, andapplication.propertieson the classpath, but can also be rerouted using theconfig.file,config.resource, andconfig.urlsystem properties.Obtains the default application-specific configuration, which defaults to parsing
application.conf,application.json, andapplication.propertieson the classpath, but can also be rerouted using theconfig.file,config.resource, andconfig.urlsystem properties.The no-arguments load() method automatically stacks the defaultReference(), defaultApplication(), and defaultOverrides() configs. You would use
defaultApplication()directly only if you're somehow customizing behavior by reimplementingload().The configuration returned by
defaultApplication()will not be resolved already, in contrast todefaultReference()anddefaultOverrides(). This is because application.conf would normally be resolved after merging with the reference and override configs.If the system properties
config.resource,config.file, orconfig.urlare set, then the classpath resource, file, or URL specified in those properties will be used rather than the defaultapplication.{conf,json,properties]]classpath resources. These system properties should not be set in code (after all, you can just parse whatever you want manually and then use load(Config) if you don't want to useapplication.conf). The properties are intended for use by the person or script launching the application. For example someone might have aproduction.confthat includeapplication.confbut then change a couple of values. When launching the app they could specify-Dconfig.resource=production.confto get production mode.If no system properties are set to change the location of the default configuration,
defaultApplication()is equivalent toConfigFactory.parseResources("application").- returns
the default application.conf or system-property-configured configuration
- Since
1.3.0
- def defaultOverrides(loader: ClassLoader): Config
Like defaultOverrides() but allows you to specify a class loader to use rather than the current context class loader.
Like defaultOverrides() but allows you to specify a class loader to use rather than the current context class loader.
- loader
class loader to look for resources in
- returns
the default override configuration
- def defaultOverrides(): Config
Obtains the default override configuration, which currently consists of system properties.
Obtains the default override configuration, which currently consists of system properties. The returned override configuration will already have substitutions resolved.
The load() methods merge this configuration for you automatically.
Future versions may get overrides in more places. It is not guaranteed that this method only uses system properties.
- returns
the default override configuration
- def defaultReference(loader: ClassLoader): Config
Like defaultReference() but allows you to specify a class loader to use rather than the current context class loader.
Like defaultReference() but allows you to specify a class loader to use rather than the current context class loader.
- loader
class loader to look for resources in
- returns
the default reference config for this class loader
- def defaultReference(): Config
Obtains the default reference configuration, which is currently created by merging all resources "reference.conf" found on the classpath and overriding the result with system properties.
Obtains the default reference configuration, which is currently created by merging all resources "reference.conf" found on the classpath and overriding the result with system properties. The returned reference configuration will already have substitutions resolved.
Libraries and frameworks should ship with a "reference.conf" in their jar.
The reference config must be looked up in the class loader that contains the libraries that you want to use with this config, so the "reference.conf" for each library can be found. Use defaultReference(ClassLoader) if the context class loader is not suitable.
The load() methods merge this configuration for you automatically.
Future versions may look for reference configuration in more places. It is not guaranteed that this method only looks at "reference.conf".
- returns
the default reference config for context class loader
- def empty(originDescription: String): Config
Gets an empty configuration with a description to be used to create a ConfigOrigin for this
Config.Gets an empty configuration with a description to be used to create a ConfigOrigin for this
Config. The description should be very short and say what the configuration is, like "default settings" or "foo settings" or something. (Presumably you will merge some actual settings into this empty config using Config.withFallback, making the description more useful.)- originDescription
description of the config
- returns
an empty configuration
- def empty(): Config
Gets an empty configuration.
Gets an empty configuration. See also empty(String) to create an empty configuration with a description, which may improve user-visible error messages.
- returns
an empty configuration
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @IntrinsicCandidate() @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @IntrinsicCandidate() @native()
- def invalidateCaches(): Unit
Reloads any cached configs, picking up changes to system properties for example.
Reloads any cached configs, picking up changes to system properties for example. Because a Config is immutable, anyone with a reference to the old configs will still have the same outdated objects. However, new calls to load() or defaultOverrides() or defaultReference() may return a new object.
This method is primarily intended for use in unit tests, for example, that may want to update a system property then confirm that it's used correctly. In many cases, use of this method may indicate there's a better way to set up your code.
Caches may be reloaded immediately or lazily; once you call this method, the reload can occur at any time, even during the invalidation process. So FIRST make the changes you'd like the caches to notice, then SECOND call this method to invalidate caches. Don't expect that invalidating, making changes, then calling load(), will work. Make changes before you invalidate.
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def load(parseOptions: ConfigParseOptions, resolveOptions: ConfigResolveOptions): Config
Like load() but allows specifying parse options and resolve options.
Like load() but allows specifying parse options and resolve options.
- parseOptions
Options for parsing resources
- resolveOptions
options for resolving the assembled config stack
- returns
configuration for an application
- Since
1.3.0
- def load(loader: ClassLoader, parseOptions: ConfigParseOptions, resolveOptions: ConfigResolveOptions): Config
Like load() but allows specifying a class loader other than the thread's current context class loader, parse options, and resolve options.
Like load() but allows specifying a class loader other than the thread's current context class loader, parse options, and resolve options.
- loader
class loader for finding resources (overrides any loader in parseOptions)
- parseOptions
Options for parsing resources
- resolveOptions
options for resolving the assembled config stack
- returns
configuration for an application
- def load(loader: ClassLoader, resolveOptions: ConfigResolveOptions): Config
Like load() but allows specifying a class loader other than the thread's current context class loader and also specify resolve options.
Like load() but allows specifying a class loader other than the thread's current context class loader and also specify resolve options.
- loader
class loader for finding resources
- resolveOptions
options for resolving the assembled config stack
- returns
configuration for an application
- def load(loader: ClassLoader, parseOptions: ConfigParseOptions): Config
Like load() but allows specifying a class loader other than the thread's current context class loader and also specify parse options.
Like load() but allows specifying a class loader other than the thread's current context class loader and also specify parse options.
- loader
class loader for finding resources (overrides any loader in parseOptions)
- parseOptions
Options for parsing resources
- returns
configuration for an application
- def load(loader: ClassLoader): Config
Like load() but allows specifying a class loader other than the thread's current context class loader.
Like load() but allows specifying a class loader other than the thread's current context class loader.
- loader
class loader for finding resources
- returns
configuration for an application
- def load(parseOptions: ConfigParseOptions): Config
Like load() but allows specifying parse options.
Like load() but allows specifying parse options.
- parseOptions
Options for parsing resources
- returns
configuration for an application
- def load(): Config
Loads a default configuration, equivalent to load(Config)
ConfigFactory.load(defaultApplication()) in most cases. This configuration should be used by libraries and frameworks unless an application provides a different one.Loads a default configuration, equivalent to load(Config)
ConfigFactory.load(defaultApplication()) in most cases. This configuration should be used by libraries and frameworks unless an application provides a different one.This method may return a cached singleton so will not see changes to system properties or config files. (Use invalidateCaches() to force it to reload.)
- returns
configuration for an application
- def load(loader: ClassLoader, config: Config, resolveOptions: ConfigResolveOptions): Config
Like load(Config,ConfigResolveOptions) but allows you to specify a class loader other than the context class loader.
Like load(Config,ConfigResolveOptions) but allows you to specify a class loader other than the context class loader.
- loader
class loader to use when looking up override and reference configs
- config
the application's portion of the configuration
- resolveOptions
options for resolving the assembled config stack
- returns
resolved configuration with overrides and fallbacks added
- def load(config: Config, resolveOptions: ConfigResolveOptions): Config
Like load(Config) but allows you to specify ConfigResolveOptions.
Like load(Config) but allows you to specify ConfigResolveOptions.
- config
the application's portion of the configuration
- resolveOptions
options for resolving the assembled config stack
- returns
resolved configuration with overrides and fallbacks added
- def load(loader: ClassLoader, config: Config): Config
Like load(Config) but allows you to specify the class loader for looking up resources.
Like load(Config) but allows you to specify the class loader for looking up resources.
- loader
the class loader to use to find resources
- config
the application's portion of the configuration
- returns
resolved configuration with overrides and fallbacks added
- def load(config: Config): Config
Assembles a standard configuration using a custom
Configobject rather than loading "application.conf".Assembles a standard configuration using a custom
Configobject rather than loading "application.conf". TheConfigobject will be sandwiched between the default reference config and default overrides and then resolved.- config
the application's portion of the configuration
- returns
resolved configuration with overrides and fallbacks added
- def load(loader: ClassLoader, resourceBasename: String, parseOptions: ConfigParseOptions, resolveOptions: ConfigResolveOptions): Config
Like load(String,ConfigParseOptions,ConfigResolveOptions) but has a class loader parameter that overrides any from the ConfigParseOptions.
Like load(String,ConfigParseOptions,ConfigResolveOptions) but has a class loader parameter that overrides any from the ConfigParseOptions.
- loader
class loader in which to find resources (overrides loader in parse options)
- resourceBasename
the classpath resource name with optional extension
- parseOptions
options to use when parsing the resource (class loader overridden)
- resolveOptions
options to use when resolving the stack
- returns
configuration for an application
- def load(resourceBasename: String, parseOptions: ConfigParseOptions, resolveOptions: ConfigResolveOptions): Config
Like ConfigFactory.load(String) but allows you to specify parse and resolve options.
Like ConfigFactory.load(String) but allows you to specify parse and resolve options.
- resourceBasename
the classpath resource name with optional extension
- parseOptions
options to use when parsing the resource
- resolveOptions
options to use when resolving the stack
- returns
configuration for an application
- def load(loader: ClassLoader, resourceBasename: String): Config
Like ConfigFactory.load(String) but uses the supplied class loader instead of the current thread's context class loader.
Like ConfigFactory.load(String) but uses the supplied class loader instead of the current thread's context class loader.
To load a standalone resource (without the default reference and default overrides), use parseResourcesAnySyntax(ClassLoader,String) rather than this method. To load only the reference config use defaultReference(ClassLoader) and to load only the overrides use defaultOverrides(ClassLoader).
- loader
class loader to look for resources in
- resourceBasename
basename (no .conf/.json/.properties suffix)
- returns
configuration for an application relative to given class loader
- def load(resourceBasename: String): Config
Loads an application's configuration from the given classpath resource or classpath resource basename, sandwiches it between default reference config and default overrides, and then resolves it.
Loads an application's configuration from the given classpath resource or classpath resource basename, sandwiches it between default reference config and default overrides, and then resolves it. The classpath resource is "raw" (it should have no "/" prefix, and is not made relative to any package, so it's like
ClassLoader.getResourcenotClass.getResource).Resources are loaded from the current thread's
Thread.getContextClassLoader. In general, a library needs its configuration to come from the class loader used to load that library, so the proper "reference.conf" are present.The loaded object will already be resolved (substitutions have already been processed). As a result, if you add more fallbacks then they won't be seen by substitutions. Substitutions are the
${foo.bar}syntax. If you want to parse additional files or something then you need to use load(Config).To load a standalone resource (without the default reference and default overrides), use parseResourcesAnySyntax(String) rather than this method. To load only the reference config use defaultReference() and to load only the overrides use defaultOverrides().
- resourceBasename
name (optionally without extension) of a resource on classpath
- returns
configuration for an application relative to context class loader
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @IntrinsicCandidate() @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @IntrinsicCandidate() @native()
- def parseFile(file: File): Config
Parses a file into a Config instance as with parseFile(File,ConfigParseOptions) but always uses the default parse options.
Parses a file into a Config instance as with parseFile(File,ConfigParseOptions) but always uses the default parse options.
- file
the file to parse
- returns
the parsed configuration
- Exceptions thrown
ConfigExceptionon IO or parse errors
- def parseFile(file: File, options: ConfigParseOptions): Config
Parses a file into a Config instance.
Parses a file into a Config instance. Does not call Config.resolve() or merge the file with any other configuration; this method parses a single file and does nothing else. It does process "include" statements in the parsed file, and may end up doing other IO due to those statements.
- file
the file to parse
- options
parse options to control how the file is interpreted
- returns
the parsed configuration
- Exceptions thrown
ConfigExceptionon IO or parse errors
- def parseFileAnySyntax(fileBasename: File): Config
Like parseFileAnySyntax(File,ConfigParseOptions) but always uses default parse options.
Like parseFileAnySyntax(File,ConfigParseOptions) but always uses default parse options.
- fileBasename
a filename with or without extension
- returns
the parsed configuration
- def parseFileAnySyntax(fileBasename: File, options: ConfigParseOptions): Config
Parses a file with a flexible extension.
Parses a file with a flexible extension. If the
fileBasenamealready ends in a known extension, this method parses it according to that extension (the file's syntax must match its extension). If thefileBasenamedoes not end in an extension, it parses files with all known extensions and merges whatever is found.In the current implementation, the extension ".conf" forces ConfigSyntax.CONF, ".json" forces ConfigSyntax.JSON, and ".properties" forces ConfigSyntax.PROPERTIES. When merging files, ".conf" falls back to ".json" falls back to ".properties".
Future versions of the implementation may add additional syntaxes or additional extensions. However, the ordering (fallback priority) of the three current extensions will remain the same.
If
optionsforces a specific syntax, this method only parses files with an extension matching that syntax.If ConfigParseOptions#getAllowMissing is true, then no files have to exist; if false, then at least one file has to exist.
- fileBasename
a filename with or without extension
- options
parse options
- returns
the parsed configuration
- def parseMap(values: Map[String, _]): Config
See the other overload of ConfigFactory.parseMap(Map,String) for details, this one just uses a default origin description.
See the other overload of ConfigFactory.parseMap(Map,String) for details, this one just uses a default origin description.
- values
map from paths to plain Java values
- returns
the map converted to a Config
- def parseMap(values: Map[String, _], originDescription: String): Config
Creates a Config based on a
java.util.Mapfrom paths to plain Java values.Creates a Config based on a
java.util.Mapfrom paths to plain Java values. Similar to ConfigValueFactory.fromMap(Map,String), except the keys in the map are path expressions, rather than keys; and correspondingly it returns a Config instead of a ConfigObject. This is more convenient if you are writing literal maps in code, and less convenient if you are getting your maps from some data source such as a parser.An exception will be thrown (and it is a bug in the caller of the method) if a path is both an object and a value, for example if you had both "a=foo" and "a.b=bar", then "a" is both the string "foo" and the parent object of "b". The caller of this method should ensure that doesn't happen.
- values
map from paths to plain Java objects
- originDescription
description of what this map represents, like a filename, or "default settings" (origin description is used in error messages)
- returns
the map converted to a Config
- def parseProperties(properties: Properties): Config
Like parseProperties(Properties, ConfigParseOptions) but uses default parse options.
Like parseProperties(Properties, ConfigParseOptions) but uses default parse options.
- properties
a Java Properties object
- returns
the parsed configuration
- def parseProperties(properties: Properties, options: ConfigParseOptions): Config
Converts a Java
java.util.Propertiesobject to a ConfigObject using the rules documented in the HOCON spec The keys in thePropertiesobject are split on the period character '.' and treated as paths.Converts a Java
java.util.Propertiesobject to a ConfigObject using the rules documented in the HOCON spec The keys in thePropertiesobject are split on the period character '.' and treated as paths. The values will all end up as string values. If you have both "a=foo" and "a.b=bar" in your properties file, so "a" is both the object containing "b" and the string "foo", then the string value is dropped.If you want to have
System.getProperties()as a ConfigObject, it's better to use the #systemProperties method which returns a cached global singleton.- properties
a Java Properties object
- options
the parse options
- returns
the parsed configuration
- def parseReader(reader: Reader): Config
Parses a reader into a Config instance as with parseReader(Reader, ConfigParseOptions) but always uses the default parse options.
Parses a reader into a Config instance as with parseReader(Reader, ConfigParseOptions) but always uses the default parse options.
- reader
the reader to parse
- returns
the parsed configuration
- Exceptions thrown
ConfigExceptionon IO or parse errors
- def parseReader(reader: Reader, options: ConfigParseOptions): Config
Parses a Reader into a Config instance.
Parses a Reader into a Config instance. Does not call Config.resolve() or merge the parsed stream with any other configuration; this method parses a single stream and does nothing else. It does process "include" statements in the parsed stream, and may end up doing other IO due to those statements.
- reader
the reader to parse
- options
parse options to control how the reader is interpreted
- returns
the parsed configuration
- Exceptions thrown
ConfigExceptionon IO or parse errors
- def parseResources(resource: String): Config
Like parseResources(ClassLoader,String) but uses thread's current context class loader.
Like parseResources(ClassLoader,String) but uses thread's current context class loader.
- resource
the resource name
- returns
the parsed configuration
- def parseResources(resource: String, options: ConfigParseOptions): Config
Like parseResources(ClassLoader,String,ConfigParseOptions) but uses thread's current context class loader if none is set in the ConfigParseOptions.
Like parseResources(ClassLoader,String,ConfigParseOptions) but uses thread's current context class loader if none is set in the ConfigParseOptions.
- resource
the resource name
- options
parse options
- returns
the parsed configuration
- def parseResources(loader: ClassLoader, resource: String): Config
Like parseResources(ClassLoader,String,ConfigParseOptions) but always uses default parse options.
Like parseResources(ClassLoader,String,ConfigParseOptions) but always uses default parse options.
- loader
will be used to load resources
- resource
resource to look up in the loader
- returns
the parsed configuration
- def parseResources(loader: ClassLoader, resource: String, options: ConfigParseOptions): Config
Parses all resources on the classpath with the given name and merges them into a single
Config.Parses all resources on the classpath with the given name and merges them into a single
Config.This works like
java.lang.ClassLoader.getResource, not likejava.lang.Class.getResource, so the name never begins with a slash.See parseResources(Class,String,ConfigParseOptions) for full details.
- loader
will be used to load resources by setting this loader on the provided options
- resource
resource to look up
- options
parse options (class loader is ignored)
- returns
the parsed configuration
- def parseResources(klass: Class[_], resource: String): Config
Like parseResources(Class,String,ConfigParseOptions) but always uses default parse options.
Like parseResources(Class,String,ConfigParseOptions) but always uses default parse options.
- klass
klass.getClassLoader()will be used to load resources, and non-absolute resource names will have this class's package added- resource
resource to look up, relative to
klass's package or absolute starting with a "/"- returns
the parsed configuration
- def parseResources(klass: Class[_], resource: String, options: ConfigParseOptions): Config
Parses all resources on the classpath with the given name and merges them into a single Config.
Parses all resources on the classpath with the given name and merges them into a single Config.
If the resource name does not begin with a "/", it will have the supplied class's package added to it, in the same way as
java.lang.Class.getResource.Duplicate resources with the same name are merged such that ones returned earlier from
ClassLoader.getResourcesfall back to (have higher priority than) the ones returned later# This implies that resources earlier in the classpath override those later in the classpath when they configure the same setting# However, in practice real applications may not be consistent about classpath ordering, so be careful# It may be best to avoid assuming too much#- klass
klass.getClassLoader()will be used to load resources, and non-absolute resource names will have this class's package added- resource
resource to look up, relative to
klass's package or absolute starting with a "/"- options
parse options
- returns
the parsed configuration
- def parseResourcesAnySyntax(resourceBasename: String): Config
Like parseResourcesAnySyntax(ClassLoader,String) but uses thread's current context class loader.
Like parseResourcesAnySyntax(ClassLoader,String) but uses thread's current context class loader.
- resourceBasename
the resource basename (no file type suffix)
- returns
the parsed configuration
- def parseResourcesAnySyntax(resourceBasename: String, options: ConfigParseOptions): Config
Like parseResourcesAnySyntax(ClassLoader,String,ConfigParseOptions) but uses thread's current context class loader.
Like parseResourcesAnySyntax(ClassLoader,String,ConfigParseOptions) but uses thread's current context class loader.
- resourceBasename
the resource basename (no file type suffix)
- options
parse options
- returns
the parsed configuration
- def parseResourcesAnySyntax(loader: ClassLoader, resourceBasename: String): Config
Like parseResourcesAnySyntax(ClassLoader,String,ConfigParseOptions) but always uses default parse options.
Like parseResourcesAnySyntax(ClassLoader,String,ConfigParseOptions) but always uses default parse options.
- loader
will be used to load resources
- resourceBasename
a resource name as in
java.lang.ClassLoader.getResource, with or without extension- returns
the parsed configuration
- def parseResourcesAnySyntax(loader: ClassLoader, resourceBasename: String, options: ConfigParseOptions): Config
Parses classpath resources with a flexible extension.
Parses classpath resources with a flexible extension. In general, this method has the same behavior as parseFileAnySyntax(File,ConfigParseOptions) but for classpath resources instead, as in parseResources(ClassLoader,String,ConfigParseOptions).
parseResourcesAnySyntax(Class,String,ConfigParseOptions) differs in the syntax for the resource name, but it is useful to review for some details and caveats on this method.
- loader
class loader to look up resources in, will be set on options
- resourceBasename
a resource name as in
java.lang.ClassLoader.getResource, with or without extension- options
parse options (class loader ignored)
- returns
the parsed configuration
- def parseResourcesAnySyntax(klass: Class[_], resourceBasename: String): Config
Like parseResourcesAnySyntax(Class,String,ConfigParseOptions) but always uses default parse options.
Like parseResourcesAnySyntax(Class,String,ConfigParseOptions) but always uses default parse options.
- klass
klass.getClassLoader()will be used to load resources, and non-absolute resource names will have this class's package added- resourceBasename
a resource name as in
java.lang.Class.getResource, with or without extension- returns
the parsed configuration
- def parseResourcesAnySyntax(klass: Class[_], resourceBasename: String, options: ConfigParseOptions): Config
Parses classpath resources with a flexible extension.
Parses classpath resources with a flexible extension. In general, this method has the same behavior as parseFileAnySyntax(File,ConfigParseOptions) but for classpath resources instead, as in parseResources(String).
There is a thorny problem with this method, which is that
java.lang.ClassLoader.getResourcesmust be called separately for each possible extension. The implementation ends up with separate lists of resources called "basename.conf" and "basename.json" for example. As a result, the ideal ordering between two files with different extensions is unknown; there is no way to figure out how to merge the two lists in classpath order. To keep it simple, the lists are simply concatenated, with the same syntax priorities as parseFileAnySyntax(File,ConfigParseOptions)- all ".conf" resources are ahead of all ".json" resources which are ahead of all ".properties" resources.
- klass
class which determines the
ClassLoaderand the package for relative resource names- resourceBasename
a resource name as in
java.lang.Class.getResource, with or without extension- options
parse options (class loader is ignored in favor of the one from klass)
- returns
the parsed configuration
- def parseString(s: String): Config
Parses a string (which should be valid HOCON or JSON).
Parses a string (which should be valid HOCON or JSON).
- s
string to parse
- returns
the parsed configuration
- def parseString(s: String, options: ConfigParseOptions): Config
Parses a string (which should be valid HOCON or JSON by default, or the syntax specified in the options otherwise).
Parses a string (which should be valid HOCON or JSON by default, or the syntax specified in the options otherwise).
- s
string to parse
- options
parse options
- returns
the parsed configuration
- def parseURL(url: URL): Config
Parses a url into a Config instance as with ConfigFactory.parseURL(URL,ConfigParseOptions) but always uses the default parse options.
Parses a url into a Config instance as with ConfigFactory.parseURL(URL,ConfigParseOptions) but always uses the default parse options.
- url
the url to parse
- returns
the parsed configuration
- Exceptions thrown
ConfigExceptionon IO or parse errors
- def parseURL(url: URL, options: ConfigParseOptions): Config
Parses a URL into a Config instance.
Parses a URL into a Config instance. Does not call Config.resolve() or merge the parsed stream with any other configuration; this method parses a single stream and does nothing else. It does process "include" statements in the parsed stream, and may end up doing other IO due to those statements.
- url
the url to parse
- options
parse options to control how the url is interpreted
- returns
the parsed configuration
- Exceptions thrown
ConfigExceptionon IO or parse errors
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def systemEnvironment(): Config
Gets a Config containing the system's environment variables.
Gets a Config containing the system's environment variables. This method can return a global immutable singleton.
Environment variables are used as fallbacks when resolving substitutions whether or not this object is included in the config being resolved, so you probably don't need to use this method for most purposes. It can be a nicer API for accessing environment variables than raw
java.lang.System.getenv(String)though, since you can use methods such as Config.getInt.- returns
system environment variables parsed into a
Config
- def systemProperties(): Config
Gets a
Configcontaining the system properties fromjava.lang.System.getProperties(), parsed and converted as with parseProperties(Properties).Gets a
Configcontaining the system properties fromjava.lang.System.getProperties(), parsed and converted as with parseProperties(Properties).This method can return a global immutable singleton, so it's preferred over parsing system properties yourself.
ConfigFactory.load() will include the system properties as overrides already, as will defaultReference() and defaultOverrides().
Because this returns a singleton, it will not notice changes to system properties made after the first time this method is called. Use invalidateCaches() to force the singleton to reload if you modify system properties.
- returns
system properties parsed into a Config
- def toString(): String
- Definition Classes
- AnyRef → Any
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
Deprecated Value Members
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable]) @Deprecated
- Deprecated
(Since version 9)