Wie setze ich Umgebungsvariablen von Java aus? Ich sehe, dass ich dies für Unterprozesse mit tun kann ProcessBuilder. Ich muss jedoch mehrere Unterprozesse starten, daher möchte ich lieber die Umgebung des aktuellen Prozesses ändern und die Unterprozesse diese erben lassen.

Es gibt eine System.getenv(String), um eine einzelne Umgebungsvariable zu erhalten. Ich kann auch einen Mapvollständigen Satz von Umgebungsvariablen mit abrufen System.getenv(). Aber, ruft put()auf , dass Mapwirft ein UnsupportedOperationException- offenbar bedeuten sie für die Umwelt nur gelesen werden. Und es gibt keine System.setenv().

Gibt es also eine Möglichkeit, Umgebungsvariablen im aktuell ausgeführten Prozess festzulegen? Wenn das so ist, wie? Wenn nicht, was ist der Grund? (Liegt es daran, dass dies Java ist und ich daher keine bösen, nicht portierbaren, veralteten Dinge wie das Berühren meiner Umgebung tun sollte?) Und wenn nicht, gibt es gute Vorschläge für die Verwaltung der Änderungen der Umgebungsvariablen, die ich mehreren zuführen muss Unterprozesse?

(Liegt es daran, dass dies Java ist und ich deshalb keine bösen, nicht portierbaren, veralteten Dinge tun sollte, wie meine Umgebung zu berühren?)

Ich denke, Sie haben den Nagel auf den Kopf getroffen.

Ein möglicher Weg, um die Belastung zu verringern, wäre das Herausrechnen einer Methode

void setUpEnvironment(ProcessBuilder builder) {
    Map<String, String> env = builder.environment();
    // blah blah
}

und führen Sie alle ProcessBuilders durch, bevor Sie sie starten.

Wahrscheinlich wissen Sie das auch schon, aber Sie können mehr als einen Prozess mit demselben starten ProcessBuilder. Wenn Ihre Unterprozesse identisch sind, müssen Sie dieses Setup nicht immer wieder durchführen.

Für die Verwendung in Szenarien, in denen Sie bestimmte Umgebungswerte für Komponententests festlegen müssen, ist der folgende Hack möglicherweise hilfreich. Dadurch werden die Umgebungsvariablen in der gesamten JVM geändert (stellen Sie daher sicher, dass Sie alle Änderungen nach dem Test zurücksetzen), Ihre Systemumgebung wird jedoch nicht geändert.

Ich fand heraus, dass eine Kombination der beiden schmutzigen Hacks von Edward Campbell und anonym am besten funktioniert, da einer unter Linux nicht funktioniert, einer unter Windows 7 nicht. Um einen bösen Hack mit mehreren Plattformen zu erhalten, habe ich sie kombiniert:

protected static void setEnv(Map<String, String> newenv) throws Exception {
  try {
    Class<?> processEnvironmentClass = Class.forName("java.lang.ProcessEnvironment");
    Field theEnvironmentField = processEnvironmentClass.getDeclaredField("theEnvironment");
    theEnvironmentField.setAccessible(true);
    Map<String, String> env = (Map<String, String>) theEnvironmentField.get(null);
    env.putAll(newenv);
    Field theCaseInsensitiveEnvironmentField = processEnvironmentClass.getDeclaredField("theCaseInsensitiveEnvironment");
    theCaseInsensitiveEnvironmentField.setAccessible(true);
    Map<String, String> cienv = (Map<String, String>)     theCaseInsensitiveEnvironmentField.get(null);
    cienv.putAll(newenv);
  } catch (NoSuchFieldException e) {
    Class[] classes = Collections.class.getDeclaredClasses();
    Map<String, String> env = System.getenv();
    for(Class cl : classes) {
      if("java.util.Collections$UnmodifiableMap".equals(cl.getName())) {
        Field field = cl.getDeclaredField("m");
        field.setAccessible(true);
        Object obj = field.get(env);
        Map<String, String> map = (Map<String, String>) obj;
        map.clear();
        map.putAll(newenv);
      }
    }
  }
}

Das funktioniert wie ein Zauber. Volle Credits an die beiden Autoren dieser Hacks.

