14

I wonder which of the following is a preferred approach?

We can set things up as APP_HOME=/path/to/file (export in .profile or something along those lines) and access it as System.getenv("APP_HOME")

Or, alternatively using properties as -DAPP_HOME=/path/to/file and access it as System.getProperty("APP_HOME")

Now .. either one will make the value available for the application stand point, but is either approach preferred? Why? When?

ruakh
  • 175,680
  • 26
  • 273
  • 307
James Raitsev
  • 92,517
  • 154
  • 335
  • 470
  • 2
    Why would one be preferred over the other? IMO env vars should be overridden by options specified via -D, but other than that, meh. – Dave Newton Dec 24 '12 at 23:51
  • 1
    Well, we have 2 options to do the same thing right? Hence the question – James Raitsev Dec 24 '12 at 23:55
  • Why not use both? Search system properties for the key, and if not there, search the environment. They are not really the same thing, since one requires the value to be set explicitly for the application and the other not. – Nathan Ryan Dec 25 '12 at 00:02
  • 1
    Also, note that getEnv used to be deprecated. If you are using Java 1.3 or 1.4, you should be using only system properties. – Nathan Ryan Dec 25 '12 at 00:04
  • Ok cool. Nathan, please `answer` so i can accept it. – James Raitsev Dec 25 '12 at 00:07
  • System properties can be set only by the process doing the invocation. Environnemnt variables can be set by any parent process, e.g. the login shell making it more accessible for administrators. If you have full control, it most likely doesn't matter which one you use. – Thorbjørn Ravn Andersen Dec 25 '12 at 02:14

4 Answers4

20

The Javadoc for System.getenv(String) addresses this question directly, saying:

System properties and environment variables are both conceptually mappings between names and values. Both mechanisms can be used to pass user-defined information to a Java process. Environment variables have a more global effect, because they are visible to all descendants of the process which defines them, not just the immediate Java subprocess. They can have subtly different semantics, such as case insensitivity, on different operating systems. For these reasons, environment variables are more likely to have unintended side effects. It is best to use system properties where possible. Environment variables should be used when a global effect is desired, or when an external system interface requires an environment variable (such as PATH).

(emphasis mine).

ruakh
  • 175,680
  • 26
  • 273
  • 307
5

If you are using Java 1.3 or 1.4 (and 1.2, IIRC), you should be using system properties, since System.getenv was deprecated. It was reinstated in Java 1.5. The relevant bug report can be found here.

You can use both. Search system properties for the key, and if it's not there, search the environment. This gives you the best of both worlds.

These really aren't the same thing: One requires the value to be set explicitly, and the other not. Also, note that the environment is a convenient place to put some strings for interoperability.

Nathan Ryan
  • 12,893
  • 4
  • 26
  • 37
  • 1
    With the caveat that it's `System.getenv`, not `getEnv`. – Dave Newton Dec 25 '12 at 01:25
  • The method System.getenv() should not be used to access environment variables because not all platforms have support for environment variables. -- Reasoning given by CodePro code analysis tool – Anuj Balan Aug 14 '17 at 18:42
  • @AnujBalan The default system environment should not be relied upon for platform-independent behavior. However, artificial (platform-independent) environments can be created for subprocesses via ProcessBuilder, so a strict prohibition on its use is likely to result in false positives being reported by a tool such as CodePro – Nathan Ryan Aug 16 '17 at 15:36
0

Can't comment yet at the moment, so I will add a couple of points as an answer.

I agree with the javadoc's saying "It is best to use system properties where possible.", also in my own words previous to seeing this page here that the Java system variables are encapsulated inside the JVM. They are not visible to other processes on the host, and thus less coupled with the host system.

In addition, there are multiple interfaces to set the global environment variables, and so it could be a bit tricky to track all the values being used over time.

BJYC
  • 354
  • 2
  • 10
0

One important difference between using Environment Variables (envs) and System properties which should be considered is that the envs could not be changed at runtime/in the running process, BUT System properties could be. Refer to the Javadoc:

https://docs.oracle.com/javase/8/docs/api/java/lang/System.html#setProperties-java.util.Properties-

Dob Riki Tipov
  • 13
  • 3