दिलचस्प पोस्ट
मैं कैसे जांचूं अगर कोई C ++ स्ट्रिंग int है? न्यूनतम एपीआई स्तर 14 के साथ ऐप में रोबो फ़ॉन्ट का उपयोग करें तालिकाओं के साथ calc () का उपयोग करना मैं किसी विशिष्ट प्रतिबद्ध के लिए एक github रिपॉजिटरी रोलबैक कैसे कर सकता हूं? Java.awt.Component.getName () और setName () के लिए क्या प्रयोग किया जाता है? आईबी के बिना दाएं तरफ यूआईनेविगेशनबार में 2 बटन कैसे जोड़ सकते हैं? एक ब्रॉडकास्ट रिसीवर सक्षम और अक्षम करें जावा में ऑब्जेक्ट का आकार की गणना करें एंड्रॉइड: आर क्या है? ऐसा क्यों क्रिप्टिक है? किसी नेट वस्तु में JSON डेटा को पार्स करने का सर्वोत्तम तरीका क्या किसी प्राकृतिक भाषा से तिथियों और समय को पार्स करने के लिए कोई अजगर पुस्तकालय है? कोणीय जेएस कस्टम सीमांकक फायरबसे एफसीएम फोर्स ऑन टॉकनफ्रेश () को कॉल करने के लिए मैं नोड। Js का उपयोग करने के लिए JSON को बहुत प्रिंट कैसे कर सकता / सकती हूं? डेल्फी में कौन सी चर का उपयोग किया जाता है?

जावा से पर्यावरण चर कैसे सेट करूं?

जावा से पर्यावरण चर कैसे सेट करूं? मैं देखता हूं कि मैं प्रोसेब्लियलर का इस्तेमाल करते हुए सबप्रोसेस के लिए ऐसा कर सकता हूं। मेरे पास कई उपप्रक्रियाएं शुरू करने के लिए हैं, हालांकि, इसलिए मैं वर्तमान प्रक्रिया के वातावरण को संशोधित नहीं कर पाता हूं और उपप्रापकों को इसे प्राप्त करना चाहिए

एक वातावरण चर को पाने के लिए एक सिस्टम.getenv (स्ट्रिंग) है I मैं System.getenv () के साथ पर्यावरण चर का पूरा सेट का मानचित्र भी प्राप्त कर सकता हूं। लेकिन उस मानचित्र पर बुला देना () को एक असमर्थित अपवाद अपवाद फेंकता है – जाहिरा तौर पर उनका मतलब पर्यावरण के लिए ही पढ़ना है। और कोई सिस्टम नहीं है। Setenv ()

तो, क्या मौजूदा चल रहे प्रक्रिया में पर्यावरण चर सेट करने का कोई तरीका है? यदि हां, तो कैसे? यदि नहीं, तो तर्क क्या है? (क्या यह इसलिए है क्योंकि यह जावा है और इसलिए मुझे अपने पर्यावरण को छूने जैसी गैरकानूनी अप्रचलित चीजों को नहीं करना चाहिए?) और यदि नहीं, तो पर्यावरण के परिवर्तनों को प्रबंधित करने के लिए कोई अच्छा सुझाव जो मुझे कई खिलाओ करने की ज़रूरत हैं subprocesses?

Solutions Collecting From Web of "जावा से पर्यावरण चर कैसे सेट करूं?"

(क्या यह इसलिए है क्योंकि यह जावा है और इसलिए मुझे अपने पर्यावरण को छूने जैसी गैरकानूनी अप्रचलित चीजों को नहीं करना चाहिए?)

मुझे लगता है कि आपने सिर पर कील को मारा है।

बोझ को कम करने का एक संभावित तरीका एक विधि का पता लगाने के लिए होगा

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

और उन्हें शुरू करने से पहले किसी भी ProcessBuilder एस पास।

इसके अलावा, आप शायद पहले से ही यह जानते हैं, लेकिन आप उसी ProcessBuilder साथ एक से अधिक प्रक्रिया शुरू कर सकते हैं इसलिए यदि आपके उपप्रक्रिया एक समान हैं, तो आपको इस सेटअप को और अधिक करने की आवश्यकता नहीं है

परिदृश्यों में उपयोग के लिए जहां आपको यूनिट परीक्षणों के लिए विशिष्ट वातावरण मान सेट करने की आवश्यकता होती है, आपको निम्न उपयोगी हैक मिल सकता है। यह JVM भर में पर्यावरण चर को बदल देगा (ऐसा सुनिश्चित करें कि आप अपने परीक्षण के बाद किसी भी परिवर्तन को रीसेट करें), लेकिन आपके सिस्टम परिवेश में बदलाव नहीं करेंगे।

