Download the PHP package bapcat/phi without Composer

φhi

An efficient, easy-to-use, open-source PHP dependency injection container, boasting a tiny footprint, powerful features, 100% unit test coverage, and awesome documentation. Phi is compatible with PSR-0 and PSR-4 auto-loading standards, and open to collaboration from anyone who feels they can make an improvement.

Installation

Composer

Composer is the recommended method of installation for BapCat packages.

GitHub

BapCat packages may be downloaded from GitHub.

Features

Phi supports several different ways to inject dependencies, which can all be used alone or in conjunction with one another.

Automatic Injection

Assume you have a class named Foo that depends on a second class, Bar:

You can easily get a new instance of Foo with all required dependencies by doing the following:

You'll get a new instance of Foo with a new instance of Bar automatically injected into the constructor. This, of course, works recursively. If Bar depends on Baz, an instance of Baz will be injected into Bar, and so on.

Passing Parameters

There will be many cases where you need to pass parameters into the constructors as well. Consider the following class (note the order of the parameters):

There are several ways you can request this class from Phi:

You may want to override an automatically injected parameter:

Note that $a was passed in last in the previous example. Phi is smart enough to figure out the correct order to inject parameters of non-scalar types.

Multiple Same-Type Dependencies

Consider the following class:

Parameters of the same type will be passed to the constructor in the order they are given to Phi. If you would like to pass them in a different order, please see the section on named injection.

Named Injection

In some cases, it is useful to be explicit about which parameters you are passing in. Phi makes this easy. Consider the class from the "Passing Parameters" section:

Binding

Many modern applications have pieces that may be swapped out. This is accomplished by using interfaces. Phi allows automatic injection of interfaces using binding:

Binding even allows you to swap one concrete instance of a class for another:

Dependencies With Parameters

Sometimes you may have a dependency that has required parameters. This can be done by binding a class to a callable:

This is also useful if you need to perform logic when instanciating a class:

Any parameters passed to Phi will be passed directly to the callable:

Singletons

Phi also allows binding to real instances of classes. This can be used to create singletons:

Aliases

Sometimes, a codebase will have very commonly used classes with difficult-to remember names. For example, Vendor\Package\Core\Logging\Log. It may be useful to give such classes shorter and easier to type names:

You may also bind aliases to callables or singletons.

Custom Resolvers

There may be times when you want to match far more than a single alias. Custom resolvers were designed with this purpose in mind. When a binding is requested from Phi, any custom resolvers that are registered will be executed one by one in the order they were added, and the first one to return a non-null value is the one that will be used. If all custom resolvers return null, Phi will resolve the binding normally.

Another reason to use custom resolvers is to wrap other IoC containers. For example, if you are using Laravel, you could combine the Laravel container with Phi:

This way, any binding that is registered in the Laravel IoC container will be resolved by it. The rest will be passed on to Phi.

Recursive Resolution

It's possible to bind one binding to another.

php $phi->singleton(FooInterface::class, Foo::class);

The first time an instance of `FooInterface` is requested, `Foo` will be loaded and bound.  From then on, all
requests for `FooInterface` will return the same instance of `Foo`.

### Dependency Injection on Callables
Not only is dependency injection useful when creating objects, it may also be useful when calling methods.  Phi can
perform dependency injection on any method PHP will accept as a `callable` type hint.

You may pass arguments to method injections in the same way as constructor injections.