Laminas Servicemanager

https://github.com/laminas/laminas-servicemanager
Admin
Laminas ServiceManager implements the Service Locator design pattern, acting as a service/object...
Tokens:29,482
Snippets:203
Trust Score:9.7
License:BSD-3-Clause
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Install laminas-servicemanager via Composer

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/quick-start.md

Run this command to install the Laminas Service Manager package using Composer. Requires Composer to be installed first.

```bash
$ composer require laminas/laminas-servicemanager
```

--------------------------------

### Verify shared instances with get()

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/quick-start.md

Calling get() twice returns the same shared instance. The var_dump prints 'true' because the objects are identical.

```php
$object1 = $serviceManager->get(stdClass::class);
$object2 = $serviceManager->get(stdClass::class);

var_dump($object1 === $object2); // prints "true"
```

--------------------------------

### Retrieve shared instance with get()

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/quick-start.md

Use the get() method to retrieve a service instance. By default, instances are shared, so calling get() twice returns the exact same object.

```php
$object = $serviceManager->get(stdClass::class);
```

--------------------------------

### Default shared service behavior with get()

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/configuring-the-service-manager.md

By default, services are shared, so calling get() twice returns the same instance. This example shows that var_dump prints 'true'.

```php
$serviceManager = new ServiceManager([
    'factories' => [
        stdClass::class => InvokableFactory::class
    ]
]);

$object1 = $serviceManager->get(stdClass::class);
$object2 = $serviceManager->get(stdClass::class);

var_dump($object1 === $object2); // prints "true"
```

--------------------------------

### Retrieve discrete instances with build()

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/quick-start.md

Use the build() method to retrieve discrete (non-shared) instances. Each call creates a new object, so var_dump prints 'false'.

```php
$object1 = $serviceManager->build(stdClass::class);
$object2 = $serviceManager->build(stdClass::class);

var_dump($object1 === $object2); // prints "false"
```

--------------------------------

### ConfigAbstractFactory configuration example

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/config-abstract-factory.md

Shows the configuration array structure for the ConfigAbstractFactory, mapping service names to dependency lists.

```php
use Laminas\ServiceManager\AbstractFactory\ConfigAbstractFactory;

return [
    ConfigAbstractFactory::class => [
        MyInvokableClass::class => [],
        MySimpleClass::class => [
            Logger::class,
        ],
        Logger::class => [
            Handler::class,
        ],
    ],
];
```

--------------------------------

### Install laminas-cli via Composer

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/cli-commands/introduction.md

Required to run console tools with laminas-servicemanager. Use the --dev flag if laminas-cli is only needed for consuming these tools.

```bash
$ composer require laminas/laminas-cli
```

--------------------------------

### Configure ServiceManager with factories

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/quick-start.md

Create a ServiceManager instance by passing a configuration array. The 'factories' key maps a service name (stdClass::class) to an invokable factory (InvokableFactory::class).

```php
use Laminas\ServiceManager\ServiceManager;
use Laminas\ServiceManager\Factory\InvokableFactory;
use stdClass;

$serviceManager = new ServiceManager([
    'factories' => [
        stdClass::class => InvokableFactory::class,
    ],
]);
```

--------------------------------

### Generated factories configuration file

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/cli-commands/generate-ahead-of-time-factories.md

Example of the file created by the CLI command containing all service <=> factory entries for the container and plugin-managers.

```php
return [
    'service_manager' => [
        'factories' => [
            MyService::class => GeneratedMyServiceFactory::class,    
        ],
    ],
    'validators' => [
        'factories' => [
            MyValidator::class => GeneratedMyValidatorFactory::class,    
        ],
    ],
];
```

--------------------------------

### Example classes for ConfigAbstractFactory

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/config-abstract-factory.md

Defines classes with constructor dependencies to be used with the ConfigAbstractFactory.

```php
class UserMapper
{
    public function __construct(Adapter $db, Cache $cache) {}
}

class Adapter
{
    public function __construct(array $config) {}
}

class Cache
{
    public function __construct(CacheAdapter $cacheAdapter) {}
}

class CacheAdapter
{
}
```

--------------------------------

### ConfigAbstractFactory configuration with mixed factories

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/config-abstract-factory.md

Configuration for the example classes, mixing abstract factory definitions with a normal factory for Adapter.

```php
// config/autoload/dependencies.php or anywhere that gets merged into global config
return [
    ConfigAbstractFactory::class => [
        CacheAdapter::class => [], // no dependencies
        Cache::class => [
            CacheAdapter::class, // dependency on the CacheAdapter key defined above
        ],
        UserMapper::class => [
            Adapter::class, // will be called using normal factory defined below
            Cache::class, // defined above and will be created using this abstract factory
        ],
    ],
    'service_manager' => [
        'factories' => [
            Adapter::class => AdapterFactory::class, // normal factory not using above config
        ],
    ],
],
```

--------------------------------

### Install laminas-cli

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/cli-commands/generate-ahead-of-time-factories.md

