2017 © Pedro Peláez
 

library dependency-injection

A dependency injection container

image

gandung/dependency-injection

A dependency injection container

  • Sunday, June 25, 2017
  • by gandung
  • Repository
  • 1 Watchers
  • 2 Stars
  • 104 Installations
  • PHP
  • 1 Dependents
  • 0 Suggesters
  • 1 Forks
  • 0 Open issues
  • 7 Versions
  • 0 % Grown

The README.md

Simple Dependency Injection Library

Join the chat at https://gitter.im/dependency-injection-container/Lobby, (*1)

Coverage Status Scrutinizer Code Quality Build Status SensioLabsInsight, (*2)

This is my simple dependency injection library in PHP, (*3)

Features:

  - Can resolve class dependency that placed only on constructor (autowiring)
  - Binding concrete dependency into unresolved abstract, either closure or class name.
  - Can do shared binding concrete dependency into unresolved abstract, either closure or class name.
  - Can resolve concrete implementation on typehinted interface on constructor method.
  - Can resolve concrete implementation which bound on interface directly.
  - Registering service under an alias.

Setter injection and method injection not yet implemented. Feel free to look, or clone it for your own needs., (*4)

Autowiring:

Assume you have a class:, (*5)

<?php

namespace Unused;

class Foo
{
    /**
     * @var \SplPriorityQueue
     */
    private $heap;

    public function __construct(\SplPriorityQueue $heap)
    {
        $this->heap = $heap;
    }   
}

And you have a class that depends on class Unused\Foo, however class Unused\Foo depends on class \SplPriorityQueue, (*6)

<?php

namespace Unused;

class Bar
{
    /**
     * @var Foo
     */
    private $foo;

    public function __construct(Foo $foo)
    {
        $this->foo = $foo;
    }
}

You can resolve an instance of class Bar without resolving Bar and \SplPriorityQueue manually, (*7)

<?php

use Unused\Bar;

$container = new Container();

$bar = $container->make(Bar::class);

Binding concrete dependency into unresolved abstract (only class name)

<?php

use Unused\Bar;
use Unused\Foo;

$container = new Container();

$container->bind(Bar::class, Foo::class);

$bar = $container->make(Bar::class);

Now, $bar is an instance of Bar::class., (*8)

Binding concrete dependency into unresolved abstract (with closure)

<?php

use Unused\Bar;
use Unused\Foo;

$container = new Container();

$container->bind(Bar::class, function($container) {
    return $container->make(Foo::class);
});

$bar = $container->make(Bar::class);

Now, $bar is an instance of Bar::class too., (*9)

Shared binding concrete dependency into unresolved abstract (only class name)

<?php

use Unused\Base;
use Unused\BaseInterface;

$container = new Container();

$container->singleton(BaseInterface::class, Base::class);

$base = $container->make(BaseInterface::class);

Shared binding concrete dependency into unresolved abstract (with closure)

<?php

use Unused\Base;
use Unused\BaseInterface;

$container = new Container();

$container->singleton(BaseInterface::class, function($container) {
    return $container->make(Base::class);
});

$base = $container->make(BaseInterface::class);

Binding typehinted interface into unresolved abstract (class based and with closure)

Assume you have an BaseInterface interface:, (*10)

<?php

namespace Unused;

interface BaseInterface
{
    public function setFirstName($firstName);

    public function setMiddleName($middleName);

    public function setLastName($lastName);
}

And a class which implements BaseInterface interface under the same namespace:, (*11)

<?php

namespace Unused;

class Base implements BaseInterface
{
    /**
     * @var string
     */
    private $firstName;

    /**
     * @var string
     */
    private $middleName;

    /**
     * @var string
     */
    private $lastName;

    public function setFirstName($firstName)
    {
        $this->firstName = $firstName;
    }

    public function setMiddleName($middleName)
    {
        $this->middleName = $middleName;
    }

    public function setLastName($lastName)
    {
        $this->lastName = $lastName;
    }
}

And a class which have typehinted interface in it's constructor, (*12)

<?php

namespace Unused;

class Foo
{
    /**
     * @var BaseInterface
     */
    private $base;

    public function __construct(BaseInterface $base)
    {
        $this->base = $base;
    }
}

You can resolve class Foo with binding class Base into BaseInterface first., (*13)

