How to write laravel dependency injection

As a popular PHP framework, one of Laravel’s core features is the dependency injection (Dependency Injection, hereinafter referred to as DI) mechanism. Using dependency injection can decouple an object's dependencies from the object itself, thereby improving the readability, testability, and maintainability of the code. This article will introduce how Laravel dependency injection is implemented and how to use it.

1. Basic concepts

Dependency injection is a design pattern. Its core idea is to decouple the dependencies required by the object from the object itself to achieve Reduce coupling, improve testability, improve maintainability and other purposes. In the Laravel framework, the implementation of the DI mechanism is based on the Dependency Injection Container (hereinafter referred to as the DI container), which mainly includes the following points:

• Automatic injection of object attributes: The DI container will The properties of the injected object need to be injected automatically.
• Automatic binding and resolution of dependencies: The DI container will automatically bind and resolve dependencies between classes.
• Singleton mode support: DI container can support the use of singleton mode.

After understanding the basic concept of DI container, we can start to explore its specific implementation in the Laravel framework.

2. Implementation of DI container

In the Laravel framework, the implementation of the DI container is based on the service container (Service Container), which is the App class. The App class is the core class of the entire application. It is responsible for managing, registering and resolving all services and dependencies that need to be used. Therefore, it is also the core class of the DI container in Laravel. Let's take a look at the specific implementation of the service container.

2.1 Service registration and resolution

Service registration in Laravel mainly includes two steps: registering a service provider and registering a service. Registering a service provider is to facilitate unified management and registration of services instead of manually registering services every time. The registration service is to inject objects into the DI container for subsequent parsing.

The registered service provider can be configured in the config/app.php configuration file. Just add the service provider in the providers array. For example:

'providers' => [
    // Laravel Framework Service Providers...
    IlluminateAuthAuthServiceProvider::class,
    IlluminateBroadcastingBroadcastServiceProvider::class,
    IlluminateBusBusServiceProvider::class,
    IlluminateCacheCacheServiceProvider::class,

    // Application Service Providers...
    AppProvidersAppServiceProvider::class,
    AppProvidersAuthServiceProvider::class,
    AppProvidersEventServiceProvider::class,
    AppProvidersRouteServiceProvider::class,
],

The registration service can be registered through the bind method of the App class. For example:

// 将Foo类注册到DI容器中
app()->bind('foo', function() {
    return new Foo();
});

In the above sample code, we register the Foo class into the DI container through the bind method and specify its corresponding alias as foo. Note that in Laravel, you can specify an alias for the service to make it easier to parse and call.

The parsing service can be parsed through the make method of the App class. For example:

// 通过别名解析Foo类实例
$foo = app('foo');

2.2 Automatic resolution of services

In Laravel, the DI container will automatically resolve the dependencies between classes, so we do not need to manually pass the dependencies and let the DI container automatically Help us solve dependency injection problems. For example, we have the following two classes:

class Foo {
    public function __construct(Bar $bar) {}
}

class Bar {
    public function __construct(Baz $baz) {}
}

Here, the Foo class depends on the Bar class, and the Bar class depends on the Baz class. If we want to create an instance of the Foo class, then we only need to resolve it through the DI container:

// 自动解析依赖关系，并通过DI容器创建Foo类实例
$foo = app(Foo::class);

Here, the DI container will automatically create instances of the Bar and Baz classes and inject them into the Foo class in the constructor.

2.3 Singleton mode of service

In Laravel, we can register the service as singleton mode through the singleton method, which means that the same instance will be returned every time the service is called. For example:

// 将Foo类注册为单例模式
app()->singleton('foo', function() {
    return new Foo();
});

Here, we register the Foo class as a singleton mode through the singleton method, which means that the same instance of the Foo class will be returned every time the foo service is called.

3. Summary

Laravel's DI container mechanism greatly simplifies the implementation process of dependency injection, allowing us to manage and use dependencies more flexibly and conveniently. When using the Laravel framework, mastering the use of DI containers will greatly improve our development efficiency, and will also bring many benefits in terms of code testability and maintainability. This article introduces the basic concepts, implementation and usage of DI containers in Laravel. I hope it can be helpful to everyone.

The above is the detailed content of How to write laravel dependency injection. For more information, please follow other related articles on the PHP Chinese website!