A simple dependency injecting container from laravel.
, (*1)
Why
Currently more popular php container:, (*2)
Pimple is a simple and excellent php 5.3 container, which is also the most used service container, and the installed capacity of packagist is also up to 1000W+ .But Pimple just a simple service container that does not support many features such as:, (*3)
class Cache
{
public function __construct(Config $config){}
}
class Config
{
}
// not support
$cache = $container->make('Cache');
Pimple Does not support the automatic injection of dependency parameters, when you need to rely on other objects object, you can only instantiate the required parameters., (*4)
Laravel Container is the most full-featured service container, including auto-injection, load-loading, alias, TAG, and so so. But the official does not recommend using the component in non-laravel project., (*5)
If you have noticed the composer.json file under that component，You will find that he depends on the illuminate/contracts component.(see also), (*6)
Based on this, easy-container was born, and the project code relied heavily on Laravel Container :smile: :smile: . You can use it like a Laravel Container container., (*7)
Install
| SDK Version |
PHP Version |
Composer Command |
| 3.x |
>= 8.1 |
composer require "easy-container:^3.0" |
| 2.x |
>= 7.2 |
composer require "easy-container:^2.1" |
| 1.x |
>= 5.6 |
composer require "easy-container:^2.1" |
Use
You can get more help with container usage at laravel.com., (*8)
Initialize the container., (*9)
$app = new Godruoyi\Container\Container;
The following documents support from laravel.com, reproduced please indicate the source., (*10)
Simple Bindings
We can register a binding using the bind method, passing the class or interface name that we wish to register along with a Closure that returns an instance of the class:, (*11)
$app->bind('HelpSpot\API', function ($app) {
return new HelpSpot\API($app->make('HttpClient'));
});
Note,All anonymous functions accept the service container instance as a parameter., (*12)
Binding A Singleton
The singleton method binds a class or interface into the container that should only be resolved one time. Once a singleton binding is resolved, the same object instance will be returned on subsequent calls into the container:, (*13)
$app->singleton('HelpSpot\API', function ($app) {
return new HelpSpot\API($app->make('HttpClient'));
});
Each time you call $app['HelpSpot\API'] will return the same object., (*14)
Binding A Singleton
The singleton method binds a class or interface into the container that should only be resolved one time. Once a singleton binding is resolved, the same object instance will be returned on subsequent calls into the container:, (*15)
$api = new HelpSpot\API(new HttpClient);
$app->instance('HelpSpot\API', $api);
Binding Interfaces To Implementations
A very powerful feature of the service container is its ability to bind an interface to a given implementation. For example, let's assume we have an EventPusher interface and a RedisEventPusher implementation. Once we have coded our RedisEventPusher implementation of this interface, we can register it with the service container like so:, (*16)
$app->bind(
'App\Contracts\EventPusher',
'App\Services\RedisEventPusher'
);
This statement tells the container that it should inject the RedisEventPusher when a class needs an implementation of EventPusher. Now we can type-hint the EventPusher interface in a constructor, or any other location where dependencies are injected by the service container:, (*17)
use App\Contracts\EventPusher;
/**
* Create a new instance of the class, which will be injected into the App\Services\RedisEventPusher instance.
*
* @param EventPusher $pusher
* @return void
*/
public function __construct(EventPusher $pusher)
{
$this->pusher = $pusher;
}
Resolving
The make Method
You may use the make method to resolve a class instance out of the container(regardless of what type of parameter the object needs). The make method accepts the name of the class or interface you wish to resolve:, (*18)
$api = $app->make('HelpSpot\API');
The mark method is the most important method I think of,You can simply use the "type prompt" way to add dependencies,the container will automatically parse all the parameters you need., (*19)
// Automatically parses the dependencies required by the UserController constructor
$userController = $app->make(UserController::class);
class UserController
{
public function __construct(UserRepository $users, HttpClient $client, $other = 'default')
{
}
}
PSR-11
Laravel's service container implements the PSR-11 interface. Therefore, you may type-hint the PSR-11 container interface to obtain an instance of the Laravel container:, (*20)
use Psr\Container\ContainerInterface;
$service = $app->get('Service');
LISTEN
MIT, (*21)
Thanks
laravel-china, (*22)
Wallogit.com
godruoyi