Adds laminas/laminas-cli as a dev dependency to enable the CLI command for auto-detecting services using ReflectionBasedAbstractFactory.

```shell
$ composer require --dev laminas/laminas-cli
```

--------------------------------

### Alias mapping example

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/configuring-the-service-manager.md

Shows how to define aliases in the service manager configuration. An alias can point to another alias, resolved recursively. In this example, 'B' resolves to 'A', which resolves to stdClass::class.

```php
use Laminas\ServiceManager\Factory\InvokableFactory;
use Laminas\ServiceManager\ServiceManager;
use stdClass;

$serviceManager = new ServiceManager([
    'factories' => [
        stdClass::class => InvokableFactory::class
    ],

    'aliases' => [
        'A' => stdClass::class,
        'B' => 'A'
    ]
]);

$object = $serviceManager->get('B');
```

--------------------------------

### Configure ReflectionBasedAbstractFactory as abstract factory and factory

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/reflection-abstract-factory.md

Shows how to register Laminas\ServiceManager\AbstractFactory\ReflectionBasedAbstractFactory in the service_manager configuration, both as an abstract factory and mapped to a specific service name. Mapping services to the factory is more explicit and more performant than in v3.0 due to ahead-of-time factory generation.

```php
use Laminas\ServiceManager\AbstractFactory\ReflectionBasedAbstractFactory;

return [
    /* ... */
    'service_manager' => [
        'abstract_factories' => [
            ReflectionBasedAbstractFactory::class,
        ],
        'factories' => [
            'MyModule\Model\FooModel' => ReflectionBasedAbstractFactory::class,
        ],
    ],
    /* ... */
];
```

--------------------------------

### Use build() to bypass caching

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/configuring-the-service-manager.md

The build() method never caches or reuses instances, so each call returns a new service. This example shows that var_dump prints 'false'.

```php
$serviceManager = new ServiceManager([
    'factories' => [
        stdClass::class => InvokableFactory::class
    ]
]);

$object1 = $serviceManager->build(stdClass::class);
$object2 = $serviceManager->build(stdClass::class);

var_dump($object1 === $object2); // prints "false"
```

--------------------------------

### Install ProxyManager

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/lazy-services.md

Required before using lazy services. Installs the proxy-manager-lts package via Composer.

```php
$ composer require friendsofphp/proxy-manager-lts
```

--------------------------------

### Buzzer example class

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/lazy-services.md

A class designed to be slow at instantiation time for demonstration purposes. Its constructor sleeps for 5 seconds.

```php
namespace MyApp;

class Buzzer
{
    public function __construct()
    {
        // deliberately halting the application for 5 seconds
        sleep(5);
    }

    public function buzz()
    {
        return 'Buzz!';
    }
}
```

--------------------------------

### Disable sharing per service with 'shared' key

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/configuring-the-service-manager.md

Set the 'shared' key to false for a specific service to get discrete instances. This example shows that var_dump prints 'false'.

```php
$serviceManager = new ServiceManager([
    'factories' => [
        stdClass::class => InvokableFactory::class
    ],
    'shared' => [
        stdClass::class => false
    ]
]);

$object1 = $serviceManager->get(stdClass::class);
$object2 = $serviceManager->get(stdClass::class);

var_dump($object1 === $object2); // prints "false"
```

--------------------------------

### Disable sharing by default with 'shared_by_default'

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/configuring-the-service-manager.md

Set 'shared_by_default' to false to disable caching even when calling get(). This example shows that var_dump prints 'false'.

```php
$serviceManager = new ServiceManager([
    'factories' => [
        stdClass::class => InvokableFactory::class
    ],
    'shared_by_default' => false,
]);

$object1 = $serviceManager->get(stdClass::class);
$object2 = $serviceManager->get(stdClass::class);

var_dump($object1 === $object2); // prints "false"
```

--------------------------------

### Register and use a plugin manager as a service

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/plugin-managers.md

Shows how to register a plugin manager as a service in the main service manager, retrieve it, and use it to get a validator. The factory receives the parent container and returns a new ValidatorPluginManager with its own service configuration.

```php
$serviceManager = new ServiceManager([
    'factories' => [
        ValidatorPluginManager::class => function(ContainerInterface $container, $requestedName) {
            return new ValidatorPluginManager($container, [
                'factories' => [
                    StringLengthValidator::class => InvokableFactory::class,
                ],
            ]);
        },
    ],
]);

// Get the plugin manager:

$pluginManager = $serviceManager->get(ValidatorPluginManager::class);

// Use the plugin manager

$validator = $pluginManager->get(StringLengthValidator::class);
```

--------------------------------

### Configure ServiceManager with associative array

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/configuring-the-service-manager.md

Pass an associative array to the ServiceManager constructor to configure services, invokables, factories, abstract factories, delegators, aliases, initializers, lazy services, shared settings, and shared_by_default. The example shows all keys with empty arrays and shared_by_default set to true.