public static void set(Map<String, String> newenv) throws Exception {
    Class[] classes = Collections.class.getDeclaredClasses();
    Map<String, String> env = System.getenv();
    for(Class cl : classes) {
        if("java.util.Collections$UnmodifiableMap".equals(cl.getName())) {
            Field field = cl.getDeclaredField("m");
            field.setAccessible(true);
            Object obj = field.get(env);
            Map<String, String> map = (Map<String, String>) obj;
            map.clear();
            map.putAll(newenv);
        }
    }
}

Oder um eine einzelne Variable hinzuzufügen / zu aktualisieren und die Schleife gemäß dem Vorschlag von thejoshwolfe zu entfernen.

@SuppressWarnings({ "unchecked" })
  public static void updateEnv(String name, String val) throws ReflectiveOperationException {
    Map<String, String> env = System.getenv();
    Field field = env.getClass().getDeclaredField("m");
    field.setAccessible(true);
    ((Map<String, String>) field.get(env)).put(name, val);
  }

// this is a dirty hack - but should be ok for a unittest.
private void setNewEnvironmentHack(Map<String, String> newenv) throws Exception
{
  Class<?> processEnvironmentClass = Class.forName("java.lang.ProcessEnvironment");
  Field theEnvironmentField = processEnvironmentClass.getDeclaredField("theEnvironment");
  theEnvironmentField.setAccessible(true);
  Map<String, String> env = (Map<String, String>) theEnvironmentField.get(null);
  env.clear();
  env.putAll(newenv);
  Field theCaseInsensitiveEnvironmentField = processEnvironmentClass.getDeclaredField("theCaseInsensitiveEnvironment");
  theCaseInsensitiveEnvironmentField.setAccessible(true);
  Map<String, String> cienv = (Map<String, String>) theCaseInsensitiveEnvironmentField.get(null);
  cienv.clear();
  cienv.putAll(newenv);
}

Unter Android wird die Benutzeroberfläche über Libcore.os als eine Art versteckte API verfügbar gemacht.

Libcore.os.setenv("VAR", "value", bOverwrite);
Libcore.os.getenv("VAR"));

Die Libcore-Klasse sowie das Schnittstellenbetriebssystem sind öffentlich. Nur die Klassendeklaration fehlt und muss dem Linker angezeigt werden. Es ist nicht erforderlich, die Klassen zur Anwendung hinzuzufügen, aber es tut auch nicht weh, wenn sie enthalten ist.

package libcore.io;

public final class Libcore {
    private Libcore() { }

    public static Os os;
}

package libcore.io;

public interface Os {
    public String getenv(String name);
    public void setenv(String name, String value, boolean overwrite) throws ErrnoException;
}

Nur Linux

Festlegen einzelner Umgebungsvariablen (basierend auf der Antwort von Edward Campbell):

public static void setEnv(String key, String value) {
    try {
        Map<String, String> env = System.getenv();
        Class<?> cl = env.getClass();
        Field field = cl.getDeclaredField("m");
        field.setAccessible(true);
        Map<String, String> writableEnv = (Map<String, String>) field.get(env);
        writableEnv.put(key, value);
    } catch (Exception e) {
        throw new IllegalStateException("Failed to set environment variable", e);
    }
}

Verwendungszweck:

Fügen Sie die Methode zunächst in eine beliebige Klasse ein, z. B. SystemUtil. Dann nenne es statisch:

SystemUtil.setEnv("SHELL", "/bin/bash");

Wenn Sie danach anrufen System.getenv("SHELL"), werden Sie "/bin/bash"zurückkommen.

Dies ist eine Kombination aus der in Java konvertierten Antwort von @ paul-blair, die einige Bereinigungen enthält, auf die paul blair hingewiesen hat, und einige Fehler, die in @pushys Code enthalten zu sein scheinen, der aus @Edward Campbell besteht und anonym ist.

Ich kann nicht betonen, wie oft dieser Code NUR zum Testen verwendet werden sollte und ist extrem hackig. Aber für Fälle, in denen Sie die Umgebung in Tests einrichten müssen, ist es genau das, was ich brauchte.

Dies beinhaltet auch einige kleinere Details von mir, die es dem Code ermöglichen, unter beiden Windows-Betriebssystemen zu funktionieren

java version "1.8.0_92"
Java(TM) SE Runtime Environment (build 1.8.0_92-b14)
Java HotSpot(TM) 64-Bit Server VM (build 25.92-b14, mixed mode)

sowie Centos laufen weiter

