set cache php,laravel cache get 是如何调用的?

本文使用版本为laravel5.5

cache get

public function cache()

{

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

if(!$c) {

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

}

dump($c);//cache

}

config/app.php

'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,

]

使用cache实际调用的是Illuminate\Support\Facades\Cache,这个映射是如何做的？

public/index.php

$response = $kernel->handle(

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

);

bootstarp/app.php

$app->singleton(

Illuminate\Contracts\Http\Kernel::class,

App\Http\Kernel::class

);

app/http/kernel.php

use Illuminate\Foundation\Http\Kernel as HttpKernel;

class Kernel extends HttpKernel

{

}

Illuminate/Foundation/Http/Kernel.php

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());

}

}

Illuminate/Foundation/Application.php

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]);

}

}

Illuminate/Foundation/Bootstrap/RegisterFacades.php

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();

}

Illuminate/Foundation/AliasLoader.php

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);

}

}

Illuminate/Support/Facades/Cache.php

class Cache extends Facade

{

/**

* Get the registered name of the component.

*

* @return string

*/

protected static function getFacadeAccessor()

{

return 'cache';

}

}

Illuminate/Support/Facades/Facade.php

这个文件没有get set ，只有__callStatic

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];

}

IlluminateContainerContainer.php

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;

}

Illuminate/Cache/CacheServiceProvider.php

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;

});

}

get set

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