```php
use Laminas\ServiceManager\ServiceManager;

$serviceManager = new ServiceManager([
    'services'           => [],
    'invokables'         => [],
    'factories'          => [],
    'abstract_factories' => [],
    'delegators'         => [],
    'aliases'            => [],
    'initializers'       => [],
    'lazy_services'      => [],
    'shared'             => [],
    'shared_by_default'  => true,
]);
```

--------------------------------

### Generate Factory for Class - Help Command

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/cli-commands/generate-factory-for-class.md

Displays help for the servicemanager:generate-factory-for-class command, showing usage and options.

```bash
$ ./vendor/bin/laminas servicemanager:generate-factory-for-class -h
```

--------------------------------

### Service Manager configuration with callable factory

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/configuring-the-service-manager.md

Shows how to use a closure as a factory to create complex objects with dependencies. The factory receives the container and requested name.

```php
use Interop\Container\ContainerInterface;
use Laminas\ServiceManager\Factory\InvokableFactory;
use Laminas\ServiceManager\ServiceManager;
use stdClass;

$serviceManager = new ServiceManager([
    'factories' => [
        stdClass::class => InvokableFactory::class,
        MyObject::class => function(ContainerInterface $container, $requestedName) {
            $dependency = $container->get(stdClass::class);
            return new MyObject($dependency);
        },
    ],
]);
```

--------------------------------

### Mapping multiple services to the same factory

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/configuring-the-service-manager.md

Shows how to use the $requestedName parameter to create multiple services with the same factory, reducing the number of factories needed. Includes both interface and non-interface implementations.

```php
// In MyObjectFactory.php file

class MyObjectFactory implements FactoryInterface
{
    public function __invoke(ContainerInterface $container, $requestedName, array $options = null)
    {
        $dependency = $container->get(stdClass::class);
        return new $requestedName($dependency);
    }
}

// or without implementing the interface:
class MyObjectFactory
{
    public function __invoke(ContainerInterface $container, $requestedName)
    {
        $dependency = $container->get(Dependency::class);
        return new $requestedName($dependency);
    }
}

// When creating the service manager:
$serviceManager = new ServiceManager([
    'factories' => [
        MyObjectA::class => MyObjectFactory::class,
        MyObjectB::class => MyObjectFactory::class
    ]
]);
```

--------------------------------

### Run PHPBench benchmarks

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/README.md

Execute the benchmark suite for laminas-servicemanager using PHPBench. The command runs all benchmarks and outputs an aggregate report.

```bash
$ vendor/bin/phpbench run --report=aggregate
```

--------------------------------

### Initializer as class implementing InitializerInterface

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/configuring-the-service-manager.md

Shows how to create a class implementing InitializerInterface and pass it to the 'initializers' array. The class is instantiated automatically when the service manager is initialized, even if you pass the class name.

```php
// In MyInitializer.php

class MyInitializer implements InitializerInterface
{
    public function __invoke(ContainerInterface $container, $instance)
    {
        if (! $instance instanceof EventManagerAwareInterface) {
            return;
        }
        $instance->setEventManager($container->get(EventManager::class));
    }
}

// When creating the service manager:

use Interop\Container\ContainerInterface;
use stdClass;
use Laminas\ServiceManager\ServiceManager;

$serviceManager = new ServiceManager([
    'initializers' => [
        new MyInitializer() // You could also use MyInitializer::class
    ]
]);
```

--------------------------------

### Using InvokableFactory with build() options

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/configuring-the-service-manager.md

Shows how to replace a custom factory with the built-in InvokableFactory when the service has no other dependencies. The InvokableFactory automatically passes the options array to the constructor.

```php
// When creating the service manager:
$serviceManager = new ServiceManager([
    'factories' => [
        StringLengthValidator::class => InvokableFactory::class
    ]
]);

// When creating the objects:

$validator1 = $serviceManager->build(StringLengthValidator::class, ['min' => 5]);
$validator2 = $serviceManager->build(StringLengthValidator::class, ['min' => 15]);
```

--------------------------------

### Factory with options and build() usage

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/configuring-the-service-manager.md

Shows a custom factory that accepts options passed via the build() method, along with service manager configuration and two build() calls with different options. The factory receives the options array and passes it to the constructor.

```php
// In StringLengthValidatorFactory.php

class StringLengthValidatorFactory implements FactoryInterface
{
    public function __invoke(ContainerInterface $container, $requestedName, array $options = [])
    {
        return new StringLengthValidator($options);
    }
}

// When creating the service manager:
$serviceManager = new ServiceManager([
    'factories' => [
        StringLengthValidator::class => StringLengthValidatorFactory::class
    ]
]);

// When creating the objects:

$validator1 = $serviceManager->build(StringLengthValidator::class, ['min' => 5]);
$validator2 = $serviceManager->build(StringLengthValidator::class, ['min' => 15]);
```

--------------------------------

### Mapping an Abstract Factory to a Service in Configuration

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/cookbook/factories-vs-abstract-factories.md

