What is Environment?
org.springframework.core.env.Environment is an interface representing the environment in which the current application is running.
With Environment instance we can access the properties loaded for the application. Let's understand how can we do that.
Definition of Environment(Version: spring-framework 6.1.2) package org.springframework.core.env;
........
public interface Environment extends PropertyResolver {
String[] getActiveProfiles();
String[] getDefaultProfiles();
default boolean matchesProfiles(String... profileExpressions) {
return acceptsProfiles(Profiles.of(profileExpressions));
}
@Deprecated
boolean acceptsProfiles(String... profiles);
boolean acceptsProfiles(Profiles profiles);
}
As seen above Environment extends PropertyResolver.
Definition of PropertyResolver(Version: spring-framework 6.1.2) package org.springframework.core.env;
........
public interface PropertyResolver {
boolean containsProperty(String key);
@Nullable
String getProperty(String key);
String getProperty(String key, String defaultValue);
@Nullable
<T> T getProperty(String key, Class<T> targetType);
<T> T getProperty(String key, Class<T> targetType, T defaultValue);
String getRequiredProperty(String key) throws IllegalStateException;
<T> T getRequiredProperty(String key, Class<T> targetType)
throws IllegalStateException;
String resolvePlaceholders(String text);
String resolveRequiredPlaceholders(String text) throws IllegalArgumentException;
}
Spring attempts to unify all name/value property pairs access into org.springframework.core.env.Environment.
The properties source can be java.util.Properties, loaded from a file or Java system/env properties or java.util.Map.
If we are in the Servlet container environment, the source can be javax.servlet.ServletContext or javax.servlet.ServletConfig.
ConfigurableEnvironment interface
This interface extends Environment and ConfigurablePropertyResolver interfaces. It provides facilities for setting active and default profiles and accessing underlying property sources.
Definition of ConfigurableEnvironment(Version: spring-framework 6.1.2) package org.springframework.core.env;
........
public interface ConfigurableEnvironment extends Environment, ConfigurablePropertyResolver {
void setActiveProfiles(String... profiles);
void addActiveProfile(String profile);
void setDefaultProfiles(String... profiles);
MutablePropertySources getPropertySources();
Map<String, Object> getSystemProperties();
Map<String, Object> getSystemEnvironment();
void merge(ConfigurableEnvironment parent);
}
Definition of ConfigurablePropertyResolver(Version: spring-framework 6.1.2) package org.springframework.core.env;
........
public interface ConfigurablePropertyResolver extends PropertyResolver {
ConfigurableConversionService getConversionService();
void setConversionService(ConfigurableConversionService conversionService);
void setPlaceholderPrefix(String placeholderPrefix);
void setPlaceholderSuffix(String placeholderSuffix);
void setValueSeparator(@Nullable String valueSeparator);
void setIgnoreUnresolvableNestedPlaceholders(
boolean ignoreUnresolvableNestedPlaceholders);
void setRequiredProperties(String... requiredProperties);
void validateRequiredProperties() throws MissingRequiredPropertiesException;
}
We can get an instance of ConfigurableEnvironment via ConfigurableApplicationContext#getEnvironment() (as we saw in the last tutorial). ConfigurableApplicationContext is a sub interface of org.springframework.context.ApplicationContext.
Accessing properties with Environment
Using methods of org.springframework.core.env.Environment directly is one way to access properties in our applications.
package com.logicbig.example;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.PropertySource;
import java.util.Map;
public class DefaultSystemSourcesExample {
public static void main (String[] args) {
AnnotationConfigApplicationContext context =
new AnnotationConfigApplicationContext();
ConfigurableEnvironment env = context.getEnvironment();
printSources(env);
System.out.println("-- System properties --");
printMap(env.getSystemProperties());
System.out.println("-- System Env properties --");
printMap(env.getSystemEnvironment());
}
private static void printSources (ConfigurableEnvironment env) {
System.out.println("-- property sources --");
for (PropertySource<?> propertySource : env.getPropertySources()) {
System.out.println("name = " + propertySource.getName() + "\nsource = " + propertySource
.getSource().getClass()+"\n");
}
}
private static void printMap (Map<?, ?> map) {
map.entrySet()
.stream().limit(15)
.forEach(e -> System.out.println(e.getKey() + " = " + e.getValue()));
System.out.println("-------------");
}
}
Output-- property sources --
name = systemProperties
source = class java.util.Properties
name = systemEnvironment
source = class java.util.Collections$UnmodifiableMap
-- System properties --
exec.cleanupDaemonThreads = false
java.runtime.name = Java(TM) SE Runtime Environment
exec.mainClass = com.logicbig.example.DefaultSystemSourcesExample
sun.boot.library.path = D:\programs\java\jdk1.8.0_151\jre\bin
java.vm.version = 25.151-b12
java.vm.vendor = Oracle Corporation
java.vendor.url = http://java.oracle.com/
guice.disable.misplaced.annotation.check = true
path.separator = ;
java.vm.name = Java HotSpot(TM) 64-Bit Server VM
file.encoding.pkg = sun.io
user.country = US
user.script =
sun.java.launcher = SUN_STANDARD
-------------
-- System Env properties --
example-site-projects = D:\project\example-sentence-site
USERDOMAIN_ROAMINGPROFILE = DESKTOP-0E87003
GIT_HOME = D:\programs\Git
PROCESSOR_LEVEL = 6
SESSIONNAME = Console
ALLUSERSPROFILE = C:\ProgramData
PROCESSOR_ARCHITECTURE = AMD64
intellijPath = D:\programs\JetBrains\ideaIC-2021.1.1.win\bin
jvmConfig = \.mvn\jvm.config
PSModulePath = C:\Program Files\WindowsPowerShell\Modules;C:\WINDOWS\system32\WindowsPowerShell\v1.0\Modules
SystemDrive = C:
=ExitCode = 00000001
-------------
As seen in above output, there are two property sources by default, System properties and System Environmental properties. We can add our own property sources as well (next tutorials).
By default, system properties have precedence over environment variables, so if the foo property happens to be set in both places during a call to env.getProperty("foo"), the system property value will 'win' and be returned preferentially over the environment variable. Note that property values will not get merged but rather completely overridden by a preceding entry.
Example ProjectDependencies and Technologies Used: - spring-context 6.1.2 (Spring Context)
Version Compatibility: 3.2.3.RELEASE - 6.1.2 Version compatibilities of spring-context with this example: Versions in green have been tested.
- JDK 17
- Maven 3.8.1
|
