Re: Singleton Pattern

Adi wrote:


The main reason is that it hinders Unit testing, but there are many
other good arguments against singletons as well.

The alternative is often the use of Dependency Injection. This allows
you to decouple the process of obtaining an object from the class
altogether. A class which uses a Singleton will have to know exactly
where to get it, and therefor coupling it to the Singleton. A class
which utilizes Dependency Injection will know that it wants the
"Singleton" object, but instead of asking for it directly, it will be
given it by some outside source.

Lets give an analogy in psuedo-Java:

class Plant {
    double lightObsorbed = 0;
    void obsorbLight() {
         listObsorbed +=
LightSourceSingletonFactory.getLightSource().getLightInWatts();
    }
}

the Plant class is now coupled to LightSourceSingletonFactory and the
LightSource interface. While it is not coupled to the implementation
of LightSource.

class Plant {
    LightSource lightSource;
    void obsorbLight() {
         listObsorbed += lightSource.getLightInWatts();
    }

   void setLightSource(LightSource lightSource) {
       this.lightSource = lightSource;
   }
}

Now, plant is no longer coupled to a singleton factory at all, and only
the interface of LightSource. This would be useful of some day, your
business logic needed to have both indoor plants (class LightBulb
implements LightSource), and outdoor plants (class Sun implements
LightSource).

It also allows you to have a unit test with a "mock" LightSource
object.

Dependency Injection is a subcategory of Inversion of Control. The
basis of the spring framework.

While the Singleton pattern DOES have uses, there are often other ways
to achieve the same goal which lend themselves to a more flexible
architecture. If you only need to ensure that there is only one
instance of a particular class (eg. for a resource heavy object), you
can still use DI and IoC, especially since the classes themselves don't
do any form of object instansiation or retrieval.

It removes the burdon of object instantiation or retrieval from the
business domain, and puts it into the framework.

Hope this helps,
Daniel.