Shows how to map an abstract factory to a specific service name in the service manager configuration. This allows the abstract factory to be used as a regular factory for that service.

```php
return [
    'factories' => [
        SomeService::class => AnAbstractFactory::class,
    ],
];
```

--------------------------------

### Configure Service Manager with factories and methods

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/configuring-the-service-manager.md

Shows how to alter a service manager's configuration after construction using configure(), setAlias(), setFactory(), mapLazyService(), addAbstractFactory(), addDelegator(), addInitializer(), setService(), and setShared(). Assumes setAllowOverride(false) has not been called. Includes a note that addInitializer is discouraged in favor of delegator factories.

```php
use Laminas\ServiceManager\ServiceManager;

$serviceManager = new ServiceManager([
    'factories' => [
        stdClass::class => InvokableFactory::class;
    ]
]);

$serviceManager->configure([
    'factories' => [
        DateTime::class => InvokableFactory::class
    ]
]);

var_dump($newServiceManager->has(DateTime::class)); // prints true

// Create an alias from 'Date' to 'DateTime'
$serviceManager->setAlias('Date', DateTime::class);

// Set a factory for the 'Time' service
$serviceManager->setFactory('Time', function ($container) {
    return $container->get(DateTime::class);
});

// Map a lazy service named 'localtime' to the class DateTime.
$serviceManager->mapLazyService('localtime', DateTime::class);

// Add an abstract factory
$serviceManager->addAbstractFactory(new CustomAbstractFactory());

// Add a delegator factory for the DateTime service
$serviceManager->addDelegator(DateTime::class, function ($container, $name, $callback) {
    $dateTime = $callback();
    $dateTime->setTimezone(new DateTimezone('UTC'));
    return $dateTime;
});

// Add an initializer
// Note: don't do this. Use delegator factories instead.
$serviceManager->addInitializer(function ($service, $instance) {
    if (! $instance instanceof DateTime) {
        return;
    }
    $instance->setTimezone(new DateTimezone('America/Chicago'));
})

// Explicitly map a service name to an instance.
$serviceManager->setService('foo', new stdClass);

// Mark the DateTime service as NOT being shared.
$serviceManager->setShared(DateTime::class, false);
```

--------------------------------

### Verify proxying with loop

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/lazy-services.md

Runs a loop to retrieve the buzzer 100 times, then calls buzz. The 5-second delay should occur only when buzz is invoked, not during retrieval.

```php
use MyApp\Buzzer;

for ($i = 0; $i < 100; $i += 1) {
    $buzzer = $serviceManager->get(Buzzer::class);
    echo "created buzzer $i\n";
}

echo $buzzer->buzz();
```

--------------------------------

### setService($name, $instance)

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/configuring-the-service-manager.md

Explicitly maps a service name to an instance. This allows you to register a pre-existing object as a service.

```APIDOC
## setService($name, $instance)

### Description
Explicitly maps a service name to an instance. This allows you to register a pre-existing object as a service.

### Method
setService

### Parameters
#### Request Body
- **name** (string) - Required - The service name.
- **instance** (object) - Required - The instance to register.

### Request Example
```php
$serviceManager->setService('foo', new stdClass);
```

### Response
No return value.
```

--------------------------------

### Service Manager configuration with factories using InvokableFactory

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/configuring-the-service-manager.md

Shows how to configure the ServiceManager with a factories array, using InvokableFactory for classes without dependencies and a custom factory for others.

```php
use Laminas\ServiceManager\Factory\InvokableFactory;
use Laminas\ServiceManager\ServiceManager;
use stdClass;

$serviceManager = new ServiceManager([
    'factories' => [
        stdClass::class => InvokableFactory::class,
        MyObject::class => MyObjectFactory::class,
    ],
]);
```

--------------------------------

### Directory structure

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/cli-commands/generate-ahead-of-time-factories.md

Shows the shared configuration directory structure for Laminas-MVC and Mezzio projects.

```text
.
├── config
│   ├── autoload
│   │   ├── global.php
│   │   └── local.php.dist
└── data
```

--------------------------------

### Factory class implementation and ServiceManager configuration

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/configuring-the-service-manager.md

Shows two factory class implementations (with and without FactoryInterface) and the corresponding ServiceManager configuration. Factories are created lazily for performance.

```php
// In MyObjectFactory.php file

class MyObjectFactory implements FactoryInterface
{
    public function __invoke(ContainerInterface $container, $requestedName, array $options = null)
    {
        $dependency = $container->get(stdClass::class);
        return new MyObject($dependency);
    }
}

// or without implementing the interface:
class MyObjectFactory
{
    public function __invoke(ContainerInterface $container, $requestedName)
    {
        $dependency = $container->get(Dependency::class);
        return new MyObject($dependency);
    }
}

// When creating the service manager:
$serviceManager = new ServiceManager([
    'factories' => [
        stdClass::class => InvokableFactory::class,
        MyObject::class => MyObjectFactory::class
    ]
]);
```

--------------------------------