मुझे पता चला कि एडवर्ड कैम्पबेल और बेनामी द्वारा दो गंदी हैक्स का एक संयोजन सबसे अच्छा है, क्योंकि लिनक्स के तहत काम नहीं करता है, इसलिए कोई भी विंडोज 7 के तहत काम नहीं करता है। इसलिए मुझे एक मल्टीप्लेफ्ट बुराई हैक मिलाने के लिए:

 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); } } } } 

यह एक जादू की तरह काम करता है इन 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); } } } 

एंड्रॉइड पर इंटरफ़ेस Libcore.os के माध्यम से छिपा हुआ एपीआई के रूप में सामने आया है।

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

लिबकोर वर्ग और साथ ही इंटरफ़ेस ओएस सार्वजनिक है। सिर्फ क्लास घोषणापत्र गायब है और लिंकर को दिखाया जाना चाहिए। आवेदन करने के लिए कक्षाओं को जोड़ने की कोई आवश्यकता नहीं है, लेकिन अगर इसमें शामिल है, तो इससे भी चोट नहीं होती है।

 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; } 
 // 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); } 

यह पता चला है कि @ पुसी / @ बेनामी @ एडवर्ड कैंपबेल का समाधान Android पर काम नहीं करता है क्योंकि एंड्रॉइड वास्तव में जावा नहीं है विशेष रूप से, एंड्रॉइड में java.lang.ProcessEnvironment नहीं है। लेकिन एंड्रॉइड में यह आसान हो जाता है, आपको सिर्फ एक जेएनआई कॉल POSIX setenv() :

सी / जेएनआई में:

 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; } 

और जावा में:

 public class Posix { public static native int setenv(String key, String value, boolean overwrite); private void runTest() { Posix.setenv("LD_LIBRARY_PATH", "foo", true); } } 

ऑनलाइन के आसपास पोकिंग, ऐसा लगता है कि जेएनआई के साथ ऐसा करना संभव हो सकता है फिर आपको सी से putenv () को कॉल करना पड़ता है, और आप चाहते हैं (संभवतः) इसे ऐसे तरीके से करना चाहिए जो Windows और UNIX दोनों पर काम किया।

यदि सब कुछ किया जा सकता है, तो जावा के लिए सीधे एक जैकेट में डाल देने के बजाय यह निश्चित रूप से मुश्किल नहीं होगा

किसी अन्य पर्ल-स्पीक मित्र का सुझाव है कि ऐसा इसलिए है क्योंकि पर्यावरण चर प्रोसेस ग्लोबल हैं और जावा अच्छे डिज़ाइन के लिए अच्छे अलगाव के लिए प्रयास कर रहा है।

यह @ पॉल-ब्लेयर के उत्तर का एक संयोजन है जो जावा में परिवर्तित किया गया है जिसमें पॉल ब्लेयर द्वारा उठाए गए कुछ सफाई शामिल हैं और कुछ गलतियां जो पाश के कोड के अंदर होती हैं जो कि एडवर्ड कैंपबेल @

मैं यह नहीं बता सकता कि यह कोड परीक्षण में कितना उपयोग किया जाना चाहिए और यह अत्यंत हैकी है। लेकिन ऐसे मामलों के लिए जहां आपको परीक्षणों में पर्यावरण की स्थापना की आवश्यकता है, वही मुझे जरूरी चाहिए।

इसमें मेरा कुछ मामूली स्पर्श भी शामिल है जो कोड को दोनों विंडोज पर चलने की अनुमति देता है

 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) 

साथ ही साथ सेंटोस चल रहा है

 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) 

