From here: http://www.codingwithoutcomments.com/
If you do use Singletons, try to use dependency injection instead of
calling getInstance() from the constructor, use this:
public MyConstructor(Singleton singleton)
{
this.singleton = singleton;
}
rather than this:
public MyConstructor()
{
this.singleton = Singleton.getInstance();
}
At the very least, using dependency injection allows you to do some unit testing of the class by adhering to good encapsulation principles.
How is this “dependency injection”? What is the meaning of dependency injection?
Doesn’t this defeat the purpose of the Singleton pattern?
Is this supposed to be used for some time and then removed later on?
“Dependency injection” means that you explicitly provide an object with references to all other objects that it depends on; that’s what the first example does when it passes a reference to the constructor.
The alternative is to implicitly provide the objects that it depends on, by making them globally accessible. That’s what the second example does.
The main advantage of dependency injection is that the dependency can be on an abstract interface; there’s no need to tie your class to a particular concrete class, or to a particular instance of that class. This makes testing more convenient – your class can be tested in isolation, interacting with “stub” implementations of any interface that it depends on. It also makes it easier to keep track of the dependencies, since they are all explicitly stated in the code.
The main advantages of using globals are that they allow you to write slightly less code, and you don’t need to worry about managing dependencies until they become a problem; when they do, you can simply abandon the project and start a new one.
That rather depends on what you think the purpose of the anti-pattern is. It certainly does remove the convenience of a globally-accessible instance; but, assuming the Singleton class does follow the anti-pattern, you still have the assurance that the object you receive is the One True Instance.
The singleton should be replaced by a normal class, passed by reference to its dependents, once you need to do things that the anti-pattern prevents (unit testing, multiple instances, subtypes, an abstract interface, etc.). There is little need to remove dependency injection once it’s there; you’ll only have to put it back again once you find that singletons don’t meet your requirements.