Facades working principle

In Laravel applications, Facade is a class that can access objects from the container. The core component is the Facade class. Whether it is Laravel's own Facades or custom Facades, they all inherit from the Illuminate\Support\Facades\Facade class.

Facade The base class uses the __callStatic() magic method, which will not be called until the object is parsed out of the container. In the example below, Laravel's caching system is called. By browsing this code, it can be assumed that the static method get is called in the Cache class:

<?php
   namespace App\Http\Controllers;
   use App\Http\Controllers\Controller;
   use Illuminate\Support\Facades\Cache;
   class UserController extends Controller{   
    /**
     * 显示给定用户的信息。
     *
     * @param  int  $id
     * @return Response
     */   
      public function showProfile($id) 
         {       
           $user = Cache::get('user:'.$id); 
           return view('profile', ['user' => $user]);  
          }
      }

Note that in the above code, we "import" Cache Facade. This Facade serves as a proxy for accessing the underlying implementation of the Illuminate\Contracts\Cache\Factory interface. Any calls we make using the Facade will be passed to the underlying instance of the Laravel caching service.

If we look at the Illuminate\Support\Facades\Cache class, you will find that there is no get static method in the class:

class Cache extends Facade{   
    /**
     * 获取组件的注册名称。
     *
     * @return string
     */  
       protected static function getFacadeAccessor() { 
            return 'cache'; 
        }
     }

Cache Facade inherits the Facade class and defines the getFacadeAccessor() method. The function of this method is to return the name of the service container binding. When a user calls any static method in the Cache Facade, Laravel resolves the cache binding from the service container and the object runs the requested method (in this case it is get method).

Real-time Facades

With real-time Facades, you can treat any class in your application as a Facade. To illustrate how this is used, let's look at another method. For example, let's say our Podcast model has a publish method. However, in order to publish a Podcast, we need to inject a Publisher instance:

<?php
   namespace App;
   use App\Contracts\Publisher;
   use Illuminate\Database\Eloquent\Model;
   class Podcast extends Model{  
     /**
     * 发布 Podcast。
     *
     * @param  Publisher  $publisher
     * @return void
     */ 
        public function publish(Publisher $publisher) 
           {     
              $this->update(['publishing' => now()]); 
              $publisher->publish($this);   
             }
        }

Injecting the publisher's implementation into the method, we can easily test this method since we can mock Injected publisher. However, it requires us to pass a publisher instance every time we call the publish method. Using live Facades we can maintain the same testability without having to explicitly pass a Publisher instance. To generate a real-time Facade, add Facades to the namespace of the imported class:

<?php
   namespace App;
   use Facades\App\Contracts\Publisher;
   use Illuminate\Database\Eloquent\Model;
   class Podcast extends Model{ 
    /**
     * 发布 Podcast。
     *
     * @return void
     */ 
        public function publish()  
          {   
               $this->update(['publishing' => now()]); 
                Publisher::publish($this);  
            }
       }

When using a real-time Facade, the publisher implementation will be prefixed by using the Facades The part of the interface or class name that appears later to solve the problem of the service container. When testing, we can use Laravel's built-in facade test helper function to simulate this method call:

<?php
  namespace Tests\Feature;use App\Podcast;
  use Tests\TestCase;use Facades\App\Contracts\Publisher;
  use Illuminate\Foundation\Testing\RefreshDatabase;
  class PodcastTest extends TestCase{  
    use RefreshDatabase;   
    /**
     * 一个测试演示。
     *
     * @return void
     */  
       public function test_podcast_can_be_published()  
         {    
             $podcast = factory(Podcast::class)->create(); 
             Publisher::shouldReceive('publish')->once()->with($podcast);  
             $podcast->publish(); 
            }
      }

Facade Class Reference

Below you can find each Facade class and its corresponding underlying class. This is a tool to find API documentation for a given Facade class. Key information for service container bindings is also included.