Download the PHP package radutopala/mnapoli-php-di without Composer
On this page you can find all versions of the php package radutopala/mnapoli-php-di. It is possible to download/install these versions without Composer. Possible dependencies are resolved automatically.
Download radutopala/mnapoli-php-di
More information about radutopala/mnapoli-php-di
Files in radutopala/mnapoli-php-di
Package mnapoli-php-di
Short Description PHP-DI is a Container that makes Dependency Injection as practical as possible in PHP
License MIT
Homepage http://mnapoli.github.com/PHP-DI/
Informations about the package mnapoli-php-di
PHP-DI is a Container that makes Dependency Injection as practical as possible.
PHP-DI also tries to avoid falling into the trap of the "Service Locator" antipattern and help you do real dependency injection.
Features
- Simple to start with
- Supports different configuration alternatives to suit every taste:
- Reflection: zero configuration, intelligent guessing
- Annotations: modern, practical and simple
- PHP code: if you like complete control and auto-completion
- PHP array: allows you to store it in a configuration file
- YAML: elegant and concise
- XML (work in progress): more verbose, but more classic
- Performances: supports a large number of Caches
- Offers lazy injection: lazy-loading of dependencies (WIP)
- Supports constructor injection, setter injection and property injection
Usage
Let's go to the Getting started guide!
And there is a complete documentation waiting for you.
What is dependency injection, and why use PHP-DI
You can first read the introduction to dependency injection with an example.
Dependency injection and DI containers are separate notions, and one should use of a container only if it makes things more practical (which is not always the case depending on the container you use).
PHP-DI is about this: make dependency injection more practical.
How classic PHP code works
Here is how a code not using DI will roughly work:
- Application needs Foo (e.g. a controller), so:
- Application creates Foo
- Application calls Foo
- Foo needs Bar (e.g. a service), so:
- Foo creates Bar
- Foo calls Bar
- Bar needs Bim (a service, a repository, …), so:
- Bar creates Bim
- Bar does something
How Dependency Injection works
Here is how a code using DI will roughly work:
- Application needs Foo, which needs Bar, which needs Bim, so:
- Application creates Bim
- Application creates Bar and gives it Bim
- Application creates Foo and gives it Bar
- Application calls Foo
- Foo calls Bar
- Bar does something
- Foo calls Bar
This is the pattern of Inversion of Control. The control of the dependencies is inversed from one being called to the one calling.
The main advantage: the one at the end of the caller chain is always you. So you can control every dependencies: you have a complete control on how your application works. You can replace a dependency by another (one you made for example).
For example that wouldn't be so easy if Library X uses Logger Y and you have to change the code of Library X to make it use your logger Z.
How code using PHP-DI works
Now how does a code using PHP-DI works:
- Application needs Foo so:
- Application gets Foo from the Container, so:
- Container creates Bim
- Container creates Bar and gives it Bim
- Container creates Foo and gives it Bar
- Application calls Foo
- Foo calls Bar
- Bar does something
- Foo calls Bar
In short, PHP-DI takes away all the work of creating and injecting dependencies.
All versions of mnapoli-php-di with dependencies
doctrine/annotations Version 1.*
doctrine/cache Version 1.*
myclabs/php-enum Version 1.*
symfony/yaml Version 2.*