Download the PHP package hgraca/micro-di without Composer
On this page you can find all versions of the php package hgraca/micro-di. It is possible to download/install these versions without Composer. Possible dependencies are resolved automatically.
Download hgraca/micro-di
More information about hgraca/micro-di
Files in hgraca/micro-di
Package micro-di
Short Description A small dependency injection library that uses reflection and a service locator container, to instantiate and recursively resolve, instantiate and inject dependencies.
License MIT
FAQ
Example:
In general, it is recommended to use always a project to download your libraries. In an application normally there is more than one library needed.
- Some hosting areas are not accessible by a terminal or SSH. Then it is not possible to use Composer.
- To use Composer is sometimes complicated. Especially for beginners.
- Composer needs much resources. Sometimes they are not available on a simple webspace.
- If you are using private repositories you don't need to share your credentials. You can set up everything on our site and then you provide a simple download link to your team member.
- Simplify your Composer build process. Use our own command line tool to download the vendor folder as binary. This makes your build process faster and you don't need to expose your credentials for private repositories.
Informations about the package micro-di
Hgraca\MicroDI
A small dependency injection library that uses reflection and a service locator container, to instantiate and recursively resolve, instantiate and inject dependencies.
Installation
To install the library, run the command below and you will get the latest version:
Usage
Factories
The factories used in Builder::buildFromFactory need to extend Hgraca\MicroDI\FactoryInterface.
The method Builder::buildFromFactory instantiates the factory and calls the create method on it.
The arguments given to Builder::buildFromFactory will be used both when instantiating the factory and when
calling the create method:
- They will be injected in the
__construct()if the arguments keys match any of the dependencies names. - They will all be injected in the
create(), together with whatever is in the container with the key '.context', where is the relevant factory FQCN.
Dependency resolution process
The builder will resolve and instantiate dependencies. The dependencies, both when instantiating and when calling
a method with Builder::call, will fe filled in the following priority:
- By matching the dependencies names with the name of the provided arguments
- If its a class/interface, it will try to instantiate it, which in turn:
- tries to fetch it from the container, by searching for the class/interface fqcn as one of the containers keys
- If the key (class/interface fqcn) is found:
- If its an instance, it will be used (singleton)
- If its a closure, it will be used to instantiate the required class (singleton)
- If its a factory, it will be used to build the required class through the method
Builder::buildFromFactory, and build a new instance every time (making it not a singleton)
- If the key (class/interface fqcn) is not found:
- If its a class it will be instantiated (recursively resolving and injecting its dependencies) and it will be cached in the container
- If its an interface, an error will be thrown
- If the key (class/interface fqcn) is found:
- tries to fetch it from the container, by searching for the class/interface fqcn as one of the containers keys
- If its not a class/interface it will try to find the dependencies in the container, by their name.
- If it fails to find all mandatory dependencies, it will throw an error while instantiating the class.