openjdk version "1.8.0_91"
OpenJDK Runtime Environment (build 1.8.0_91-b14)
OpenJDK 64-Bit Server VM (build 25.91-b14, mixed mode)

Die Umsetzung:

/**
 * Sets an environment variable FOR THE CURRENT RUN OF THE JVM
 * Does not actually modify the system's environment variables,
 *  but rather only the copy of the variables that java has taken,
 *  and hence should only be used for testing purposes!
 * @param key The Name of the variable to set
 * @param value The value of the variable to set
 */
@SuppressWarnings("unchecked")
public static <K,V> void setenv(final String key, final String value) {
    try {
        /// we obtain the actual environment
        final Class<?> processEnvironmentClass = Class.forName("java.lang.ProcessEnvironment");
        final Field theEnvironmentField = processEnvironmentClass.getDeclaredField("theEnvironment");
        final boolean environmentAccessibility = theEnvironmentField.isAccessible();
        theEnvironmentField.setAccessible(true);

        final Map<K,V> env = (Map<K, V>) theEnvironmentField.get(null);

        if (SystemUtils.IS_OS_WINDOWS) {
            // This is all that is needed on windows running java jdk 1.8.0_92
            if (value == null) {
                env.remove(key);
            } else {
                env.put((K) key, (V) value);
            }
        } else {
            // This is triggered to work on openjdk 1.8.0_91
            // The ProcessEnvironment$Variable is the key of the map
            final Class<K> variableClass = (Class<K>) Class.forName("java.lang.ProcessEnvironment$Variable");
            final Method convertToVariable = variableClass.getMethod("valueOf", String.class);
            final boolean conversionVariableAccessibility = convertToVariable.isAccessible();
            convertToVariable.setAccessible(true);

            // The ProcessEnvironment$Value is the value fo the map
            final Class<V> valueClass = (Class<V>) Class.forName("java.lang.ProcessEnvironment$Value");
            final Method convertToValue = valueClass.getMethod("valueOf", String.class);
            final boolean conversionValueAccessibility = convertToValue.isAccessible();
            convertToValue.setAccessible(true);

            if (value == null) {
                env.remove(convertToVariable.invoke(null, key));
            } else {
                // we place the new value inside the map after conversion so as to
                // avoid class cast exceptions when rerunning this code
                env.put((K) convertToVariable.invoke(null, key), (V) convertToValue.invoke(null, value));

                // reset accessibility to what they were
                convertToValue.setAccessible(conversionValueAccessibility);
                convertToVariable.setAccessible(conversionVariableAccessibility);
            }
        }
        // reset environment accessibility
        theEnvironmentField.setAccessible(environmentAccessibility);

        // we apply the same to the case insensitive environment
        final Field theCaseInsensitiveEnvironmentField = processEnvironmentClass.getDeclaredField("theCaseInsensitiveEnvironment");
        final boolean insensitiveAccessibility = theCaseInsensitiveEnvironmentField.isAccessible();
        theCaseInsensitiveEnvironmentField.setAccessible(true);
        // Not entirely sure if this needs to be casted to ProcessEnvironment$Variable and $Value as well
        final Map<String, String> cienv = (Map<String, String>) theCaseInsensitiveEnvironmentField.get(null);
        if (value == null) {
            // remove if null
            cienv.remove(key);
        } else {
            cienv.put(key, value);
        }
        theCaseInsensitiveEnvironmentField.setAccessible(insensitiveAccessibility);
    } catch (final ClassNotFoundException | NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
        throw new IllegalStateException("Failed setting environment variable <"+key+"> to <"+value+">", e);
    } catch (final NoSuchFieldException e) {
        // we could not find theEnvironment
        final Map<String, String> env = System.getenv();
        Stream.of(Collections.class.getDeclaredClasses())
                // obtain the declared classes of type $UnmodifiableMap
                .filter(c1 -> "java.util.Collections$UnmodifiableMap".equals(c1.getName()))
                .map(c1 -> {
                    try {
                        return c1.getDeclaredField("m");
                    } catch (final NoSuchFieldException e1) {
                        throw new IllegalStateException("Failed setting environment variable <"+key+"> to <"+value+"> when locating in-class memory map of environment", e1);
                    }
                })
                .forEach(field -> {
                    try {
                        final boolean fieldAccessibility = field.isAccessible();
                        field.setAccessible(true);
                        // we obtain the environment
                        final Map<String, String> map = (Map<String, String>) field.get(env);
                        if (value == null) {
                            // remove if null
                            map.remove(key);
                        } else {
                            map.put(key, value);
                        }
                        // reset accessibility
                        field.setAccessible(fieldAccessibility);
                    } catch (final ConcurrentModificationException e1) {
                        // This may happen if we keep backups of the environment before calling this method
                        // as the map that we kept as a backup may be picked up inside this block.
                        // So we simply skip this attempt and continue adjusting the other maps
                        // To avoid this one should always keep individual keys/value backups not the entire map
                        LOGGER.info("Attempted to modify source map: "+field.getDeclaringClass()+"#"+field.getName(), e1);
                    } catch (final IllegalAccessException e1) {
                        throw new IllegalStateException("Failed setting environment variable <"+key+"> to <"+value+">. Unable to access field!", e1);
                    }
                });
    }
    LOGGER.info("Set environment variable <"+key+"> to <"+value+">. Sanity Check: "+System.getenv(key));
}

