public function cache()

    {

        $c=\Cache::get('app');

        if(!$c) {

            \Cache::put('app', 'cache', 1);

        }

        dump($c);//cache

    }

'aliases' => [

       'App' => Illuminate\Support\Facades\App::class,

       'Artisan' => Illuminate\Support\Facades\Artisan::class,

       'Auth' => Illuminate\Support\Facades\Auth::class,

       'Blade' => Illuminate\Support\Facades\Blade::class,

       'Broadcast' => Illuminate\Support\Facades\Broadcast::class,

       'Bus' => Illuminate\Support\Facades\Bus::class,

       'Cache' => Illuminate\Support\Facades\Cache::class,

       ]

$response = $kernel->handle(

$request = Illuminate\Http\Request::capture()

);

$app->singleton(

    Illuminate\Contracts\Http\Kernel::class,

    App\Http\Kernel::class

);

use Illuminate\Foundation\Http\Kernel 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 Events\RequestHandled($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' => Illuminate\Support\Facades\Route::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)