<?php

use Unused\BaseInterface;
use Unused\Base;
use Unused\Foo;

$container = new Container();

$container->bind(BaseInterface::class, Base::class);

$foo = $container->make(Foo::class);

Or, you and bind concrete implementation of BaseInterface with closure, (*14)

<?php

use Unused\BaseInterface;
use Unused\Base;
use Unused\Foo;

$container = new Container();

$container->bind(BaseInterface::class, function($container) {
    return $container->make(Base::class);
});

$foo = $container->make(Foo::class);

Resolve concrete implementation which bound on interface directly

Assume you have an interface:, (*15)

<?php

namespace Unused;

interface BaseInterface
{
    public function setFirstName($firstName);

    public function setMiddleName($middleName);

    public function setLastName($lastName);
}

And, concrete class which implements Unused\BaseInterface, (*16)

<?php

namespace Unused;

class Base implements BaseInterface
{
    /**
     * @var string
     */
    private $firstName;

    /**
     * @var string
     */
    private $middleName;

    /**
     * @var string
     */
    private $lastName;

    /**
     * @implements
     */
    public function setFirstName($firstName)
    {
        $this->firstName = $firstName;
    }

    /**
     * @implements
     */
    public function setMiddleName($middleName)
    {
        $this->middleName = $middleName;
    }

    /**
     * @implements
     */
    public function setLastName($lastName)
    {
        $this->lastName = $lastName;
    }
}

Bind concrete implementation on that interface first (use either direct class name or closure), (*17)

<?php

use Unused\Base;
use Unused\BaseInterface;

$container = new Container();

// with direct class name.
$container->bind(BaseInterface::class, Base::class);

// or, use a closure.
$container->bind(BaseInterface::class, function($container) {
    return $container->make(Base::class);
});

Then, get it directly., (*18)

$base = $container->make(BaseInterface::class);

Registering service under an alias (PSR-11 compatible.)

Assume you have a service which require a concrete implementation of a BaseInterface:, (*19)

<?php

namespace Unused;

class FooService
{
    /**
     * @var BaseInterface
     */
    private $base;

    public function __construct(BaseInterface $base)
    {
        $this->base = $base;
    }
}

Just bind a concrete implementation of BaseInterface, then register FooService under an alias (e.g: foo.service), (*20)

<?php

$container = new Container();

$container->bind(BaseInterface::class, function($container) {
    return $container->make(Base::class);
});

$container->register('foo.service', FooService::class);

$service = $container->get('foo.service');

Unit Testing

If you want to run unit tests:, (*21)

vendor/bin/phpunit

If you need more verbose:, (*22)

vendor/bin/phpunit --verbose

The Versions

25/06 2017

dev-master

9999999-dev

A dependency injection container

  Sources   Download

MIT

The Requires

 

The Development Requires

by Paulus Gandung Prakosa

container dependency-injection dependency-manager

25/06 2017

v1.0.4

1.0.4.0

A dependency injection container

  Sources   Download

MIT

The Requires

 

The Development Requires

by Paulus Gandung Prakosa

container dependency-injection dependency-manager

02/06 2017

v1.0.3

1.0.3.0

A dependency injection container

  Sources   Download

MIT

The Requires

 

The Development Requires

by Paulus Gandung Prakosa

container dependency-injection dependency-manager

01/06 2017

v1.0.2

1.0.2.0

A dependency injection container

  Sources   Download

MIT

The Requires

 

The Development Requires

by Paulus Gandung Prakosa

container dependency-injection dependency-manager

31/05 2017

v1.0.1

1.0.1.0

A dependency injection container

  Sources   Download

MIT

The Requires

  • php >=5.6.0 || >=7.1.0

 

The Development Requires

by Paulus Gandung Prakosa

container dependency-injection dependency-manager

28/05 2017

v1.0.0

1.0.0.0

A dependency injection container

  Sources   Download

MIT

The Requires

  • php >=5.6.0

 

The Development Requires

by Paulus Gandung Prakosa

container dependency-injection dependency-manager

28/05 2017

v1.0.1-beta

1.0.1.0-beta

A dependency injection container

  Sources   Download

MIT

The Requires

  • php >=5.6.0

 

The Development Requires

by Paulus Gandung Prakosa

container dependency-injection dependency-manager