Es stellt sich heraus, dass die Lösung von @ pushy / @ anonym / @ Edward Campbell unter Android nicht funktioniert, da Android nicht wirklich Java ist. Insbesondere hat Android überhaupt nicht java.lang.ProcessEnvironment. In Android ist dies jedoch einfacher. Sie müssen lediglich einen JNI-Aufruf an POSIX sendensetenv() :

In C / JNI:

JNIEXPORT jint JNICALL Java_com_example_posixtest_Posix_setenv
  (JNIEnv* env, jclass clazz, jstring key, jstring value, jboolean overwrite)
{
    char* k = (char *) (*env)->GetStringUTFChars(env, key, NULL);
    char* v = (char *) (*env)->GetStringUTFChars(env, value, NULL);
    int err = setenv(k, v, overwrite);
    (*env)->ReleaseStringUTFChars(env, key, k);
    (*env)->ReleaseStringUTFChars(env, value, v);
    return err;
}

Und in Java:

public class Posix {

    public static native int setenv(String key, String value, boolean overwrite);

    private void runTest() {
        Posix.setenv("LD_LIBRARY_PATH", "foo", true);
    }
}

Wie die meisten Leute, die diesen Thread gefunden haben, habe ich einige Komponententests geschrieben und musste die Umgebungsvariablen ändern, um die richtigen Bedingungen für die Ausführung des Tests festzulegen. Ich fand jedoch, dass die am besten bewerteten Antworten einige Probleme hatten und / oder sehr kryptisch oder übermäßig kompliziert waren. Hoffentlich hilft dies anderen, die Lösung schneller zu finden.

Als erstes fand ich die Lösung von @Hubert Grzeskowiak am einfachsten und sie funktionierte für mich. Ich wünschte, ich wäre zuerst dazu gekommen. Es basiert auf der Antwort von @Edward Campbell, ohne jedoch die Suche nach Schleifen zu erschweren.

Ich habe jedoch mit der Lösung von @ pushy begonnen, die die meisten positiven Stimmen erhielt. Es ist eine Kombination aus @anonymous und @Edward Campbell's. @pushy behauptet, dass beide Ansätze erforderlich sind, um sowohl Linux- als auch Windows-Umgebungen abzudecken. Ich laufe unter OS X und stelle fest, dass beide funktionieren (sobald ein Problem mit dem @ anonymous-Ansatz behoben ist). Wie andere angemerkt haben, funktioniert diese Lösung die meiste Zeit, aber nicht alle.

Ich denke, die Ursache für den größten Teil der Verwirrung liegt in der Lösung von @onymous, die im Feld "theEnvironment" ausgeführt wird. Bei der Definition der ProcessEnvironment Struktur ist 'theEnvironment' keine Map <String, String>, sondern eine Map <Variable, Value>. Das Löschen der Map funktioniert einwandfrei, aber die putAll-Operation erstellt die Map neu als Map <String, String>, was möglicherweise zu Problemen führt, wenn nachfolgende Operationen die Datenstruktur mit der normalen API bearbeiten, die Map <Variable, Wert> erwartet. Auch der Zugriff auf / das Entfernen einzelner Elemente ist ein Problem. Die Lösung besteht darin, indirekt über 'die nicht veränderbare Umgebung' auf 'theEnvironment' zuzugreifen. Da dies aber ein Typ UnmodizableMap ist muss der Zugriff über die private Variable 'm' vom Typ UnmodizableMap erfolgen. Siehe getModutableEnvironmentMap2 im folgenden Code.

