Construction of a singleton class

Question

An ethical question here.

I'm planning on using several manager classes in my new project that will be performing various tasks across the whole project. These classes are singletons, but require construction based on parameters.

As to when/where this construction has to happen, I have mixed feelings. I have these options so far:

Option A

It's easy to just pass these parameters to the getInstance method while having a default null value. On the very first call the parameters will be used, and any additional calls completely ignore them.

While this works, doing so feels rather unlogical, for the following reasons:

• It makes documentation unclear. getInstance' first parameter must be of type Collection, but can be null... what's going on here? You can argue that writing a line about this in the description will clear it up, but I'd prefer clarification to be unneccesary.

• It feels faulty to pass getInstance any construction parameters. This is due to the fact that the method name does not explicity hint towards construction, making it unclear it will happen.

Option B

I'm thinking about a setup method. This method takes all parameters, calls the class constructor, and changes the internal class state to initialized.

When calling the getInstance method prior to setup, it will throw a NotInitializedException. After setup has been called, any additional calls to setup will result in a PreviouslyInitializedException.

After setup has been called, getInstance becomes available.

Personally, this option appeals more to me. But it feels excessive.

What option do you prefer? And why?

Answer 1

I would probably try and ditch the singleton approach and pass manager classes around to whatever needs them.

$manager = new Manager( $collection, $var, $var2 );

$other_class = New OtherClass( $manager );
//or
$other_class = New OtherClass;
$other_class->manager = $manager;
//or
$other_class = New OtherClass;
$other_class->setManager( $manager );

Answer 2

Use dependency injection to pass the Manager object around. Don't use Singleton pattern. It's a common consensus that using it creates a global state and makes your API deceptive.

• PHP Global in functions (jump to answer)
• Singletons are pathological liars

Inject the Manager instance to any class that needs it via the constructor. Each class should not try to instantiate Manager by themselves, the only way the classes get an instance of the Manager is by getting it from constructor.

class NeedsManager
{
    protected $manager;

    public function __construct(Manager $manager)
    {
        $this->manager = $manager;
    }
}

You don't need to enforce one instance of Manager. Just don't instantiate it more than once. If all of your classes that need an instance of Manager get what they need from the constructor and never tries to instantiate it on their own, it will assure that there's just going to be one instance in your application.

Answer 3

How about option 3. If they are true singletons, set up properties files for their parameters for use with a no-arg getInstance.

If that doesn't fit, you might be misusing the singleton pattern.

Answer 4

You are looking at using a Factory design pattern. Factories are objects that act as fancy constructors for other objects. In your case, you will move setup and getInstance to the factory. The wiki article's pretty good- http://en.wikipedia.org/wiki/Factory_method_pattern

class SingletonFoo {
  //properties, etc
    static $singleton = NULL;
    private function __constructor(){}
    static function getInstance(){
        if(NULL === self::$singleton) {
            self::$singleton = new SingletonFoo();
        }
        return self::$singleton;
    }
}

class FooFactory {
    static $SingletonFoo = null;
    static function setup($args){
        if( !(NULL === self::$SingletonFoo)){
            throw new AlreadyInstantiatedException();
        }
        self::$SingletonFoo = SingletonFoo::getInstance();
        //Do stuff with $args to build SingletonFoo
        return self::$SingletonFoo;
    }

    static function getInstance(){
        if(NULL === self::$SingletonFoo) {
            throw new NotInstantiatedException();
        }
        return self::$SingletonFoo;
    }
}

Answer 5

Don't use Singleton, use Resources Manager (or Service Container, or DI Container):

class ResourceManager
{
    protected static $resource;

    public static function setResource($resource)
    {
        if (!empty(self::$resource)) //resource should not be overwritten
        {
            if ($resource!=self::$resource) return false;
            else return true;
        }

        self::$resource = $resource;
        return true;
    }

    public static function getResource()
    {
        return self::$resource;
    }
}

Resource Manager allows you to set any custom classes for unit-testing (like dependency injection), you can just get needed resources without requesting them in constructor (I like DI, but sometimes it's just more handy to use empty constructors).

Ready-to-use variant: http://symfony.com/doc/current/book/service_container.html (I don't like to move logic from code to configs, but in stand-alone module it looks acceptable).