PHPackages                             rafaeltovar/php-service-manager - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Framework](/categories/framework)
4. /
5. rafaeltovar/php-service-manager

ActiveLibrary[Framework](/categories/framework)

rafaeltovar/php-service-manager
===============================

Simple, light, minimum service manager and dependency injection for PHP.

v1.0.4(5y ago)16.1k↓50%MITPHPPHP >=7.0

Since Feb 8Pushed 5y ago1 watchersCompare

[ Source](https://github.com/rafaeltovar/php-service-manager)[ Packagist](https://packagist.org/packages/rafaeltovar/php-service-manager)[ Docs](https://github.com/rafaeltovar/php-service-manager)[ RSS](/packages/rafaeltovar-php-service-manager/feed)WikiDiscussions master Synced 1mo ago

READMEChangelogDependencies (1)Versions (6)Used By (0)

ServiceManager for PHP
======================

[](#servicemanager-for-php)

Simple, light, minimum service manager and dependency injection for PHP.

Installation
------------

[](#installation)

### Composer

[](#composer)

Execute:

```
composer require rafaeltovar/php-service-manager

```

Features
--------

[](#features)

- Dependency injection
- Service container
- Providers
- Singleton strategy
- Initialized only if service is called
- Alias

Documentation
-------------

[](#documentation)

### Service container

[](#service-container)

The **service container** is the main service controller for manage the service queue.

```
// myproject.php
use MyServiceAProvider;

$serviceContainer = new \ServiceManager\ServiceContainer(
                            [MyServiceAProvider::class]
                        );
```

### Service Providers

[](#service-providers)

This is my service.

```
// MyServiceA.php
class MyServiceA
{
    public function test()
    {
        echo "Working.";
    }
}
```

This is my service **provider**.

```
// MyServiceAProvider.php
class MyServiceAProvider
extends \ServiceManager\ServiceProvider
{
    /**
     * This method return the service class name (mandatory)
     **/
    public function getServiceType() : string
    {
        return MyServiceA::class;
    }

    /**
     * This method return the identification of the service
     * into Service Container (mandatory)
     **/
    public function getServiceId(): string
    {
        return "my-service-a";
    }

    /**
     * This method return the service (mandatory)
     **/
    public function getService()
    {
        return new MyServiceA();
    }
}
```

#### Passing custom arguments to the provider

[](#passing-custom-arguments-to-the-provider)

Sometimes We need pass some arguments to the provider for initialize the service, like the config or logger, for example. In this case we need implements `\ServiceManager\ServiceProviderArgumentsInterface`.

`MyCustomArguments` will have the arguments it needs.

```
// myproject.php
use MyServiceDebugProvider,
    MyServiceAProvider;

use MyCustomArguments;

//...
$serviceContainer = new \ServiceManager\ServiceContainer(
                            [
                                MyServiceAProvider::class,
                                MyServiceDebugProvider::class
                            ],
                            [],
                            new MyCustomArguments($myLogger)
                        );
```

```
// MyCustomArguments.php
class MyCustomArguments
implements \ServiceManager\ServiceProviderArgumentsInterface
{
    protected $logger;

    public function __construct(\Psr\Log\LoggerInterface $logger)
    {
        $this->logger = $logger;
    }

    public function getLogger() : \Psr\Log\LoggerInterface
    {
        return $this->logger;
    }
}
```

My example service with argument:

```
// MyServiceDebug.php
class MyServiceDebug
{
    protected $logger;

    public function __construct(\Psr\Log\LoggerInterface $logger)
    {
        $this->logger = $logger;
    }

    public function write(string $text)
    {
        $this->logger->debug($text);
    }
}
```

My example service provider:

```
// MyServiceDebugProvider.php
class MyServiceDebugProvider
extends \ServiceManager\ServiceProvider
{
    public function getServiceType() : string
    {
        return MyServiceDebug::class;
    }

    public function getServiceId(): string
    {
        return "debug";
    }

    public function getService()
    {
        $logger = $this->getProviderArguments()->getLogger();
        return new MyServiceDebug($logger);
    }
}
```

### Getting a service

[](#getting-a-service)

```
$serviceContainer->get("my-service-a")->test();
```

```
// result:
Working.

```

Dependency injection
--------------------

[](#dependency-injection)

```
// MyController.php
class MyController
{
    protected $a;

    public function __construct(MyServiceA $a)
    {
        $this->a = $a;
    }
    public function test()
    {
        $this->a->test();
    }
}
```

```
use MyController;

//...
$myCtrl = $serviceContainer->build(MyController::class);
$myCtrl->test();
```

```
// result:
Working.

```

### Custom builders

[](#custom-builders)

Sometime our controller need other controller or data, not a service. In those cases we can create a custom constructor implements `ControllerBuilderCreateInterface`.

```
// MyController.php
use ServiceManager\ServiceContainer,
    ServiceManager\ControllerBuilderCreateInterface;

class MyController
implements ControllerBuilderCreateInterface
{
    protected $public;

    public function __construct(string $publicFolder)
    {
        $this->public = $publicFolder;
    }

    public static function create(ServiceContainer $services)
    {
        return new MyController(
            $services->get('config')->get("PUBLIC_FOLDER")
        );
    }
}
```

Now we can build our controller. The service container will call to `create` method if implements `ControllerBuilderCreateInterface`.

```
use MyController;

//...
$myCtrl = $serviceContainer->build(MyController::class);
```

### Alias

[](#alias)

Other times we need to work with interfaces, we can use aliases to obtain the services that implement these interfaces.

```
// myproject.php
use MyServiceDebugProvider,
    MyServiceAProvider;

use MyCustomArguments;

//...
$serviceContainer = new \ServiceManager\ServiceContainer(
                            [
                                MyLoggerProvider::class,
                            ],
                            [ // aliases
                                // interface => service id
                                \Psr\Log\LoggerInterface::class => "logger"
                            ]
                        );
```

```
// MyServiceDebugProvider.php
use Monolog\Logger;
use Monolog\Handler\StreamHandler;

class MyLoggerProvider
extends \ServiceManager\ServiceProvider
{
    public function getServiceType() : string
    {
        return Logger::class;
    }

    public function getServiceId(): string
    {
        return "logger";
    }

    public function getService()
    {
        $log = new Logger('name');
        $log->pushHandler(new StreamHandler('path/to/your.log', Logger::WARNING));
        return $log;
    }
}
```

Now we can build our controller with interface dependency.

```
// MyController.php
class MyController
{
    protected $logger;

    public function __construct(\Psr\Log\LoggerInterface $logger)
    {
        $this->logger = $logger; // this logger will be \Monolog\Logger
    }

    // ...
}
```

```
use MyController;

//...
$myCtrl = $serviceContainer->build(MyController::class);
```

###  Health Score

31

—

LowBetter than 68% of packages

Maintenance20

Infrequent updates — may be unmaintained

Popularity24

Limited adoption so far

Community7

Small or concentrated contributor base

Maturity59

Maturing project, gaining track record

 Bus Factor1

Top contributor holds 100% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Every ~157 days

Total

5

Last Release

2028d ago

### Community

Maintainers

![](https://avatars.githubusercontent.com/u/791726?v=4)[Rafael Tovar](/maintainers/rafaeltovar)[@rafaeltovar](https://github.com/rafaeltovar)

---

Top Contributors

[![rafaeltovar](https://avatars.githubusercontent.com/u/791726?v=4)](https://github.com/rafaeltovar "rafaeltovar (16 commits)")

---

Tags

dependency-injectionphpservice-manager

### Embed Badge

![Health badge](/badges/rafaeltovar-php-service-manager/health.svg)

```
[![Health](https://phpackages.com/badges/rafaeltovar-php-service-manager/health.svg)](https://phpackages.com/packages/rafaeltovar-php-service-manager)
```

###  Alternatives

[cakephp/cakephp

The CakePHP framework

8.8k18.5M1.6k](/packages/cakephp-cakephp)[silverstripe/framework

The SilverStripe framework

7213.5M2.5k](/packages/silverstripe-framework)[drupal/core-recommended

Locked core dependencies; require this project INSTEAD OF drupal/core.

6939.5M343](/packages/drupal-core-recommended)[cakephp/core

CakePHP Framework Core classes

6126.8M39](/packages/cakephp-core)[contao/core-bundle

Contao Open Source CMS

1231.6M2.4k](/packages/contao-core-bundle)[neos/flow

Flow Application Framework

862.0M451](/packages/neos-flow)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)