Laravel Core Interpretation Facades

This article mainly introduces the core interpretation of Facades in Laravel, which has certain reference value. Now I share it with everyone. Friends in need can refer to it

What are Facades

Facades are A component that we use very frequently in Laravel application development is not appropriately called a component. In fact, they are a set of static class interfaces or proxies that allow developers to simply access various services bound to the service container. The explanation of Facades in the Laravel documentation is as follows:

Facades provide a "static" interface for classes available in the application's service container. Laravel comes with many facades, and you may be using them without even knowing it! As a "static proxy" for base classes in the service container, Laravel "facades" have the advantages of concise and easy-to-express syntax, while maintaining higher testability and flexibility than traditional static methods.

The Route we often use is a Facade, which is an alias of the \Illuminate\Support\Facades\Route class. This Facade class represents the registered in the service container. router service, so through the Route class we can easily use the various services provided in the router service, and the service resolution involved is completely implicitly completed by Laravel, which to a certain extent makes the application The code has become much simpler. Below we will take a brief look at the process between Facades being registered in the Laravel framework and being used by the application. Facades work closely with ServiceProvider, so if you understand these processes, it will be helpful to develop custom Laravel components.

Registering Facades

When it comes to Facades registration, we have to go back to the Bootstrap stage that has been mentioned many times when introducing other core components. There is a startup before the request passes through middleware and routing. Application process:

//Class: \Illuminate\Foundation\Http\Kernel
 
protected function sendRequestThroughRouter($request)
{
    $this->app->instance('request', $request);

    Facade::clearResolvedInstance('request');

    $this->bootstrap();

    return (new Pipeline($this->app))
                    ->send($request)
                    ->through($this->app->shouldSkipMiddleware() ? [] : $this->middleware)
                    ->then($this->dispatchToRouter());
}

//引导启动Laravel应用程序
public function bootstrap()
{
    if (! $this->app->hasBeenBootstrapped()) {
        /**依次执行$bootstrappers中每一个bootstrapper的bootstrap()函数
         $bootstrappers = [
               'Illuminate\Foundation\Bootstrap\DetectEnvironment',
             'Illuminate\Foundation\Bootstrap\LoadConfiguration',
              'Illuminate\Foundation\Bootstrap\ConfigureLogging',
             'Illuminate\Foundation\Bootstrap\HandleExceptions',
             'Illuminate\Foundation\Bootstrap\RegisterFacades',
             'Illuminate\Foundation\Bootstrap\RegisterProviders',
             'Illuminate\Foundation\Bootstrap\BootProviders',
            ];*/
            $this->app->bootstrapWith($this->bootstrappers());
    }
}

In the process of starting the applicationIlluminate\Foundation\Bootstrap\RegisterFacadesThis stage will register the Facades used in the application.

class RegisterFacades
{
    /**
     * Bootstrap the given application.
     *
     * @param  \Illuminate\Contracts\Foundation\Application  $app
     * @return void
     */
    public function bootstrap(Application $app)
    {
        Facade::clearResolvedInstances();

        Facade::setFacadeApplication($app);

        AliasLoader::getInstance(array_merge(
            $app->make('config')->get('app.aliases', []),
            $app->make(PackageManifest::class)->aliases()
        ))->register();
    }
}

Here, aliases will be registered for all Facades through instances of the AliasLoader class. The corresponding relationship between Facades and aliases is stored in the config/app.php file. ##$aliasesIn the array

'aliases' => [

    'App' => Illuminate\Support\Facades\App::class,
    'Artisan' => Illuminate\Support\Facades\Artisan::class,
    'Auth' => Illuminate\Support\Facades\Auth::class,
    ......
    'Route' => Illuminate\Support\Facades\Route::class,
    ......
]

Look at how these aliases are registered in AliasLoader

// class: Illuminate\Foundation\AliasLoader
public static function getInstance(array $aliases = [])
{
    if (is_null(static::$instance)) {
        return static::$instance = new static($aliases);
    }

    $aliases = array_merge(static::$instance->getAliases(), $aliases);

    static::$instance->setAliases($aliases);

    return static::$instance;
}

public function register()
{
    if (! $this->registered) {
        $this->prependToLoaderStack();

        $this->registered = true;
    }
}

