PHPackages                             hughnoble/injector - 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. [PSR & Standards](/categories/psr-standards)
4. /
5. hughnoble/injector

ActiveLibrary[PSR & Standards](/categories/psr-standards)

hughnoble/injector
==================

An easy to configure and flexible PSR-11 compliant IoC container for PHP

1.0.1(6y ago)07MITPHPPHP ^7.1

Since Feb 25Pushed 6y agoCompare

[ Source](https://github.com/HughNoble/Injector)[ Packagist](https://packagist.org/packages/hughnoble/injector)[ RSS](/packages/hughnoble-injector/feed)WikiDiscussions master Synced 1mo ago

READMEChangelog (1)Dependencies (2)Versions (3)Used By (0)

 [![Build Status](https://camo.githubusercontent.com/b94a2aa139174106fc553cf1ddcea29d574055100cc19ec8c3f3e97ac3301f17/68747470733a2f2f7472617669732d63692e6f72672f487567684e6f626c652f496e6a6563746f722e737667)](https://travis-ci.org/HughNoble/Injector)

Injector IoC
============

[](#injector-ioc)

An easy to configure and flexible PSR-11 compliant IoC container for PHP.

Basic Usage
-----------

[](#basic-usage)

The most simple use case is as below.

```
$map = new \Injector\Binding\BindingMap;
$container = \Injector\ContainerFactory::makeContainer($map);

// Any type hinted constructor parameters will be auto-wired.
$class = $container->get(MyClass::class);
```

Auto-Wiring
-----------

[](#auto-wiring)

By default the container will automatically attempt to resolve any dependencies it can without them needing to be bound.

```
class UserRepository
{
    public function __construct(EntityManager $user)
    ...
}
```

If the `EntityManager` class is instantiable (not an interface or abstract, and has no dependencies that can't be resolved) then the container will resolve it using the code below.

```
$userRepository = $container->get(UserRepository::class);
```

However if the dependency is an interface or abstract it will need binding. There are different ways to do this.

### Auto-Wired Binding

[](#auto-wired-binding)

The most common form of binding is by binding to a concrete so they can be auto wired.

```
$map->add(
    MyInterface::class,
    new Injector\Dependency\AutoWireDependency(MyConcrete::class)
);
```

### Closure Binding

[](#closure-binding)

```
$map->add(
    MyInterface::class,
    new Injector\Dependency\ClosureDependency(function($container){
        return new MyConcrete(
            $container->get(ChildInterface::class),
            'something-that-cannot-be-resolved'
        );
    })
);
```

In this example the closure will be run every time this dependency is requested. This means that if two classes require it within the same process they will both get new instances.

### Singleton Binding

[](#singleton-binding)

```
$childDependency = new Injector\Dependency\ClosureDependency(function($container){
    return new MyConcrete(
        $container->get(ChildInterface::class),
        'something-that-cannot-be-resolved'
    );
});

$map->add(
    MyInterface::class,
    new Injector\Dependency\SingletonBinding($childDependency)
);
```

In this case the closure within `$childDependency` will be run the first time it is requested and then cached. Subsequent calls will result in the same instance being returned.

Child dependencies for singletons can also be auto wire bindings. This is useful when you always want the same instance and isn't limited to interface binding.

```
$childDependency = new Injector\Dependency\AutoWireDependency(MyClass::class);

$map->add(
    new Injector\Dependency\SingletonDependency(MyClass::class, $childDependency)
);
```

By binding a class to itself as a singleton it ensures the same instance will always be returned.

Injecting the Container
-----------------------

[](#injecting-the-container)

The following reserved bindings can be used to access the container as a dependency.

`Injector\Container` and `Psr\Container\ContainerInterface` will always resolve to the instance of the container.

`Injector\Binding\BindingMapInterface` will always resolve to the binding map in use by the container.

This is useful when you might want programmatic binding through providers.

```
class UserServiceProvider
{
    private $bindingMap;

    public function __construct(\Injector\Binding\BindingMapInterface $bindingMap)
    {
        $this->bindingMap = $bindingMap;
    }

    public function bindDependencies()
    {
        $this->bindingMap->add(
            UserRepositoryInterface::class,
            new \Injector\Binding\AutoWireBinding(UserRepository::class)
        );
    }
}
```

###  Health Score

25

—

LowBetter than 37% of packages

Maintenance20

Infrequent updates — may be unmaintained

Popularity4

Limited adoption so far

Community6

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 ~445 days

Total

2

Last Release

2549d ago

### Community

Maintainers

![](https://www.gravatar.com/avatar/d8c8b8ce59106335d9365353d31052e0ecbe46485df1b571b5ec6c6e41c5314a?d=identicon)[HughNoble](/maintainers/HughNoble)

---

Top Contributors

[![HughNoble](https://avatars.githubusercontent.com/u/6029435?v=4)](https://github.com/HughNoble "HughNoble (14 commits)")

---

Tags

containerdependencyinjectionioc

###  Code Quality

TestsPHPUnit

### Embed Badge

![Health badge](/badges/hughnoble-injector/health.svg)

```
[![Health](https://phpackages.com/badges/hughnoble-injector/health.svg)](https://phpackages.com/packages/hughnoble-injector)
```

###  Alternatives

[league/container

A fast and intuitive dependency injection container.

86387.8M342](/packages/league-container)[capsule/di

A PSR-11 compliant autowiring dependency injection container.

2857.5k2](/packages/capsule-di)[miladrahimi/phpcontainer

Dependency injection (IoC) container for PHP projects

1322.7k2](/packages/miladrahimi-phpcontainer)[slince/di

A flexible dependency injection container

20260.4k6](/packages/slince-di)

PHPackages © 2026

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