Take you step by step to understand dependency injection in laravel

1. What is Dependency Injection

Dependency Injection (Dependency Injection) is a design pattern that achieves object decoupling by passing dependent objects to objects. In other words, dependency injection is a technology that passes dependent objects through constructors, properties, or methods, making the relationship between classes looser and reducing the coupling of the code.

In the Laravel framework, dependency injection is a very important concept. It is the basis for implementing Inversion of Control in Laravel.

2. How Laravel implements dependency injection

The Laravel framework uses PHP's built-in Reflection class to implement dependency injection. The Reflection class is mainly used to obtain various information of the class, including class methods, attributes, annotations, etc.

1. The principle of dependency injection

In the Laravel framework, dependency injection is implemented through the service container (Service Container). The service container is an important component of the Laravel framework. It is a dependency injection container used to instantiate and manage class objects.

In the Laravel framework, developers can use the following methods to implement dependency injection:

• Declare dependencies in the constructor of the controller
• In the controller method Declare dependencies
• Use closure function to generate objects

Below we will explain the implementation principles of these three methods one by one.

2. Declare dependencies in the constructor of the controller

In the Laravel framework, controllers are usually implemented through dependency injection. In the controller, we can declare dependencies using constructors, and the Laravel framework will automatically instantiate the required dependency objects through the reflection mechanism.

For example, we have a UserController class that needs to depend on a UserService class, which can be achieved in the following ways:

use App\Services\UserService;

class UserController extends Controller
{
    protected $userService;

    public function __construct(UserService $userService)
    {
        $this->userService = $userService;
    }

    public function getUser($id)
    {
        $user = $this->userService->getUser($id);
        return view('user', compact('user'));
    }
}

In the above code, we declare a dependent object through the constructor $ userService. When the UserController class is instantiated, the Laravel framework automatically injects the required UserService instance.

3. Declare dependencies in controller methods

In some special scenarios, we may need to declare dependencies in controller methods. For example, when we need to use some auxiliary class libraries, we can achieve this through method injection.

For example, we have a UserController class that needs to use the cache library, which can be implemented in the following way:

use Illuminate\Cache\Repository;

class UserController extends Controller
{
    public function getUser($id, Repository $cache)
    {
        $user = $cache->get('user_' . $id, function() use($id) {
            $userService = app(UserService::class);
            return $userService->getUser($id);
        });

        return view('user', compact('user'));
    }
}

In the above code, we declare a parameter in the getUser method Depends on object $cache. When the getUser method is called, the Laravel framework automatically injects the required Repository instance.

4. Use the closure function to generate objects

In addition to the previous two methods, we can also generate objects through the closure function and hand the object over to the Laravel framework for management. This approach is usually used to resolve some special dependencies, such as implementation classes of interfaces and abstract classes.

For example, we have a UserController class that needs to use the interface, which can be implemented in the following way:

use App\Repositories\UserRepository;
use App\Services\UserService;
use Illuminate\Contracts\Container\Container;

class UserController extends Controller
{
    protected $container;

    public function __construct(Container $container)
    {
        $this->container = $container;
    }

    public function getUser($id)
    {
        $userService = $this->container->make(UserService::class, [
            'userRepository' => $this->container->make(UserRepository::class),
        ]);

        $user = $userService->getUser($id);
        return view('user', compact('user'));
    }
}

In the above code, we inject a Container object in the constructor, and then pass The make method generates a UserService object and passes the UserRepository object as a parameter to the make method.

Through the above methods, we can implement dependency injection in the Laravel framework to make the code more flexible and scalable.

3. Summary

Dependency injection is a very important concept in the Laravel framework. It achieves the purpose of object decoupling by passing dependent objects to objects. The Laravel framework uses PHP's built-in reflection class to implement dependency injection, making the relationship between classes looser and reducing the coupling of the code.

In the Laravel framework, we can implement dependency injection through controller constructors, controller methods and closure functions. Different methods are suitable for different scenarios, and developers can choose the appropriate method for implementation based on actual needs.

The above is the detailed content of Take you step by step to understand dependency injection in laravel. For more information, please follow other related articles on the PHP Chinese website!