Parse Laravel dependency injection related content through source code

This article mainly introduces you to the relevant information on how to parse Laravel's dependency injection through source code. The article introduces it in great detail through sample code. It has certain reference learning value for everyone's study or work. Friends who need it can follow Let’s learn together with the editor.

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 the constructor or member method of Laravel's controller, dependency injection can be used 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 the dependent object based on the method parameters of the class, and 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.

Code for obtaining dependent object examples:

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, which obtains the class Method parameter list, you can know the parameter type constraints, parameter names, 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.

According to the class name, you can get the instance initially bound through the service provider from the container. .

Summary

Articles you may be interested in:

php data structure Examples of sequential linked lists and linked linear lists

Detailed explanation based on the difference between using commas and dots for echo in PHP

Example of php implementing statistical algorithm for counting the number of 1's in binary

The above is the detailed content of Parse Laravel dependency injection related content through source code. For more information, please follow other related articles on the PHP Chinese website!