Best Practice for Using Java System Properties

Question

Our code uses a lot of system properties eg, 'java.io.tmpdir', 'user.home', 'user.name' etc. We do not have any constants defined for these anywhere (and neither does java I think) or any other clever thing for dealing with them so they are in plain text littered throughout the code.

String tempFolderPath = System.getProperty("java.io.tmpdir");

How is everyone using system properties?

Answer 1

I would treat this just as any other String constant you have scattered throughout your code and define a constant variable for it. Granted, in this case "java.io.tmpdir" is unlikely to change, but you never know. (I don't mean that Sun might change the meaning of "java.io.tmpdir", or what system property it points to, but that you might change your mind about what system property you need to read.)

If you're only using a particular property within one class, then I'd define the constants right in that class.

private final String TEMPDIR = "java.io.tmpdir";

If you're using the same properties in different classes, you may want to define an static class of your own to hold the constants you use most often.

public final Class Prop {
    public static final String TEMPDIR = "java.io.tmpdir";
    ...
}

Then, everywhere you need to use that constant just call it using

System.getProperty(Prop.TEMPDIR);

Answer 2

SystemUtils provided by Apache Commons Lang package, solves this problem.

SystemUtils has defined constant for most of the system properties, which can be obtained by a lookup, for example:

import org.apache.commons.lang3.SystemUtils;

class Something
{
    public static void main(String[] args){     
        System.out.println(SystemUtils.JAVA_IO_TMPDIR);
    }
}

Probably, that is a cleaner way to do it.

Answer 3

I think that in an object oriented software, you have probably an object (or a method) that have a dependency on a directory where a job has to be done. So, you can put in evidence this dependency on the constructor or the method. After that, if you need a default for that directory and the default come from a system property, you can simply create a factory method or a constructor/method with less parameters passing to the other costrunctor/method a:

new File(System.getProperty("java.io.tmpdir");

You don't need to create a "dependency magnet" only to contain a configuration parameter.

Answer 4

if you are using it in multiple places it might be a good idea to write a class to encapsulate reading the property and maybe other properties.

so maybe something like: Configuration.getTemporaryDirectory()

Answer 5

Since the question title is extremely broad, I'll throw in another good practice you should consider when using system properties. Access to system properties can by denied by the SecurityManager, so you may need to access them through a PrivilegedAction, like this:

String tmpdir = AccessController.doPrivileged(new PrivilegedAction<String>() {
  public String run() {
    return System.getProperty("java.io.tmpdir");
  }
});

Use a privileged action when your code constrains a sensitive action so that it will be safe even if malicious code invokes it.

For example, it would be unsafe to use a privileged action in a method like OutputStream open(File file). Untrusted code could invoke it, and use your code's privileges to write anything, anywhere.

However, if you had a method that saved user preferences for your application to a file you choose, that would probably be safe. A malicious caller can't choose the file location or its contents; those are specified by your code. So, your method can use a privileged action to allow it to be invoked by unprivileged code.

Answer 6

I'd treat these as any other constant, probably with a P_ or PROP_ prefix, and put them in an appropriate constants class.

If you use lots of them, I'd even consider splitting them out to a PropertyNames constants class:

public final class PropertyNames
{
  private PropertyNames()
  {
     // no instantiation
  }

  public static final String P_VAR_DIRECTORY = "org.acme.app.varDir";

  public static final String P_TMP_DIRECTORY = "java.io.tmpDir";
}

Finally, I would seriously considering namespacing the property names themselves, with the standard reverse domain name used for packages. This is just to avoid clashing with third-party properties consumers.

Answer 7

In Java, Strings are immutable, which means the same object in memory space is not overwritten; a new String is created every time. The currently highest voted suggestion is to use a constant:

System.getProperty(Prop.TEMPDIR);

Unfortunately, the constant being used is for the actual property key. That means that every time you make this call, you're going to create a new String object to hold the value. In my opinion, you should make the constant the result of the call itself:

public static final String SYS_PROP_TEMP_DIR = System.getProperty("java.io.tmpdir");