In meinem Fall musste ich einige der Umgebungsvariablen für meinen Test entfernen (die anderen sollten unverändert bleiben). Dann wollte ich die Umgebungsvariablen nach dem Test auf ihren vorherigen Zustand zurücksetzen. Die folgenden Routinen machen dies einfach. Ich habe beide Versionen von getModutableEnvironmentMap unter OS X getestet und beide funktionieren gleichwertig. Obwohl dies auf Kommentaren in diesem Thread basiert, ist je nach Umgebung möglicherweise eine bessere Wahl als die andere.

Hinweis: Ich habe keinen Zugriff auf das 'theCaseInsensitiveEnvironmentField' hinzugefügt, da dies Windows-spezifisch zu sein scheint und ich keine Möglichkeit hatte, es zu testen, aber das Hinzufügen sollte einfach sein.

private Map<String, String> getModifiableEnvironmentMap() {
    try {
        Map<String,String> unmodifiableEnv = System.getenv();
        Class<?> cl = unmodifiableEnv.getClass();
        Field field = cl.getDeclaredField("m");
        field.setAccessible(true);
        Map<String,String> modifiableEnv = (Map<String,String>) field.get(unmodifiableEnv);
        return modifiableEnv;
    } catch(Exception e) {
        throw new RuntimeException("Unable to access writable environment variable map.");
    }
}

private Map<String, String> getModifiableEnvironmentMap2() {
    try {
        Class<?> processEnvironmentClass = Class.forName("java.lang.ProcessEnvironment");
        Field theUnmodifiableEnvironmentField = processEnvironmentClass.getDeclaredField("theUnmodifiableEnvironment");
        theUnmodifiableEnvironmentField.setAccessible(true);
        Map<String,String> theUnmodifiableEnvironment = (Map<String,String>)theUnmodifiableEnvironmentField.get(null);

        Class<?> theUnmodifiableEnvironmentClass = theUnmodifiableEnvironment.getClass();
        Field theModifiableEnvField = theUnmodifiableEnvironmentClass.getDeclaredField("m");
        theModifiableEnvField.setAccessible(true);
        Map<String,String> modifiableEnv = (Map<String,String>) theModifiableEnvField.get(theUnmodifiableEnvironment);
        return modifiableEnv;
    } catch(Exception e) {
        throw new RuntimeException("Unable to access writable environment variable map.");
    }
}

private Map<String, String> clearEnvironmentVars(String[] keys) {

    Map<String,String> modifiableEnv = getModifiableEnvironmentMap();

    HashMap<String, String> savedVals = new HashMap<String, String>();

    for(String k : keys) {
        String val = modifiableEnv.remove(k);
        if (val != null) { savedVals.put(k, val); }
    }
    return savedVals;
}

private void setEnvironmentVars(Map<String, String> varMap) {
    getModifiableEnvironmentMap().putAll(varMap);   
}

@Test
public void myTest() {
    String[] keys = { "key1", "key2", "key3" };
    Map<String, String> savedVars = clearEnvironmentVars(keys);

    // do test

    setEnvironmentVars(savedVars);
}

Wenn Sie online stöbern, scheint es möglich zu sein, dies mit JNI zu tun. Sie müssten dann putenv () von C aus aufrufen, und Sie müssten dies (vermutlich) auf eine Weise tun, die sowohl unter Windows als auch unter UNIX funktioniert.

Wenn all das getan werden kann, wäre es für Java selbst sicherlich nicht zu schwierig, dies zu unterstützen, anstatt mich in eine Zwangsjacke zu stecken.

Ein Perl sprechender Freund an anderer Stelle schlägt vor, dass dies darauf zurückzuführen ist, dass Umgebungsvariablen prozessglobal sind und Java eine gute Isolation für ein gutes Design anstrebt.

Versuchte Pushys Antwort oben und es funktionierte größtenteils. Unter bestimmten Umständen würde ich jedoch diese Ausnahme sehen:

java.lang.String cannot be cast to java.lang.ProcessEnvironment$Variable

