gh-11065. Set up environment variables using the Maven plugin.

Author: nosan

spring-boot-project/spring-boot-docs/src/main/asciidoc/howto.adoc

@@ -2774,6 +2774,14 @@ See {spring-boot-maven-plugin-site}/examples/run-debug.html[this example] for mo
 details.
 
 
+[[howto-set-env-maven-run]]
+=== Run Spring Boot Application with Environment variables Started with Maven
+To set up the environment variables to a Spring Boot application that was started with Maven, you
+can use the `environmentVariables` property of the {spring-boot-maven-plugin-site}[maven plugin].
+
+See {spring-boot-maven-plugin-site}/examples/run-with-env.html[this example] for more
+details.
+
 
 [[howto-build-an-executable-archive-with-ant]]
 === Build an Executable Archive from Ant without Using `spring-boot-antlib`

spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/main/java/org/springframework/boot/loader/tools/RunProcess.java

@@ -20,6 +20,8 @@
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
 
 /**
  * Utility used to run a process.
@@ -28,6 +30,7 @@
  * @author Dave Syer
  * @author Andy Wilkinson
  * @author Stephane Nicoll
+ * @author Dmytro Nosan
  * @since 1.1.0
  */
 public class RunProcess {
@@ -63,14 +66,19 @@ public RunProcess(File workingDirectory, String... command) {
 	}
 
 	public int run(boolean waitForProcess, String... args) throws IOException {
-		return run(waitForProcess, Arrays.asList(args));
+		return run(waitForProcess, Arrays.asList(args), Collections.emptyMap());
 	}
 
-	protected int run(boolean waitForProcess, Collection<String> args)
+	public int run(boolean waitForProcess, String[] args, Map<String, String> environmentVariables) throws IOException {
+		return run(waitForProcess, Arrays.asList(args), environmentVariables);
+	}
+
+	protected int run(boolean waitForProcess, Collection<String> args, Map<String, String> environmentVariables)
 			throws IOException {
 		ProcessBuilder builder = new ProcessBuilder(this.command);
 		builder.directory(this.workingDirectory);
 		builder.command().addAll(args);
+		builder.environment().putAll(environmentVariables);
 		builder.redirectErrorStream(true);
 		builder.inheritIO();
 		try {

spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/it/run-envargs/pom.xml

@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<groupId>org.springframework.boot.maven.it</groupId>
+	<artifactId>run-envargs</artifactId>
+	<version>0.0.1.BUILD-SNAPSHOT</version>
+	<properties>
+		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+		<maven.compiler.source>@java.version@</maven.compiler.source>
+		<maven.compiler.target>@java.version@</maven.compiler.target>
+	</properties>
+	<build>
+		<plugins>
+			<plugin>
+				<groupId>@project.groupId@</groupId>
+				<artifactId>@project.artifactId@</artifactId>
+				<version>@project.version@</version>
+				<executions>
+					<execution>
+						<phase>package</phase>
+						<goals>
+							<goal>run</goal>
+						</goals>
+						<configuration>
+							<environmentVariables>
+								<ENV1>5000</ENV1>
+								<ENV2>Some Text</ENV2>
+								<ENV3/>
+								<ENV4></ENV4>
+							</environmentVariables>
+						</configuration>
+					</execution>
+				</executions>
+			</plugin>
+		</plugins>
+	</build>
+</project>

spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/it/run-envargs/src/main/java/org/test/SampleApplication.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2012-2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.test;
+
+public class SampleApplication {
+
+
+	public static void main(String[] args) {
+		assertEnvValue("ENV1", "5000");
+		assertEnvValue("ENV2", "Some Text");
+		assertEnvValue("ENV3", "");
+		assertEnvValue("ENV4", "");
+
+		System.out.println("I haz been run");
+
+	}
+
+
+	static void assertEnvValue(String envKey, String expectedValue) {
+		String actual = System.getenv(envKey);
+		if (!expectedValue.equals(actual)) {
+			throw new IllegalStateException("env property [" + envKey + "] mismatch (got [" + actual + "], expected [" + expectedValue + "]");
+		}
+	}
+
+}

spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/it/run-envargs/verify.groovy

@@ -0,0 +1,3 @@
+def file = new File(basedir, "build.log")
+return file.text.contains("I haz been run")
+

spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/main/java/org/springframework/boot/maven/AbstractRunMojo.java

@@ -24,7 +24,9 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 import org.apache.maven.artifact.Artifact;
@@ -46,6 +48,7 @@
  * @author Stephane Nicoll
  * @author David Liu
  * @author Daniel Young
+ * @author Dmytro Nosan
  * @see RunMojo
  * @see StartMojo
  */
@@ -105,6 +108,15 @@ public abstract class AbstractRunMojo extends AbstractDependencyFilterMojo {
 	@Parameter(property = "spring-boot.run.jvmArguments")
 	private String jvmArguments;
 
+	/**
+	 * List of Environment variables that should be associated with the forked process used to run the
+	 * application.
+	 * <p>NOTE: the use of Environment variables means that processes will be started by forking a
+	 * new JVM.
+	 */
+	@Parameter(property = "spring-boot.run.environmentVariables")
+	private Map<String, String> environmentVariables;
+
 	/**
 	 * Arguments that should be passed to the application. On command line use commas to
 	 * separate multiple arguments.
@@ -193,7 +205,7 @@ protected boolean isFork() {
 	 * @see #logDisabledFork()
 	 */
 	protected boolean enableForkByDefault() {
-		return hasAgent() || hasJvmArgs() || hasWorkingDirectorySet();
+		return hasAgent() || hasJvmArgs() || hasEnvVariables() || hasWorkingDirectorySet();
 	}
 
 	private boolean hasAgent() {
@@ -204,6 +216,11 @@ private boolean hasJvmArgs() {
 		return (this.jvmArguments != null && !this.jvmArguments.isEmpty());
 	}
 
+	private boolean hasEnvVariables() {
+		return (this.environmentVariables != null && !this.environmentVariables.isEmpty());
+	}
+
+
 	private boolean hasWorkingDirectorySet() {
 		return this.workingDirectory != null;
 	}
@@ -243,22 +260,27 @@ protected void logDisabledFork() {
 	private void doRunWithForkedJvm(String startClassName)
 			throws MojoExecutionException, MojoFailureException {
 		List<String> args = new ArrayList<>();
+		Map<String, String> envVariables = new LinkedHashMap<>();
 		addAgents(args);
 		addJvmArgs(args);
 		addClasspath(args);
 		args.add(startClassName);
 		addArgs(args);
-		runWithForkedJvm(this.workingDirectory, args);
+		addEnvironmentVariables(envVariables);
+		runWithForkedJvm(this.workingDirectory, args, envVariables);
 	}
 
+
 	/**
 	 * Run with a forked VM, using the specified command line arguments.
 	 * @param workingDirectory the working directory of the forked JVM
 	 * @param args the arguments (JVM arguments and application arguments)
+	 * @param environmentVariables the environment variables;
 	 * @throws MojoExecutionException in case of MOJO execution errors
 	 * @throws MojoFailureException in case of MOJO failures
 	 */
-	protected abstract void runWithForkedJvm(File workingDirectory, List<String> args)
+	protected abstract void runWithForkedJvm(File workingDirectory, List<String> args,
+			Map<String, String> environmentVariables)
 			throws MojoExecutionException, MojoFailureException;
 
 	/**
@@ -281,12 +303,29 @@ protected RunArguments resolveApplicationArguments() {
 		return runArguments;
 	}
 
+
+	/**
+	 * Resolve the environment arguments to use.
+	 *
+	 * @return a {@link EnvVariables} defining the environment arguments
+	 */
+	protected EnvVariables resolveEnvVariables() {
+		return new EnvVariables(this.environmentVariables);
+	}
+
+
 	private void addArgs(List<String> args) {
 		RunArguments applicationArguments = resolveApplicationArguments();
 		Collections.addAll(args, applicationArguments.asArray());
 		logArguments("Application argument(s): ", this.arguments);
 	}
 
+	private void addEnvironmentVariables(Map<String, String> environmentVariables) {
+		EnvVariables envVariables = resolveEnvVariables();
+		environmentVariables.putAll(envVariables.asMap());
+		logArguments("Environment variable(s): ", envVariables.asArray());
+	}
+
 	/**
 	 * Resolve the JVM arguments to use.
 	 * @return a {@link RunArguments} defining the JVM arguments

spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/main/java/org/springframework/boot/maven/EnvVariables.java

@@ -0,0 +1,76 @@
+/*
+ * Copyright 2012-2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.maven;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Helper class for working with Env variables.
+ *
+ * @author Dmytro Nosan
+ */
+class EnvVariables {
+
+	private static final String SPACE = "=";
+	private static final String NO_VALUE = "";
+
+	private final Map<String, String> args;
+
+	EnvVariables(Map<String, String> args) {
+		this.args = getArgs(args);
+	}
+
+	public Map<String, String> asMap() {
+		return Collections.unmodifiableMap(this.args);
+	}
+
+	public String[] asArray() {
+		List<String> args = new ArrayList<>(this.args.size());
+		for (Map.Entry<String, String> arg : this.args.entrySet()) {
+			args.add(arg.getKey() + SPACE + arg.getValue());
+		}
+		return args.toArray(new String[args.size()]);
+	}
+
+
+	private Map<String, String> getArgs(Map<String, String> args) {
+
+		if (args == null || args.isEmpty()) {
+			return Collections.emptyMap();
+		}
+
+		Map<String, String> result = new LinkedHashMap<>();
+		for (Map.Entry<String, String> e : args.entrySet()) {
+			result.put(e.getKey(), getValue(e.getValue()));
+		}
+		
+		return result;
+	}
+
+	private String getValue(String value) {
+		if (value == null || value.trim().isEmpty()) {
+			return NO_VALUE;
+		}
+		return value;
+	}
+
+
+}

spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/main/java/org/springframework/boot/maven/RunMojo.java

@@ -20,6 +20,7 @@
 import java.net.URL;
 import java.net.URLClassLoader;
 import java.util.List;
+import java.util.Map;
 
 import org.apache.maven.plugin.MojoExecutionException;
 import org.apache.maven.plugins.annotations.Execute;
@@ -34,6 +35,7 @@
  * Run an executable archive application.
  *
  * @author Phillip Webb
+ * @author Dmytro Nosan
  * @author Stephane Nicoll
  * @author Andy Wilkinson
  */
@@ -64,14 +66,14 @@ protected void logDisabledFork() {
 	}
 
 	@Override
-	protected void runWithForkedJvm(File workingDirectory, List<String> args)
+	protected void runWithForkedJvm(File workingDirectory, List<String> args, Map<String, String> environmentVariables)
 			throws MojoExecutionException {
 		try {
 			RunProcess runProcess = new RunProcess(workingDirectory,
 					new JavaExecutable().toString());
 			Runtime.getRuntime()
 					.addShutdownHook(new Thread(new RunProcessKiller(runProcess)));
-			int exitCode = runProcess.run(true, args.toArray(new String[0]));
+			int exitCode = runProcess.run(true, args.toArray(new String[0]), environmentVariables);
 			if (exitCode == 0 || exitCode == EXIT_CODE_SIGINT) {
 				return;
 			}