Scopes: singleton and prototype

[mnapoli]

Scopes:

• singleton: one instance of the class is shared
• prototype: a new instance of the class is created each time it is requested

Through annotations

Like Spring or Flow3

/**
 * @Scope("singleton")
 */
class MyClass {
}

/**
 * @Scope("prototype")
 */
class MyClass {
}

Through configuration

To be specified

[mnapoli]

cf. commit b1d0d2d

[domu1de]

It may be useful not just to give the opportunity to set the scope through Configuration, but also to specify injections/injection points through Configuration. That would cover some more complex use cases and would be a nice feature.

[mnapoli]

You mean an alternative to annotations? (like: "inject this and that in the constructor, and inject that in the setter")

Right now you can do:

$foo = new Foo($container['bar'], $container['baz']);
$foo->setBam($container['bam']);
$container->set('foo', $foo);

or (for lazy initializing, what I use by default):

$container->set('foo', function($container) {
    $foo = new Foo($container['bar'], $container['baz']);
    $foo->setBam($container['bam']);
    return $foo;
});

[domu1de]

Correct, it should be an alternative to annotations as it is offered by DI frameworks like Spring and Flow3. What you mentioned works, but IMO it would be better if it's possible through the configuration array, wouldn't it?

[mnapoli]

Oh yeah you can already do:

Container::addConfiguration(array(
    "entries" => array(
        "myBean" => function(Container $c) {
            return new MyClass($c["foo"], $c["bar"]);
        },
    ),
));

but you can't specify the scope in there, and the array structure don't make it easy to add it (without adding too much complexity).

Do you have something specific in mind?

[domu1de]

Maybe something like that:

Container::addConfiguration(array(
    "classes" => array(
        "myClass" => array(
            "scope" => "prototype",
            "arguments" => array(
                "arg1" => array(
                    "class" => "myClass2",
                    "lazy" => true
                ),
                "arg2" => new Foo(),
                "arg3" => function(Container $c) {
                    return new MyClass($c["foo"], $c["bar"]);
                },
                "arg4" => "myBean"
            ),
            "properties" => array(),
            "methods" => array()
        ),
    )
));

I know it's getting more complex, but it is just thought of as a feature for complex requirements.

[mnapoli]

Yep that's indeed getting complex, but I'm afraid that's the only solution if keeping PHP arrays (not YML or XML). PHP code has the advantage of allowing to define dependencies with closures.

And I used to think there was no advantage of having an explicit bean declaration like the one you wrote VS using closures, but actually there is one: using closures prevent the use of proxies (see http://ocramius.github.com/blog/zf2-and-symfony-service-proxies-with-doctrine-proxies/, very good read).

So anyway the extended bean definition will be a separate issue.

[mnapoli]

Separate issue for bean definition: #43

[mnapoli]

I'm closing this issue as we can consider scopes as implemented.

The next step is to have all configuration/metadata possible through:

• annotations
• php config
• yaml

(#43)