Dies stellt sich heraus, wenn die Methode aufgrund der Implementierung bestimmter innerer Klassen von mehr als einmal aufgerufen wurde. ProcessEnvironment.Wenn die setEnv(..)Methode mehr als einmal aufgerufen wird und die Schlüssel aus der theEnvironmentMap abgerufen werden , handelt es sich nun um Zeichenfolgen (die eingegeben wurden) als Zeichenfolgen beim ersten Aufruf von setEnv(...)) und kann nicht in den generischen Typ der Karte umgewandelt werden, Variable,der eine private innere Klasse von istProcessEnvironment.

Eine feste Version (in Scala) finden Sie weiter unten. Hoffentlich ist es nicht allzu schwierig, auf Java zu übertragen.

def setEnv(newenv: java.util.Map[String, String]): Unit = {
  try {
    val processEnvironmentClass = JavaClass.forName("java.lang.ProcessEnvironment")
    val theEnvironmentField = processEnvironmentClass.getDeclaredField("theEnvironment")
    theEnvironmentField.setAccessible(true)

    val variableClass = JavaClass.forName("java.lang.ProcessEnvironment$Variable")
    val convertToVariable = variableClass.getMethod("valueOf", classOf[java.lang.String])
    convertToVariable.setAccessible(true)

    val valueClass = JavaClass.forName("java.lang.ProcessEnvironment$Value")
    val convertToValue = valueClass.getMethod("valueOf", classOf[java.lang.String])
    convertToValue.setAccessible(true)

    val sampleVariable = convertToVariable.invoke(null, "")
    val sampleValue = convertToValue.invoke(null, "")
    val env = theEnvironmentField.get(null).asInstanceOf[java.util.Map[sampleVariable.type, sampleValue.type]]
    newenv.foreach { case (k, v) => {
        val variable = convertToVariable.invoke(null, k).asInstanceOf[sampleVariable.type]
        val value = convertToValue.invoke(null, v).asInstanceOf[sampleValue.type]
        env.put(variable, value)
      }
    }

    val theCaseInsensitiveEnvironmentField = processEnvironmentClass.getDeclaredField("theCaseInsensitiveEnvironment")
    theCaseInsensitiveEnvironmentField.setAccessible(true)
    val cienv = theCaseInsensitiveEnvironmentField.get(null).asInstanceOf[java.util.Map[String, String]]
    cienv.putAll(newenv);
  }
  catch {
    case e : NoSuchFieldException => {
      try {
        val classes = classOf[java.util.Collections].getDeclaredClasses
        val env = System.getenv()
        classes foreach (cl => {
          if("java.util.Collections$UnmodifiableMap" == cl.getName) {
            val field = cl.getDeclaredField("m")
            field.setAccessible(true)
            val map = field.get(env).asInstanceOf[java.util.Map[String, String]]
            // map.clear() // Not sure why this was in the code. It means we need to set all required environment variables.
            map.putAll(newenv)
          }
        })
      } catch {
        case e2: Exception => e2.printStackTrace()
      }
    }
    case e1: Exception => e1.printStackTrace()
  }
}

Dies ist die böse Kotlin-Version der bösen Antwort von @ pushy =)