protected function prependToLoaderStack()
{
    // 把AliasLoader::load()放入自动加载函数队列中，并置于队列头部
    spl_autoload_register([$this, 'load'], true, true);
}

Through the above code snippet, you can see that AliasLoader registers the load method to the SPL __autoload function The head of the queue. Take a look at the source code of the load method:

public function load($alias)
{
    if (isset($this->aliases[$alias])) {
        return class_alias($this->aliases[$alias], $alias);
    }
}

In the load method

$aliases the Facade class in the configuration creates the corresponding alias, for example, when we use the alias class Route PHP will create an alias class Route for the Illuminate\Support\Facades\Route::class class through the load method of AliasLoader, so we use the alias Route in the program In fact, the `Illuminate\Support\Facades\Route class is used.

Resolve Facade proxy service

After registering Facades to the framework, we can use the Facade in the application. For example, when registering routes, we often use

Route::get ('/uri', 'Controller@action);, then how does Route proxy to the routing service? This involves the implicit resolution of the service in the Facade. Let's take a look. The source code of the Route class:

class Route extends Facade
{
    /**
     * Get the registered name of the component.
     *
     * @return string
     */
    protected static function getFacadeAccessor()
    {
        return 'router';
    }
}

has only one simple method, and there are no routing methods such as

get, post, delete, etc., parent class Neither, but we know that calling a static method that does not exist in the class will trigger PHP's __callStaticstatic method

public static function __callStatic($method, $args)
{
    $instance = static::getFacadeRoot();

    if (! $instance) {
        throw new RuntimeException('A facade root has not been set.');
    }

    return $instance->$method(...$args);
}

//获取Facade根对象
public static function getFacadeRoot()
{
    return static::resolveFacadeInstance(static::getFacadeAccessor());
}

/**
 * 从服务容器里解析出Facade对应的服务
 */
protected static function resolveFacadeInstance($name)
{
    if (is_object($name)) {
        return $name;
    }

    if (isset(static::$resolvedInstance[$name])) {
        return static::$resolvedInstance[$name];
    }

    return static::$resolvedInstance[$name] = static::$app[$name];
}

through the accessor (string router) set in the subclass Route Facade , parse the corresponding service from the service container. The router service is registered into the service container by

\Illuminate\Routing\RoutingServiceProvider during the registerBaseServiceProviders stage when the application is initialized (see the construction method of Application for details). :

class RoutingServiceProvider extends ServiceProvider
{
    /**
     * Register the service provider.
     *
     * @return void
     */
    public function register()
    {
        $this->registerRouter();
        ......
    }

    /**
     * Register the router instance.
     *
     * @return void
     */
    protected function registerRouter()
    {
        $this->app->singleton('router', function ($app) {
            return new Router($app['events'], $app);
        });
    }
    ......
}

The class corresponding to the router service is

\Illuminate\Routing\Router, so Route Facade actually proxies this class, and Route::get actually calls \Illuminate\Routing\RouterThe get method of the object

/**
 * Register a new GET route with the router.
 *
 * @param  string  $uri
 * @param  \Closure|array|string|null  $action
 * @return \Illuminate\Routing\Route
 */
public function get($uri, $action = null)
{
    return $this->addRoute(['GET', 'HEAD'], $uri, $action);
}

Add two points:

1. Used when parsing the service

   static::$app is set in the initial RegisterFacades, which refers to the service container.

2. static::$app['router']; The reason why the router service can be parsed from the service container in the form of array access is because the service container implements the ArrayAccess interface of SPL. There is no such thing as For concepts, you can read the official document ArrayAccess

##Summary

By sorting out the registration and usage process of Facade, we can see that Facade and service provider (ServiceProvider) work closely together Yes, so if you write your own Laravel custom service in the future, in addition to registering the service into the service container through the component's ServiceProvider, you can also provide a Facade in the component so that the application can easily access the custom service you wrote.

The above is the entire content of this article. I hope it will be helpful to everyone's study. For more related content, please pay attention to the PHP Chinese website!

related suggestion:

Interpretation of Laravel middleware (Middleware)

Interpretation of Laravel routing (Route)

The above is the detailed content of Laravel Core Interpretation Facades. For more information, please follow other related articles on the PHP Chinese website!