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

<?php

namespace Illuminate\Support\Facades;

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

<?php

namespace Illuminate\Cache;

use Illuminate\Support\ServiceProvider;
use Illuminate\Cache\Console\ClearCommand;
use Illuminate\Cache\Console\CacheTableCommand;

class CacheServiceProvider extends ServiceProvider
{
    /**
     * 服务提供者是否延迟加载
     *
     * @var bool
     */
    protected $defer = true;

    /**
     * 注册服务提供者
     *
     * @return void
     */
    public function register()
    {
        // 在服务容器中设置一个名为cache的CacheManager单例
        $this->app->singleton('cache', function ($app) {
            return new CacheManager($app);
        });

        // 在服务容器中设置一个名为cache.store的单例，比如memcache database
        $this->app->singleton('cache.store', function ($app) {
            return $app['cache']->driver();
        });

        // 在服务容中设置一个名为memcached.connector的MemcachedConnector单例，
        $this->app->singleton('memcached.connector', function () {
            return new MemcachedConnector;
        });

        // 注册缓存相关的控制台命令
        $this->registerCommands();
    }

    /**
     * 注册缓存相关的控制台命令。
     *
     * @return void
     */
    public function registerCommands()
    {
        // 清除缓存
        $this->app->singleton('command.cache.clear', function ($app) {
            return new ClearCommand($app['cache']);
        });

        // 创建database缓存驱动的存储表
        $this->app->singleton('command.cache.table', function ($app) {
            return new CacheTableCommand($app['files'], $app['composer']);
        });

        // 注册这两个命令
        $this->commands('command.cache.clear', 'command.cache.table');
    }

    /**
     * 提供的服务提供者。
     *
     * @return array
     */
    public function provides()
    {
        return [
            'cache', 'cache.store', 'memcached.connector', 'command.cache.clear', 'command.cache.table',
        ];
    }
}Copy

<?php
$cache = new CacheManager($app);
$cache->get('cacheKey');Copy

<?php
/**
* 从本地的stores变量中获取缓存仓库，如果没有根据名称创建仓库
*
* @param  string  $name
* @return \Illuminate\Contracts\Cache\Repository
*/
protected function get($name)
{
    return isset($this->stores[$name]) ? $this->stores[$name] : $this->resolve($name);
}Copy

<?php
/**
* 动态调用默认驱动程序实例。
*
* @param  string  $method
* @param  array   $parameters
* @return mixed
*/
public function __call($method, $parameters)
{
    return call_user_func_array([$this->store(), $method], $parameters);
}Copy

<?php
/**
* 根据名称获取缓存存储实例
*
* @param  string|null  $name
* @return mixed
*/
public function store($name = null)
{
    // 获取默认驱动名称
    $name = $name ?: $this->getDefaultDriver();

    // 根据名称获取缓存仓库
    return $this->stores[$name] = $this->get($name);
}Copy

<?php
/**
* 获取默认的缓存驱动名称
*
* @return string
*/
public function getDefaultDriver()
{
    // 实际获取的是config/cache.php中的数组，key为default,没有修改过的话默认是 'default' => env('CACHE_DRIVER', 'file'),
    return $this->app['config']['cache.default'];
}Copy

<?php
/**
* 从本地的stores变量中获取缓存仓库，如果没有根据名称创建仓库
*
* @param  string  $name
* @return \Illuminate\Contracts\Cache\Repository
*/
protected function get($name)
{
    return isset($this->stores[$name]) ? $this->stores[$name] : $this->resolve($name);
}Copy

<?php
/**
* 使用给定的名称创建缓存驱动
*
* @param  string  $name
* @return \Illuminate\Contracts\Cache\Repository
*
* @throws \InvalidArgumentException
*/
protected function resolve($name)
{
    // 根据名称获取配置信息
    $config = $this->getConfig($name);

    // 没有配置信息则抛异常
    if (is_null($config)) {
        throw new InvalidArgumentException("Cache store [{$name}] is not defined.");
    }

    // 判断是不是自定义的驱动类型，如果是则调用
    if (isset($this->customCreators[$config['driver']])) {
        return $this->callCustomCreator($config);
    } else {
        // 根据配置信息组装创建驱动的方法名
        $driverMethod = 'create'.ucfirst($config['driver']).'Driver';

        // 判断是否存在方法，存在则调用具体的方法创建驱动并返回
        if (method_exists($this, $driverMethod)) {
            return $this->{$driverMethod}($config);
        } else {
            throw new InvalidArgumentException("Driver [{$config['driver']}] not supported.");
        }
    }
}Copy

<?php
/**
* 创建一个redis缓存驱动实例
*
* @param  array  $config
* @return \Illuminate\Cache\RedisStore
*/
protected function createRedisDriver(array $config)
{
    // 获取redis实例
    $redis = $this->app['redis'];

    // 获取redis连接信息
    $connection = Arr::get($config, 'connection', 'default');

    // 通过redis存储创建缓存库
    return $this->repository(new RedisStore($redis, $this->getPrefix($config), $connection));
}Copy

<?php
/**
* 通过给定的缓存存储实现创建一个缓存库
*
* @param  \Illuminate\Contracts\Cache\Store  $store
* @return \Illuminate\Cache\Repository
*/
public function repository(Store $store)
{
    // 创建缓存库
    $repository = new Repository($store);

    // 如果没有设置过事件调度器则设置事件调度器实例
    if ($this->app->bound('Illuminate\Contracts\Events\Dispatcher')) {
        $repository->setEventDispatcher(
            $this->app['Illuminate\Contracts\Events\Dispatcher']
        );
    }

    return $repository;
}Copy

$cache->get();
    ↓
CacheManager::__call()
    ↓
$this->store()
    ↓
$this->get($name); <- $name = $this->getDefaultDriver();
    ↓
$this->resolve($name);
    ↓
$this->createRedisDriver($config); <- $config = $this->getConfig($name);
    ↓
$this->repository(new RedisStore($redis, $this->getPrefix($config), $connection));
    ↓
return $repository = new Repository($store);Copy