कार्यान्वयन:

 /** * 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)); } 

केवल लिनक्स

एकल पर्यावरण चर की स्थापना (एडवर्ड कैम्पबेल द्वारा दिए गए उत्तर के आधार पर):

 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); } } 

उपयोग:

सबसे पहले, विधि को किसी भी वर्ग में रखें, जैसे कि SystemUtil।

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

यदि आप इसके बाद System.getenv("SHELL") , तो आपको "/bin/bash" वापस मिल जाएगा।

ऊपर pushy के जवाब की कोशिश की और यह सबसे अधिक भाग के लिए काम किया। हालांकि, कुछ परिस्थितियों में, मुझे यह अपवाद दिखाई देगा:

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

इस प्रक्रिया को एक बार से अधिक बार कहा जाता है, क्योंकि ProcessEnvironment. के कुछ आंतरिक कक्षाओं के कार्यान्वयन के कारण यह हो जाता है यदि setEnv(..) विधि को एक से अधिक बार कहा जाता है, जब कुंजी को theEnvironment नक्शे से प्राप्त किया जाता है, वे अब स्ट्रिंग हैं (तार के रूप में setEnv(...) के पहले आमंत्रण के द्वारा रखा गया है) नक्शा के सामान्य प्रकार, Variable, डालें Variable, जो कि ProcessEnvironment. की एक निजी आंतरिक श्रेणी है ProcessEnvironment.

एक निश्चित संस्करण (स्कला में), नीचे है। उम्मीद है कि जावा में जारी रखना मुश्किल नहीं है

 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() } } 

अधिकांश लोगों की तरह, जिन्हें यह धागा मिल गया है, मैं कुछ यूनिट परीक्षण लिख रहा था और परीक्षण चलाने के लिए सही स्थिति निर्धारित करने के लिए पर्यावरण चर को संशोधित करने की जरूरत थी। हालांकि, मुझे पाया गया कि सबसे अधिक उत्थान उत्तरों में कुछ समस्याएं थीं और / या बहुत गुप्त या अधिक जटिल थे। उम्मीद है कि यह दूसरों को हल करने के लिए और अधिक तेज़ी से हल करने में मदद करेगा।

सबसे पहले, मुझे आखिर में हबर्ट ग्रिज़कोविक के समाधान को सरलतम पाया गया और यह मेरे लिए काम किया। काश मैं पहली बार उस पर आना चाहता था यह @ एडवर्ड कैम्पबेल के उत्तर पर आधारित है, लेकिन लूप खोज के लिए जटिलता के बिना

हालांकि, मैं @ पुशी के समाधान के साथ शुरू हुआ, जिसने सबसे अधिक उद्धरण प्राप्त किए। यह @ समानार्थी और @ एडवर्ड कैम्पबेल का कॉम्बो है @ पशि दावों दोनों तरीकों की जरूरत है लिनक्स और विंडोज दोनों वातावरणों को कवर करने के लिए मैं ओएस एक्स के तहत चल रहा हूं और पाया है कि दोनों काम (@ एकमानीय दृष्टिकोण के साथ एक बार तय हो गई है) जैसा कि अन्य लोगों ने ध्यान दिया है, यह समाधान ज्यादातर समय काम करता है, लेकिन सभी नहीं।

मुझे लगता है कि अधिकतर भ्रम का स्रोत @ अनाम के समाधान से 'पर्यावरण' क्षेत्र पर काम कर रहा है। प्रक्रिया पर्यावरण संरचना की परिभाषा को देखते हुए, 'पर्यावरण' एक नक्शा नहीं है <स्ट्रिंग, स्ट्रिंग> बल्कि यह एक नक्शा है <वैरिएबल, वैल्यू> नक्शा साफ करना ठीक काम करता है, लेकिन putAll संचालन मानचित्र को एक मानचित्र <स्ट्रिंग, स्ट्रिंग> बनाता है, जो संभवत: समस्याओं का कारण बनता है जब बाद के ऑपरेशन सामान्य एपीआई का उपयोग करते हुए डेटा संरचना पर कार्य करते हैं जो कि मानचित्र <वैरिएबल, वैल्यू> साथ ही, व्यक्तिगत तत्वों को एक्सेस / निकालना एक समस्या है। समाधान 'the पर्यावरण' परोक्ष रूप से 'theUnmodifiableEnvironment' के माध्यम से उपयोग करना है लेकिन चूंकि यह एक प्रकार का अनमोडिफाइअलाइज्म मैप है , इसे अनमोडिडेबलमेप प्रकार के निजी वेरिएबल 'एम' के माध्यम से किया जाना चाहिए। नीचे दिए गए कोड में getModifiableEnvironmentMap2 देखें

मेरे मामले में मुझे अपने परीक्षण के लिए कुछ पर्यावरण चर को हटाने की जरूरत थी (अन्य को अपरिवर्तित होना चाहिए) तब मैं टेस्ट के बाद पर्यावरण चर को उनके पूर्व राज्य में पुनर्स्थापित करना चाहता था। नीचे दिए गए दिनचर्या सीधे आगे करने के लिए करते हैं मैंने ओएस एक्स पर getModifiableEnvironmentMap के दोनों संस्करणों का परीक्षण किया, और दोनों को समान रूप से काम किया यद्यपि इस सूत्र में टिप्पणियों के आधार पर, एक पर्यावरण के आधार पर अन्य की तुलना में बेहतर विकल्प हो सकता है।

नोट: मुझे 'theCaseInsensitiveEnvironmentField' तक पहुंच शामिल नहीं है क्योंकि यह विंडोज विशिष्ट है और मुझे इसका परीक्षण करने का कोई तरीका नहीं था, लेकिन इसे जोड़ने से सीधे आगे होना चाहिए।

 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); } 

आप अपनी शुरुआती जावा प्रक्रिया में -D के साथ पैरामीटर पारित कर सकते हैं:

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