Java - best practice for creating package-wide or global variables

Question

What is the standard approach/best practice to creating variables that are program- or package-wide in Java?

I want to set up some global variables that are accessible by multiple classes. Examples of these global variables would be things like a boolean flag testModeOn, a language setting, current local server, time display format, etc. According to some other questions (namely this one) there aren't any global variables, but there are some work-arounds using interfaces (not recommended?) or classes. Since the original poster didn't explain their situation, they got nearly every answer under the sun and I want to ask specifically for program configuration variables.

Is it better to create a class/package/interface and then import it into my working class/package? Is there anything I should be aware of when trying to implement these variables using a separate class or interface? Is there any other way to fudge package-level variables since Java apparently doesn't do this natively?

NOTE: These variables would probably not change except when the program is re-compiled.

Answer 1

If you're talking about constants, then they should be declared as static final fields in a class (never in an interface, according to Joshua Bloch).

If you're talking about settings which can change on the fly, then these could be either static fields in a class, or you could create a ConfigHandler class to manage the setting and fetching of configurable values.

Using class fields for mutable values might lead to concurrency problems, so if your application is multi-threaded it might be better to create a ConfigHandler class which manages concurrent access carefully and provides synchronized methods to avoid problems.

Answer 2

In my opinion, the best approach to passing anything into your classes is using dependency injection. This would eliminate your need for Singletons, static constants and the likes.

Depending on which DI you favor, here are some link solutions to the problem you describe:

• CDI
• Spring
• Guice

Answer 3

Create a Bean class if multiple variables are required to be used in different classes. Best practice is to create a private variable with its getters and setters.

public class ListBean implements Serializable
{
    private boolean testModeOn;
    public boolean getTestModeOn()
    { 
       return testModeOn;
    }
    public setTestModeOn(boolean testModeOn)
    {
        this.testModeOn = testModeOn;
    }

Answer 4

In general there are so many ways to do it wrong regarding this topic.

The simple way is to use a Singelton. This is not an option - Singelton is an Anti-Pattern. http://c2.com/cgi/wiki?SingletonsAreEvil

So what is else there? An Interface with public static final variables? Not an option - Thats simply not the use case of an interface: https://stackoverflow.com/a/2659740/1248724

so what is else there? The answer is:

What I prefer is the spring boot way (e.g. Dependency Injection) Here an code example which is obviously Spring.

import org.springframework.stereotype.*
import org.springframework.beans.factory.annotation.*
@Component
public class MyBean {
 @Value("${name}")
 private String name;
 // ...
}

If you are using some similar Framework such things could be easy archived.

If that is somehow not possible in your environment I had to code something like this:

public final class Configuration {

private Configuration() {
    // make sure there is no instance of this class
}

    public static final MySetting<DateFormat>   setting = new SampleProperty();

    public interface MySetting<T> {
        T get();
    }

    private static final class SampleProperty implements MySetting<DateFormat> {

        @Override
        public DateFormat get() {
            return new SimpleDateFormat("...");
        }

    }

    // other inner classes that implement the MySetting interface
}

public static void main(final String[] args) {
     Configuration.setting.get();
}

Benefits: - You can validate your properties how ever you want. - You can work with the java security manager if you like to

Downsides: - You may have to maintain a bunch of code (this should be easier with lambda expressions) - Not that great as the way spring offers here for example.

A very similar approach I just found: https://stackoverflow.com/a/3931399/1248724