### configure()

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/configuring-the-service-manager.md

Configures the service manager with a new configuration array, similar to the constructor. This method allows you to add or modify services after the manager has been created.

```APIDOC
## configure()

### Description
Configures the service manager with a new configuration array, similar to the constructor. This method allows you to add or modify services after the manager has been created.

### Method
configure

### Parameters
#### Request Body
- **config** (array) - Required - The configuration array, same format as the constructor.

### Request Example
```php
$serviceManager->configure([
    'factories' => [
        DateTime::class => InvokableFactory::class
    ]
]);
```

### Response
No return value.
```

--------------------------------

### Command help for servicemanager:generate-deps-for-config-factory

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/cli-commands/generate-dependencies-for-config-factory.md

Displays usage and options for the CLI command. The command reads a configuration file (creating it if missing) and injects ConfigAbstractFactory dependency configuration for a given class. The -i/--ignore-unresolved flag allows ignoring classes with unresolved direct dependencies; without it, such classes cause the tool to fail with an exception.

```bash
$ ./vendor/bin/laminas servicemanager:generate-deps-for-config-factory -h
Description:
  Reads the provided configuration file (creating it if it does not exist), and injects it with ConfigAbstractFactory dependency configuration for the provided class name, writing the changes back to the file.

Usage:
  servicemanager:generate-deps-for-config-factory [options] [--] <configFile> <class>

Arguments:
  configFile                 Path to a config file for which to generate configuration. If the file does not exist, it will be created. If it does exist, it must return an array, and the file will be updated with new configuration.
  class                      Name of the class to reflect and for which to generate dependency configuration.

Options:
  -i, --ignore-unresolved    Ignore classes with unresolved direct dependencies.
  -q, --quiet                Do not output any message
```

--------------------------------

### Generate Factory for Class - Generate Factory and Pipe to File

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/cli-commands/generate-factory-for-class.md

Generates a factory class for the specified class and pipes the output to a PHP file. The generated class implements Laminas\ServiceManager\Factory\FactoryInterface and is placed in the same namespace as the originating class.

```bash
$ ./vendor/bin/laminas servicemanager:generate-factory-for-class \
> "Application\\Model\\AlbumModel" > ./module/Application/src/Model/AlbumModelFactory.php
```

--------------------------------

### Implementing AbstractFactoryInterface in MyAbstractFactory.php

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/configuring-the-service-manager.md

Defines an abstract factory that creates any service whose class implements Traversable. The canCreate() method checks the requested service name, and __invoke() instantiates it. This factory is registered with the service manager and used to fetch services.

```php
// In MyAbstractFactory.php:

class MyAbstractFactory implements AbstractFactoryInterface
{
    public function canCreate(ContainerInterface $container, $requestedName)
    {
        return in_array('Traversable', class_implements($requestedName), true);
    }

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

// When creating the service manager:
$serviceManager = new ServiceManager([
    'abstract_factories' => [
        new MyAbstractFactory() // You could also pass a class name: MyAbstractFactory::class
    ]
]);

// When fetching an object:
$object = $serviceManager->get(A::class);
```

--------------------------------

### setFactory($name, $factory)

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/configuring-the-service-manager.md

Registers a factory for a service. The factory can be a callable or the name of a factory class.

```APIDOC
## setFactory($name, $factory)

### Description
Registers a factory for a service. The factory can be a callable or the name of a factory class.

### Method
setFactory

### Parameters
#### Request Body
- **name** (string) - Required - The service name.
- **factory** (callable|string) - Required - A callable factory or the name of a factory class.

### Request Example
```php
$serviceManager->setFactory('Time', function ($container) {
    return $container->get(DateTime::class);
});
```

### Response
No return value.
```

--------------------------------

### setInvokableClass($name, $class = null)

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/configuring-the-service-manager.md

Registers a service that can be instantiated without arguments. If no class is provided, the service name is used as the class name.

```APIDOC
## setInvokableClass($name, $class = null)

### Description
Registers a service that can be instantiated without arguments. If no class is provided, the service name is used as the class name.

### Method
setInvokableClass

### Parameters
#### Request Body
- **name** (string) - Required - The service name.
- **class** (string|null) - Optional - The class name to instantiate. Defaults to `$name`.

### Request Example
```php
$serviceManager->setInvokableClass('MyService', MyClass::class);
```

### Response
No return value.
```

--------------------------------

### Initializer as closure

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/configuring-the-service-manager.md

Defines an initializer as a closure that injects EventManager into instances implementing EventManagerAwareInterface. The initializer is called for each service the first time it is created.

```php
use Interop\Container\ContainerInterface;
use stdClass;
use Laminas\ServiceManager\ServiceManager;

$serviceManager = new ServiceManager([
    'initializers' => [
        function(ContainerInterface $container, $instance) {
            if (! $instance instanceof EventManagerAwareInterface) {
                return;
            }
            $instance->setEventManager($container->get(EventManager::class));
        }
    ]
]);
```

--------------------------------

