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\RegisterFacades
This 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.
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:
- Used when parsing the service
static::$app
is set in the initial
RegisterFacades, which refers to the service container.
- 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!

The article discusses the differences between unset() and unlink() functions in programming, focusing on their purposes and use cases. Unset() removes variables from memory, while unlink() deletes files from the filesystem. Both are crucial for effec

PHP traits enable code reuse in single inheritance contexts, offering benefits like reusability and simplified inheritance. They can be effectively combined with traditional inheritance to enhance class flexibility and modularity.

PHP does not support multiple inheritance but uses interfaces and traits as alternatives to achieve similar functionality, avoiding issues like the diamond problem.

Inheritance in PHP allows classes to inherit properties and methods, promoting code reuse and hierarchical organization. Key benefits include reusability, abstraction, and polymorphism. Common mistakes to avoid are overuse of inheritance and ignoring

The article discusses three main error types in programming: syntax, runtime, and logical errors. It explains their causes, prevention strategies, impacts on performance and user experience, and methods for diagnosis and resolution.

Article discusses PHP and HTML interaction, best practices for embedding PHP in HTML, dynamic HTML content generation, and recommended development tools.

The article discusses the differences between for and foreach loops in PHP, focusing on syntax, usage, control, and performance. Foreach is preferred for array iteration due to simplicity and efficiency, but for loops are better for index-based opera

The article discusses the crucial role of the PHP parser in script execution, focusing on its tasks in syntax analysis, error handling, and code optimization, and how its efficiency impacts web application performance.


Hot AI Tools

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Undress AI Tool
Undress images for free

Clothoff.io
AI clothes remover

Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

Hot Tools

MantisBT
Mantis is an easy-to-deploy web-based defect tracking tool designed to aid in product defect tracking. It requires PHP, MySQL and a web server. Check out our demo and hosting services.

EditPlus Chinese cracked version
Small size, syntax highlighting, does not support code prompt function

SublimeText3 English version
Recommended: Win version, supports code prompts!

SublimeText3 Linux new version
SublimeText3 Linux latest version

Notepad++7.3.1
Easy-to-use and free code editor
