laravel cache get是怎么调用的?

public function cache()     {         $c=Cache::get('app');         if(!$c) {             Cache::put('app', 'cache', 1);         }         dump($c);//cache     }

 'aliases' => [          'App' => IlluminateSupportFacadesApp::class,         'Artisan' => IlluminateSupportFacadesArtisan::class,         'Auth' => IlluminateSupportFacadesAuth::class,         'Blade' => IlluminateSupportFacadesBlade::class,         'Broadcast' => IlluminateSupportFacadesBroadcast::class,         'Bus' => IlluminateSupportFacadesBus::class,         'Cache' => IlluminateSupportFacadesCache::class,                  ]

$response = $kernel->handle( $request = IlluminatehttpRequest::capture() );

$app->singleton(     IlluminateContractsHttpKernel::class,     AppHttpKernel::class );

use IlluminateFoundationHttpKernel as HttpKernel;  class Kernel extends HttpKernel {  }

public function handle($request) {     try {         $request->enableHttpMethodParameterOverride();         $response = $this->sendRequestThroughRouter($request);     } catch (Exception $e) {         $this->reportException($e);          $response = $this->renderException($request, $e);     } catch (Throwable $e) {         $this->reportException($e = new FatalThrowableError($e));          $response = $this->renderException($request, $e);     }      $this->app['events']->dispatch(         new EventsRequestHandled($request, $response)     );      return $response; } 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());     }     public function bootstrap()     {         if (! $this->app->hasBeenBootstrapped()) {             $this->app->bootstrapWith($this->bootstrappers());         }     }

public function bootstrapWith(array $bootstrappers)     {         $this->hasBeenBootstrapped = true;          foreach ($bootstrappers as $bootstrapper) {             $this['events']->fire('bootstrapping: '.$bootstrapper, [$this]);              $this->make($bootstrapper)->bootstrap($this);              $this['events']->fire('bootstrapped: '.$bootstrapper, [$this]);         }     }

public function bootstrap(Application $app)     {         Facade::clearResolvedInstances();          Facade::setFacadeApplication($app); //将config/app.php 里的aliases数组里面的Facades类设置别名         AliasLoader::getInstance(array_merge(             $app->make('config')->get('app.aliases', []),             $app->make(PackageManifest::class)->aliases()         ))->register();     }

public function load($alias)     {         if (static::$facadeNamespace && strpos($alias, static::$facadeNamespace) === 0) {             $this->loadFacade($alias);              return true;         }        // $alias来自于config/app.php中aliases数组          if (isset($this->aliases[$alias])) {             //'Route' => IlluminateSupportFacadesRoute::class,             // class_alias 为一个类创建别名             return class_alias($this->aliases[$alias], $alias);         }     }

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

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);     }    public static function getFacadeRoot()     {         return static::resolveFacadeInstance(static::getFacadeAccessor());     }       protected static function resolveFacadeInstance($name)     {     //这里$name为cache         if (is_object($name)) {             return $name;         }          if (isset(static::$resolvedInstance[$name])) {             return static::$resolvedInstance[$name];         }     //$app是容器对象，实现了ArrayAccess接口，最终调用的还是容器的make方法         return static::$resolvedInstance[$name] = static::$app[$name];     }

public function make($abstract, array $parameters = [])     {         return $this->resolve($abstract, $parameters);     }     protected function resolve($abstract, $parameters = [])     {         $abstract = $this->getAlias($abstract);          $needsContextualBuild = ! empty($parameters) || ! is_null(             $this->getContextualConcrete($abstract)         );          // If an instance of the type is currently being managed as a singleton we'll         // just return an existing instance instead of instantiating new instances         // so the developer can keep using the same objects instance every time.         if (isset($this->instances[$abstract]) && ! $needsContextualBuild) {             return $this->instances[$abstract];         }          $this->with[] = $parameters;          $concrete = $this->getConcrete($abstract);          // We're ready to instantiate an instance of the concrete type registered for         // the binding. This will instantiate the types, as well as resolve any of         // its "nested" dependencies recursively until all have gotten resolved.         if ($this->isBuildable($concrete, $abstract)) {             $object = $this->build($concrete);         } else {             $object = $this->make($concrete);         }          // If we defined any extenders for this type, we'll need to spin through them         // and apply them to the object being built. This allows for the extension         // of services, such as changing configuration or decorating the object.         foreach ($this->getExtenders($abstract) as $extender) {             $object = $extender($object, $this);         }          // If the requested type is registered as a singleton we'll want to cache off         // the instances in "memory" so we can return it later without creating an         // entirely new instance of an object on each subsequent request for it.         if ($this->isShared($abstract) && ! $needsContextualBuild) {             $this->instances[$abstract] = $object;         }          $this->fireResolvingCallbacks($abstract, $object);          // Before returning, we will also set the resolved flag to "true" and pop off         // the parameter overrides for this build. After those two things are done         // we will be ready to return back the fully constructed class instance.         $this->resolved[$abstract] = true;          array_pop($this->with);          return $object;     }

 public function register()     {         $this->app->singleton('cache', function ($app) {             return new CacheManager($app);         });          $this->app->singleton('cache.store', function ($app) {             return $app['cache']->driver();         });          $this->app->singleton('memcached.connector', function () {             return new MemcachedConnector;         });     }

$instance->$method(...$args)