### Enable ConfigAbstractFactory programmatically

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/config-abstract-factory.md

Adds the ConfigAbstractFactory as an abstract factory to a ServiceManager instance.

```php
$serviceManager = new ServiceManager();
$serviceManager->addAbstractFactory(new ConfigAbstractFactory());
```

--------------------------------

### composer.json classmap configuration

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/cli-commands/generate-ahead-of-time-factories.md

Adds the generated factories directory to the autoload classmap so Composer can autoload the generated classes.

```json
{
    "name": "vendor/project",
    "type": "project",
    "[...]": {},
    "autoload": {
        "classmap": ["data/GeneratedServiceManagerFactories"]
    }
}
```

--------------------------------

### Enable ConfigAbstractFactory via configuration

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/config-abstract-factory.md

Registers ConfigAbstractFactory in configuration for laminas-mvc or mezzio/ConfigProvider consumers.

```php
return [
    // laminas-mvc:
    'service_manager' => [
        'abstract_factories' => [
            ConfigAbstractFactory::class,
        ],
    ],

    // mezzio or ConfigProvider consumers:
    'dependencies' => [
        'abstract_factories' => [
            ConfigAbstractFactory::class,
        ],
    ],
];
```

--------------------------------

### mapLazyService($name, $class = null)

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/configuring-the-service-manager.md

Maps a service name to a class for lazy loading. If no class is provided, the service name is used for both sides of the map.

```APIDOC
## mapLazyService($name, $class = null)

### Description
Maps a service name to a class for lazy loading. If no class is provided, the service name is used for both sides of the map.

### Method
mapLazyService

### Parameters
#### Request Body
- **name** (string) - Required - The service name.
- **class** (string|null) - Optional - The class name to map to. Defaults to `$name`.

### Request Example
```php
$serviceManager->mapLazyService('localtime', DateTime::class);
```

### Response
No return value.
```

--------------------------------

### addAbstractFactory($factory)

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/configuring-the-service-manager.md

Adds an abstract factory to the service manager. The factory can be an instance of AbstractFactoryInterface or the name of a class implementing it.

```APIDOC
## addAbstractFactory($factory)

### Description
Adds an abstract factory to the service manager. The factory can be an instance of AbstractFactoryInterface or the name of a class implementing it.

### Method
addAbstractFactory

### Parameters
#### Request Body
- **factory** (AbstractFactoryInterface|string) - Required - An instance or class name implementing AbstractFactoryInterface.

### Request Example
```php
$serviceManager->addAbstractFactory(new CustomAbstractFactory());
```

### Response
No return value.
```

--------------------------------

### Manual usage of BuzzerDelegator

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/delegators.md

Shows how to manually instantiate and use the delegator with an event manager. The output includes the event listener's echo before the delegated result.

```php
$wrappedBuzzer = new Buzzer();
$eventManager  = new Laminas\EventManager\EventManager();

$eventManager->attach('buzz', function () { echo "Stare at the art!\n"; });

$buzzer = new BuzzerDelegator($wrappedBuzzer, $eventManager);

echo $buzzer->buzz(); // "Stare at the art!\nBuzz!"
```

--------------------------------

### Create a plugin manager by extending AbstractPluginManager with $instanceOf

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/plugin-managers.md

Defines a plugin manager class that validates all instances against a specified interface. The $instanceOf property ensures that any service retrieved from the manager must be an instance of ValidatorInterface, otherwise an InvalidServiceException is thrown.

```php
class ValidatorPluginManager extends AbstractPluginManager
{
    protected $instanceOf = ValidatorInterface::class;
}
```

--------------------------------

### setAlias($alias, $target)

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/configuring-the-service-manager.md

Creates an alias for a service name, allowing you to retrieve a service by an alternative name. The alias maps to the target service name.

```APIDOC
## setAlias($alias, $target)

### Description
Creates an alias for a service name, allowing you to retrieve a service by an alternative name. The alias maps to the target service name.

### Method
setAlias

### Parameters
#### Request Body
- **alias** (string) - Required - The alias name to use.
- **target** (string) - Required - The service name to which the alias points.

### Request Example
```php
$serviceManager->setAlias('Date', DateTime::class);
```

### Response
No return value.
```

--------------------------------

### Use ConfigAbstractFactory as a mapped factory

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/config-abstract-factory.md

Registers ConfigAbstractFactory as a factory for a specific class in the service_manager configuration.

```php
return [
    'service_manager' => [
        'factories' => [
            SomeCustomClass::class => ConfigAbstractFactory::class,
        ],
    ],
];
```

--------------------------------

### addInitializer($initializer)

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/configuring-the-service-manager.md

Adds an initializer to the service manager. The initializer can be a callable or the name of an initializer class.

