What is the implementation principle of dependency injection in Laravel?

In Laravel, the implementation principle of dependency injection is to use class method reflection to obtain the parameter type, then use the container to construct the instance, and then use the callback function to call it up; the injected object constructor cannot have parameters, otherwise an error will be reported , Dependency injection must be initiated by the Router class, otherwise the injection cannot be achieved directly using the new method.

#The operating environment of this article: Windows 10 system, Laravel version 6, Dell G3 computer.

What is the implementation principle of Laravel's dependency injection?

The laravel container contains inversion of control and dependency injection. To use it, you need to bind the object first, and you can directly use make to retrieve it when needed. .

For specific analysis, please refer to: http://laravelacademy.org/post/769.html

Usually our calls are as follows.

$config = $container->make('config'); $connection = new Connection($this->config);

It’s easier to understand. The advantage of this is that you don’t need to directly new an instance. There is no change in the value passed by the method. You can also share this instance in multiple places.

But what does this have to do with dependency injection? Real dependency injection does not require passing any parameter values to the method. You only need to specify the method parameter type, and the code will automatically find the relationship and automatically inject the dependency.

This feature can be reflected in Laravel's Controller, Job, etc., as follows:

class TestController extends Controller { public function anyConsole(Request $request, Auth $input) { //todo } }

Let's take a look at how it implements automatic dependency injection:

By index. PHP calls Kernel, calls through multi-layered Kernel pipelines, and then to Router, called through multi-layered middleware pipelines. Finally located at line 124 of

Illuminate/Routing/Route.php.

public function run(Request $request) { $this->container = $this->container ?: new Container; try { if (! is_string($this->action['uses'])) { return $this->runCallable($request); } if ($this->customDispatcherIsBound()) { return $this->runWithCustomDispatcher($request); } return $this->runController($request); } catch (HttpResponseException $e) { return $e->getResponse(); } }

Determine whether $this->action['uses'] (format line such as: \App\Http\Controller\Datacenter\RealTimeController@anyConsole) is a string, $this->customDispatcherIsBound determines whether it is bound User-defined routing is defined. Then jump to $this->runController($request).

protected function runController(Request $request) { list($class, $method) = explode('@', $this->action['uses']); $parameters = $this->resolveClassMethodDependencies( $this->parametersWithoutNulls(), $class, $method ); if (! method_exists($instance = $this->container->make($class), $method)) { throw new NotFoundHttpException; } return call_user_func_array([$instance, $method], $parameters); }

$this->resolveClassMethodDependencies This method is the method we are looking for as soon as we look at the name. $this->parametersWithoutNulls() is to filter out null characters. $class and $method are as follows: \App\Http\Controller\Datacenter\RealTimeController and anyConsole respectively.

protected function resolveClassMethodDependencies(array $parameters, $instance, $method) { if (! method_exists($instance, $method)) { return $parameters; } return $this->resolveMethodDependencies( $parameters, new ReflectionMethod($instance, $method) ); }

new ReflectionMethod($instance, $method) is the reflection object that gets the class method. See the documentation: http://www.php.net/manual/zh/class.reflectionmethod.php

The following jumps to line 54 of Illuminate/Routing/RouteDependencyResolverTrait.php.

public function resolveMethodDependencies(array $parameters, ReflectionFunctionAbstract $reflector) { $originalParameters = $parameters; foreach ($reflector->getParameters() as $key => $parameter) { $instance = $this->transformDependency( $parameter, $parameters, $originalParameters ); if (! is_null($instance)) { $this->spliceIntoParameters($parameters, $key, $instance); } } return $parameters; }

Get the class parameter array through the reflection class method, and then traverse it and pass it to the $this->transformDependency method. If the instance cannot be obtained, call $this->spliceIntoParameters to clear the parameters.

protected function transformDependency(ReflectionParameter $parameter, $parameters, $originalParameters) { $class = $parameter->getClass(); if ($class && ! $this->alreadyInParameters($class->name, $parameters)) { return $this->container->make($class->name); } }

Finally saw the shadow of the container. Yes, the final object was taken out through the make method of the container. At this point, the parameters are constructed, and will eventually be called back by the call_user_func_array of the runController method.

Summary:

The principle of dependency injection is actually to use class method reflection to obtain the parameter type, and then use the container to construct the instance. Then use the callback function to call it up.

The injection object constructor cannot have parameters. Otherwise, an error will be reported. Missing argument 1

Dependency injection is good, but it must be invoked by the Router class, otherwise the injection cannot be achieved directly using the new method. So this is why only Controller and Job classes can use this feature.

[Related recommendations:laravel video tutorial]

The above is the detailed content of What is the implementation principle of dependency injection in Laravel?. For more information, please follow other related articles on the PHP Chinese website!