Detailed explanation of source code analysis and Laravel dependency injection steps

This time I will bring you source code analysis LaravelDependency injectiondetailed steps, source code analysis Laravel dependency injectionWhat are the precautions, the following is a practical case, let's take a look.

Preface

As we all know, there are countless PHP frameworks. In recent years, a framework known for its elegance has gradually been known by domestic PHPers. , and started using it, but one obvious shortcoming of larave is that its documentation content is pitiful.

This article will give you a detailed introduction to Laravel dependency injection and share it for your reference and study. I won’t say much below, let’s take a look at the detailed introduction.

In Laravel's controller's constructor method or member method, you can use dependency injection through type constraints , such as:

public function store(Request $request)
{
 //TODO
}

Here, the $request parameter uses type constraints. Request is a class:\Illuminate\Http\Request, which means that the parameter must be this class or a subclass.

This article analyzes the source code of Laravel to see why Request can be used directly without passing in an instance in the method? It’s just that the framework automatically instantiates and passes parameters for us.

1. Route definition

Looking from the source, such a route is defined in the route definition file:

Route::resource('/role', 'Admin\RoleController');

This is a resource-based route. Laravel will automatically generate routing entries for additions, deletions, modifications and queries.

The store method at the beginning of this article is a controller method. The Action defined by the route visible in the figure is also: App\Http\Controllers\Admin\RoleController@store

Routing method analysis

Find the controller and method according to the routing definition, and execute the specific method in the dispatch method.

(File: vendor/laravel/framework/src/Illuminate/Routing/ControllerDispatcher.php)

public function dispatch(Route $route, $controller, $method)
{
 $parameters = $this->resolveClassMethodDependencies(
  $route->parametersWithoutNulls(), $controller, $method
 );
 
 if (method_exists($controller, 'callAction')) {
  return $controller->callAction($method, $parameters);
 }
 
 return $controller->{$method}(...array_values($parameters));
}

First resolveClassMethodDependencies method, "as the name suggests" is to obtain dependent objects based on the method parameters of the class, and then Then call the class method and inject the object parameters.

If there are multiple dependent objects, they will be parsed out by foreach in turn and injected as parameters.

Get the code for the dependent object example:

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

The key point here is the use of PHP reflection. Pay attention to the RelectionMethod method. It obtains the method parameter list of the class and can know the type constraints of the parameters. name etc.

The $instance parameter here is the RoleController controller class, and the $method parameter is the method name store.

2. Example of obtaining dependent objects

After obtaining the constraint type of the dependent object from the method parameters, you can instantiate the dependent object.

protected function transformDependency(ReflectionParameter $parameter, $parameters)
{
 $class = $parameter->getClass(); 
 // If the parameter has a type-hinted class, we will check to see if it is already in
 // the list of parameters. If it is we will just skip it as it is probably a model
 // binding and we do not want to mess with those; otherwise, we resolve it here.
 if ($class && ! $this->alreadyInParameters($class->name, $parameters)) {
  return $parameter->isDefaultValueAvailable()
   ? $parameter->getDefaultValue()
   : $this->container->make($class->name);
 }
}

Get the object from the container based on the class name. The process of binding the object instance is first defined in the service provider.

Then pass the instantiated object into the store method, and you can use the dependent object.

3. About PHP reflection

Give an example of using ReflectionMethod.

class Demo
{
 private $request;
 public function store(Request $request)
 {
 }
}

Print out the content of new ReflectionMethod(Demo::class, 'store') as shown in the figure:

##You can get the parameter list of this method, The constraint type of the parameter, such as typeHint, Illuminate\Http\Request.

The instance initially bound through the service provider can be obtained from the container according to the class name.

I believe you have mastered the method after reading the case in this article. For more exciting information, please pay attention to other related articles on the php Chinese website!

Recommended reading:

php data structure and sequential linked list, detailed explanation of the use of linked linear list

php implements statistical binary Detailed explanation of the steps of the number of 1 algorithm

The above is the detailed content of Detailed explanation of source code analysis and Laravel dependency injection steps. For more information, please follow other related articles on the PHP Chinese website!