```APIDOC
## addInitializer($initializer)

### Description
Adds an initializer to the service manager. The initializer can be a callable or the name of an initializer class.

### Method
addInitializer

### Parameters
#### Request Body
- **initializer** (callable|string) - Required - A callable initializer or the name of an initializer class.

### Request Example
```php
$serviceManager->addInitializer(function ($service, $instance) {
    if (! $instance instanceof DateTime) {
        return;
    }
    $instance->setTimezone(new DateTimezone('America/Chicago'));
});
```

### Response
No return value.
```

--------------------------------

### Generate AOT factories CLI command

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/cli-commands/generate-ahead-of-time-factories.md

Run this command after setting up the project to generate factories for services using ReflectionBasedAbstractFactory. The target file defaults to config/autoload/generated-factories.local.php. After running, execute composer dump-autoload and remove any existing config cache.

```shell
$ php vendor/bin/laminas servicemanager:generate-aot-factories [<target for generated factory config>]
```

--------------------------------

### Lazy services configuration structure

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/lazy-services.md

Expected config structure for the 'lazy_services' key. Includes class_map, proxies_target_dir, proxies_namespace, and write_proxy_files options.

```php
[
    // map of service names and their relative class names - this
    // is required since the service manager cannot know the
    // class name of defined services up front
    'class_map' => [
        // 'foo' => 'MyApplication\Foo',
    ],

    // directory where proxy classes will be written - default to system_get_tmp_dir()
    'proxies_target_dir' => null,

    // namespace of the generated proxies, default to "ProxyManagerGeneratedProxy"
    'proxies_namespace' => null,

    // whether the generated proxy classes should be written to disk or generated on-the-fly
    'write_proxy_files' => false,
];
```

--------------------------------

### addDelegator($name, $factory)

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/configuring-the-service-manager.md

Adds a delegator factory for a service. The factory can be a callable delegator or the name of a delegator factory class.

```APIDOC
## addDelegator($name, $factory)

### Description
Adds a delegator factory for a service. The factory can be a callable delegator or the name of a delegator factory class.

### Method
addDelegator

### Parameters
#### Request Body
- **name** (string) - Required - The service name.
- **factory** (callable|string) - Required - A callable delegator factory or the name of a delegator factory class.

### Request Example
```php
$serviceManager->addDelegator(DateTime::class, function ($container, $name, $callback) {
    $dateTime = $callback();
    $dateTime->setTimezone(new DateTimezone('UTC'));
    return $dateTime;
});
```

### Response
No return value.
```

--------------------------------

### setShared($name, $shared)

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/configuring-the-service-manager.md

Sets whether a service should be shared (i.e., a singleton) or not. When shared, the same instance is returned on each request.

```APIDOC
## setShared($name, $shared)

### Description
Sets whether a service should be shared (i.e., a singleton) or not. When shared, the same instance is returned on each request.

### Method
setShared

### Parameters
#### Request Body
- **name** (string) - Required - The service name.
- **shared** (boolean) - Required - Whether the service should be shared.

### Request Example
```php
$serviceManager->setShared(DateTime::class, false);
```

### Response
No return value.
```

--------------------------------

### Service manager configuration with aliases

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/delegators.md

Configures a service manager with a factory for Buzzer and an alias BuzzerInterface to Buzzer, allowing retrieval by either name.

```php
$serviceManager = new Laminas\ServiceManager\ServiceManager([
    'factories' => [
        Buzzer::class => Laminas\ServiceManager\Factory\InvokableFactory::class,
    ],
    'aliases' => [
        BuzzerInterface::class => Buzzer::class,
    ],
]);
```

--------------------------------

### Configure service manager for lazy services

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/lazy-services.md

Configures the service manager to generate proxies instead of real services. Requires mapping services to their class names in 'class_map' and adding LazyServiceFactory as a delegator.

```php
use MyApp\Buzzer;
use Laminas\ServiceManager\Factory\InvokableFactory;
use Laminas\ServiceManager\Proxy\LazyServiceFactory;
use Laminas\ServiceManager\ServiceManager;

$serviceManager = new \Laminas\ServiceManager\ServiceManager([
    'factories' => [
        Buzzer::class             => InvokableFactory::class,
    ],
    'lazy_services' => [
         // Mapping services to their class names is required
         // since the ServiceManager is not a declarative DIC.
         'class_map' => [
             Buzzer::class => Buzzer::class,
         ],
    ],
    'delegators' => [
        Buzzer::class => [
            LazyServiceFactory::class,
        ],
    ],
]);
```

--------------------------------

### Map lazy service with mapLazyService()

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/lazy-services.md

After obtaining a container instance, maps a lazy service/class pair using the mapLazyService method.

```php
$container->mapLazyService('foo', \MyApplication\Foo::class);
```

--------------------------------

### Configuring service manager with delegator

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/delegators.md

Registers the Buzzer service and its delegator factory in the ServiceManager. Fetching Buzzer returns a BuzzerDelegator instance.