@Suppress("UNCHECKED_CAST")
@Throws(Exception::class)
fun setEnv(newenv: Map<String, String>) {
    try {
        val processEnvironmentClass = Class.forName("java.lang.ProcessEnvironment")
        val theEnvironmentField = processEnvironmentClass.getDeclaredField("theEnvironment")
        theEnvironmentField.isAccessible = true
        val env = theEnvironmentField.get(null) as MutableMap<String, String>
        env.putAll(newenv)
        val theCaseInsensitiveEnvironmentField = processEnvironmentClass.getDeclaredField("theCaseInsensitiveEnvironment")
        theCaseInsensitiveEnvironmentField.isAccessible = true
        val cienv = theCaseInsensitiveEnvironmentField.get(null) as MutableMap<String, String>
        cienv.putAll(newenv)
    } catch (e: NoSuchFieldException) {
        val classes = Collections::class.java.getDeclaredClasses()
        val env = System.getenv()
        for (cl in classes) {
            if ("java.util.Collections\$UnmodifiableMap" == cl.getName()) {
                val field = cl.getDeclaredField("m")
                field.setAccessible(true)
                val obj = field.get(env)
                val map = obj as MutableMap<String, String>
                map.clear()
                map.putAll(newenv)
            }
        }
    }

Es funktioniert zumindest in macOS Mojave.

Wenn Sie mit SpringBoot arbeiten, können Sie die Angabe der Umgebungsvariablen in der folgenden Eigenschaft hinzufügen:

was.app.config.properties.toSystemProperties

jythonVariante basierend auf der Antwort von @ pushy , funktioniert unter Windows.

def set_env(newenv):
    from java.lang import Class
    process_environment = Class.forName("java.lang.ProcessEnvironment")
    environment_field =  process_environment.getDeclaredField("theEnvironment")
    environment_field.setAccessible(True)
    env = environment_field.get(None)
    env.putAll(newenv)
    invariant_environment_field = process_environment.getDeclaredField("theCaseInsensitiveEnvironment");
    invariant_environment_field.setAccessible(True)
    invevn = invariant_environment_field.get(None)
    invevn.putAll(newenv)

Verwendungszweck:

old_environ = dict(os.environ)
old_environ['EPM_ORACLE_HOME'] = r"E:\Oracle\Middleware\EPMSystem11R1"
set_env(old_environ)

Tim Ryans Antwort hat bei mir funktioniert ... aber ich wollte sie für Groovy (zum Beispiel Spock-Kontext) und simplissimo:

import java.lang.reflect.Field

def getModifiableEnvironmentMap() {
    def unmodifiableEnv = System.getenv()
    Class cl = unmodifiableEnv.getClass()
    Field field = cl.getDeclaredField("m")
    field.accessible = true
    field.get(unmodifiableEnv)
}

def clearEnvironmentVars( def keys ) {
    def savedVals = [:]
    keys.each{ key ->
        String val = modifiableEnvironmentMap.remove(key)
        // thinking about it, I'm not sure why we need this test for null
        // but haven't yet done any experiments
        if( val != null ) {
            savedVals.put( key, val )
        }
    }
    savedVals
}

def setEnvironmentVars(Map varMap) {
    modifiableEnvironmentMap.putAll(varMap)
}

// pretend existing Env Var doesn't exist
def PATHVal1 = System.env.PATH
println "PATH val1 |$PATHVal1|"
String[] keys = ["PATH", "key2", "key3"]
def savedVars = clearEnvironmentVars(keys)
def PATHVal2 = System.env.PATH
println "PATH val2 |$PATHVal2|"

// return to reality
setEnvironmentVars(savedVars)
def PATHVal3 = System.env.PATH
println "PATH val3 |$PATHVal3|"
println "System.env |$System.env|"

// pretend a non-existent Env Var exists
setEnvironmentVars( [ 'key4' : 'key4Val' ])
println "key4 val |$System.env.key4|"

In einer Version in Kotlin habe ich in diesem Algorithmus einen Dekorator erstellt, mit dem Sie Variablen festlegen und aus der Umgebung abrufen können.

import java.util.Collections
import kotlin.reflect.KProperty
​
class EnvironmentDelegate {
    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        return System.getenv(property.name) ?: "-"
    }
​
    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
        val key = property.name
​
        val classes: Array<Class<*>> = Collections::class.java.declaredClasses
        val env = System.getenv()
​
        val cl = classes.first { "java.util.Collections\$UnmodifiableMap" == it.name }
​
        val field = cl.getDeclaredField("m")
        field.isAccessible = true
        val obj = field[env]
        val map = obj as MutableMap<String, String>
        map.putAll(mapOf(key to value))
    }
}
​
class KnownProperties {
    var JAVA_HOME: String by EnvironmentDelegate()
    var sample: String by EnvironmentDelegate()
}
​
fun main() {
    val knowProps = KnownProperties()
    knowProps.sample = "2"
​
    println("Java Home: ${knowProps.JAVA_HOME}")
    println("Sample: ${knowProps.sample}")
}

Kotlin-Implementierung, die ich kürzlich basierend auf Edwards Antwort vorgenommen habe:

fun setEnv(newEnv: Map<String, String>) {
    val unmodifiableMapClass = Collections.unmodifiableMap<Any, Any>(mapOf()).javaClass
    with(unmodifiableMapClass.getDeclaredField("m")) {
        isAccessible = true
        @Suppress("UNCHECKED_CAST")
        get(System.getenv()) as MutableMap<String, String>
    }.apply {
        clear()
        putAll(newEnv)
    }
}

Sie können Parameter mit -D an Ihren anfänglichen Java-Prozess übergeben:

java -cp <classpath> -Dkey1=value -Dkey2=value ...