Singleton with Arguments in Java Again

Question

First, I have to admit my problem is similar to Singleton with Arguments in Java

I read it, but the solution doesn't work for me. I know the factory pattern is the best solution to that problem.

Here is my problem. I create a "singleton" class to provide some common function, for example get a global configuration parameter. This class need a handler to access the system resources, for example read the configuration file. Cause this class just act as a lib, the handler must pass in from outside, and the Handler is a system class.

So, I write my code in this way:

public class SingletonGlobalParameters {
    private static final SingletonGlobalParameters instance = new SingletonGlobalParameters ();

    private boolean initial = false;

    private String aParameter = null;

    private SingletonGlobalParameters () { }

    public static SingletonGlobalParameters getInstance() {
            if (initial == false) {
                throw exception...
            }
            return instance;
    }

    public void init(Handler h) {
        if (initial == false) {
            Handler fileHandler = h;
            aParameter = fileHandler.read(); // something like this
            initial = true;
        }
    }

    public int getParameter() {
        return aParameter;
    }
}

I remove synchronization stuff to make question clear. This implement looks ugly, right? The class must guarantee to initialize before use.

Any good ideas? Thanks very much, this problem has troubled me for some time.

---

OK! I give the real world problem. This is a Android problem.

public class Configuration {
    private static final Configuration instance = new Configuration ();

    private boolean initial = false;

    private long timeStamp = -1;

    private Configuration () { }

    public static Configuration getInstance() {
            if (initial == false) {
                throw exception...
            }
            return instance;
    }

    public void load(Context context) {
        if (initial == false) {
            SharedPreferences loader = context.getSharedPreferences("Conf", Context.MODE_PRIVATE);
            timeStamp = loader.getInt("TimeStamp", 0);              
            initial = true;
        }
    }

    public int getTimeStamp() {
        return timeStamp;
    }
}

Is this make question clearer?

Answer 1

The right pattern is the one allowing you to do things you need. Do not be so dogmatic. Singleton with a parameter is widely used and acepted in android environment (parameter is usually context). But in plain java environment, dependency injection would be better as it decouples code using you singleton from the fact it is singleton, and modalities of its creation. There are a plenty of DI frameworks,like picocontainer, spring, google guice - just pick your favorite

Answer 2

EDIT: When I wrote this answer, the question had no context - we didn't know it was an Android app. It may be that it's not a bad solution in this case; but I would at least think about other approaches. I'm leaving my answer below for the more general case.

I would attempt to move away from the singleton pattern to start with.

Why is each configuration parameter needed from many places? Could you encapsulate each aspect of configuration (possibly multiple parameters in a single aspect in some cases) and then use dependency injection (e.g. with Guice) to make those encapsulated versions available to the components that need them?

It's hard to give concrete advice when we really don't know what kind of app you're writing, but in general it's a good idea to move away from global state, and dependency injection often provides a clean way of doing this. It's not a panacea, and it could be that in some cases you can redesign in a different way, but it would be my first thought.