```php
use Laminas\ServiceManager\Factory\InvokableFactory;
use Laminas\ServiceManager\ServiceManager;

$serviceManager = new Laminas\ServiceManager\ServiceManager([
    'factories' => [
        Buzzer::class => InvokableFactory::class,
    ],
    'delegators' => [
        Buzzer::class => [
            BuzzerDelegatorFactory::class,
        ],
    ],
]);

// now, when fetching Buzzer, we get a BuzzerDelegator instead
$buzzer = $serviceManager->get(Buzzer::class);

$buzzer->buzz(); // "Stare at the art!\nBuzz!"
```

--------------------------------

### Delegator factory signature

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/delegators.md

Defines the required signature for a delegator factory. The callback parameter is responsible for instantiating the delegated service, and options are typically used only during build() operations.

```php
use Interop\Container\ContainerInterface;

public function __invoke(
    ContainerInterface $container,
    $name,
    callable $callback,
    array $options = null
);
```

--------------------------------

### Retrieve the buzzer

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/lazy-services.md

Retrieves the buzzer service and calls its buzz method.

```php
use MyApp\Buzzer;

$buzzer = $serviceManager->get(Buzzer::class);
echo $buzzer->buzz();
```

--------------------------------

### Access plugin manager from within a factory

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/plugin-managers.md

Inside a factory for a service created by a plugin manager, the passed container is the parent service manager, not the plugin manager. To access other plugins of the same type, fetch the plugin manager from the container using its class name.

```php
function ($container, $name, array $options = []) {
     $validators = $container->get(ValidatorPluginManager::class);
     // ...
}
```

--------------------------------

### Delegator factory BuzzerDelegatorFactory

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/delegators.md

Implements DelegatorFactoryInterface to wrap the real service with an event manager and attach a listener. Uses the container to fetch the EventManager service.

```php
use Interop\Container\ContainerInterface;
use Laminas\ServiceManager\Factory\DelegatorFactoryInterface;

class BuzzerDelegatorFactory implements DelegatorFactoryInterface
{
    public function __invoke(ContainerInterface $container, $name, callable $callback, array $options = null)
    {
        $realBuzzer   = call_user_func($callback);
        $eventManager = $container->get('EventManager');

        $eventManager->attach('buzz', function () { echo "Stare at the art!\n"; });

        return new BuzzerDelegator($realBuzzer, $eventManager);
    }
}
```

--------------------------------

### Delegator targeting alias (no delegation)

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/delegators.md

Shows a configuration where a delegator targets the alias BuzzerInterface, which will not execute because delegators must target the resolved service name.

```php
$serviceManager = new Laminas\ServiceManager\ServiceManager([
    'factories' => [
        Buzzer::class => Laminas\ServiceManager\Factory\InvokableFactory::class,
    ],
    'aliases' => [
        BuzzerInterface::class => Buzzer::class,
    ],
    'delegators' => [
        BuzzerInterface::class => [
            BuzzerDelegatorFactory::class, // will not be executed
        ],
    ],
]);
```

--------------------------------

### Delegator targeting resolved service name

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/delegators.md

Correct configuration where the delegator targets the resolved service name Buzzer::class, enabling delegation to execute as expected.

```php
$serviceManager = new Laminas\ServiceManager\ServiceManager([
    'factories' => [
        Buzzer::class => Laminas\ServiceManager\Factory\InvokableFactory::class,
    ],
    'aliases' => [
        BuzzerInterface::class => Buzzer::class,
    ],
    'delegators' => [
        Buzzer::class => [
            BuzzerDelegatorFactory::class, // will now execute as expected
        ],
    ],
]);
```

--------------------------------

### Delegated object Buzzer

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/delegators.md

The original service class that will be wrapped by a delegator. Its buzz() method returns a simple string.

```php
class Buzzer
{
    public function buzz()
    {
        return 'Buzz!';
    }
}
```

--------------------------------

### Delegator class BuzzerDelegator

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/delegators.md

Decorates the Buzzer by triggering an event before delegating to the real service. Requires an EventManagerInterface instance.

```php
use Laminas\EventManager\EventManagerInterface;

class BuzzerDelegator extends Buzzer
{
    protected $realBuzzer;
    protected $eventManager;

    public function __construct(Buzzer $realBuzzer, EventManagerInterface $eventManager)
    {
        $this->realBuzzer   = $realBuzzer;
        $this->eventManager = $eventManager;
    }

    public function buzz()
    {
        $this->eventManager->trigger('buzz', $this);

        return $this->realBuzzer->buzz();
    }
}
```

--------------------------------

### Override validate() method for custom validation rules

Source: https://github.com/laminas/laminas-servicemanager/blob/4.6.x/docs/book/v4/plugin-managers.md

Overrides the validate() method to implement custom validation logic. The method returns without error if the instance is an instance of Foo or Bar; otherwise, it throws an InvalidServiceException with the message 'This is not a valid service!'.

```php
class ValidatorPluginManager extends AbstractPluginManager
{
    public function validate($instance)
    {
        if ($instance instanceof Foo || $instance instanceof Bar) {
            return;
        }

        throw new InvalidServiceException('This is not a valid service!');
    }
}
```
Tokens:
Raw