Laminas ServiceManager

An initializer is a callable or a class implementing Laminas\ServiceManager\Initializer\InitializerInterface that runs every time a service is created. They are typically used to inject dependencies into objects that implement specific interfaces (e.g., injecting an EventManager into objects implementing EventManagerAwareInterface).

Warning: Initializers are primarily maintained for backward compatibility. Their use is highly discouraged because:

• They can lead to fragile code where objects exist in an "incomplete state" if the initializer fails to run.
• They impact performance as they run for every single service instance created.

Recommended Alternative: Use Factories for constructor injection, or Delegator Factories for setter/interface injection.

use Interop\
Container\ContainerInterface;
use Laminas\ServiceManager\Initializer\InitializerInterface;
use Laminas\ServiceManager\ServiceManager;

// Using a class-based initializer
class MyInitializer implements InitializerInterface
{
    public function __invoke(ContainerInterface $container, $instance)
    {
        if ($instance instanceof EventManagerAwareInterface) {
            $instance->setEventManager($container->get(EventManager::class));
        }
    }
}

$serviceManager = new ServiceManager([
    'initializers' => [
        new MyInitializer()
    ]
]);

In laminas-servicemanager (version 3 and later), you can choose between using explicit Factories or Abstract Factories to instantiate services.

Key Differences

When to use which?

• Use Abstract Factories during early development stages to avoid writing boilerplate for every new class. Examples include ReflectionBasedAbstractFactory or ConfigAbstractFactory.
• Use Factories for production-ready code where performance is critical and service dependencies are stable.

// Example of mapping a specific service to a factory (Explicit Factory approach)
return [
    'factories' => [
        SomeService::class => AnAbstractFactory::class,
    ],
];

By default, services in the ServiceManager are shared, meaning get() returns the same instance every time. You can change this behavior in three ways:

1. Per-service configuration: Use the shared key in the configuration array to set a service to false.
2. The build() method: Use $serviceManager->build(ServiceName::class) instead of get(). This always creates a new instance and never caches it.
3. Global default: Set shared_by_default to false in the configuration to make all services non-shared by default.

// 1. Per-service configuration
$serviceManager = new ServiceManager([
    'factories' => [stdClass::class => InvokableFactory::class],
    'shared' => [stdClass::class => false]
]);

// 2. Using build() for a discrete instance
$object1 = $serviceManager->build(stdClass::class);

// 3. Disabling sharing globally
$serviceManager = new ServiceManager([
    'factories' => [stdClass::class => InvokableFactory::class],
    'shared_by_default' => false,
]);

By default, services in the ServiceManager are shared. This means calling $serviceManager->get(ServiceName::class) multiple times returns the exact same instance, which optimizes memory and performance.

To change this behavior, you have three options:

1. Disable sharing for a specific service: Use the shared configuration key with a boolean false value.
2. Use the build() method: Calling $serviceManager->build(ServiceName::class) always creates a new instance and never retrieves a cached one.
3. Disable sharing globally: Set the shared_by_default configuration key to false.

// 1. Disable sharing for a specific service via config
$serviceManager = new ServiceManager([
    'factories' => [stdClass::class => InvokableFactory::class],
    'shared' => [
        stdClass::class => false
    ]
]);

// 2. Use build() to get a fresh instance regardless of sharing config
$object1 = $serviceManager->build(stdClass::class);
$object2 = $serviceManager->build(stdClass::class);
var_dump($object1 === $object2); // false

// 3. Disable sharing globally
$serviceManager = new ServiceManager([
    'shared_by_default' => false,
]);

An abstract factory is used when you cannot know the service names in advance (e.g., they are generated at runtime) but they follow a common creation pattern.

An abstract factory must implement Laminas\ServiceManager\Factory\AbstractFactoryInterface and provides two methods:

1. canCreate(ContainerInterface $container, $requestedName): Returns true if the factory is capable of creating the requested service.
2. __invoke(ContainerInterface $container, $requestedName, array $options = null): Creates and returns the service.

Resolution Process

When get($name) is called:

1. The Service Manager checks for an explicit factory mapping.
2. If none is found, it iterates through registered abstract_factories in order.
3. It calls canCreate() on each. If true, it calls __invoke().

Best Practices

Limit the number of abstract factories. Because the Service Manager must iterate through them sequentially during lookups, having many abstract factories can be costly for performance. Mapping the same factory to multiple explicit services is usually a more efficient alternative.

use Interop\Container\ContainerInterface;
use Laminas\ServiceManager\Factory\AbstractFactoryInterface;

class MyAbstractFactory implements AbstractFactoryInterface
{
    public function canCreate(ContainerInterface $container, $requestedName)
    {
        // Logic to determine if this factory can handle the request
        return in_array('Traversable', class_implements($requestedName), true);
    }

    public function __invoke(ContainerInterface $container, $requestedName, array $options = null)
    {
        return new $requestedName();
    }
}

$serviceManager = new ServiceManager([
    'abstract_factories' => [
        MyAbstractFactory::class
    ]
]);