app_Http_Middleware_ActionCache.php

<?php

namespace App\Http\Middleware;

use Closure;
use App\Services\Cache\ActionCacheManager;
use Symfony\Component\HttpFoundation\ResponseHeaderBag;

/**
 * Middleware that will cache controller action responses
 */
class ActionCache
{
    protected $cacheManager;

    /**
     * Injects the class dependencies
     * @param ActionCacheManager $cacheManager To manage the cached actions.
     */
    public function __construct(ActionCacheManager $cacheManager)
    {
        $this->cacheManager = $cacheManager;
    }

    /**
     * Run the request middleware.
     *
     * @param  \Illuminate\Http\Request $request
     * @param  \Closure                 $next
     *
     * @return mixed
     */
    public function handle($request, Closure $next)
    {
        $path = $request->path();

        if ($this->cacheManager->isCached($path) && $this->canBeCached($request)) {
            return $this->cacheManager->get($path);
        }

        return $next($request);
    }

    /**
     * Sometimes a middleware may need to do some work after the HTTP response
     * has already been sent to the browser. The ActionCache middleware will
     * store the response using the cacheManager for it to be used when
     * handling the next request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Illuminate\Http\Response $response
     */
    public function terminate($request, $response)
    {
        $path = $request->path();

        if ($this->cacheManager->isCached($path) || !$this->canBeCached($request)) {
            return;
        }

        $this->cleanCookies($response);
        $this->cacheManager->cache($path, $response);
    }

    /**
     * Tells if a request can be cached
     *
     * @param  \Illuminate\Http\Request $request
     *
     * @return boolean
     */
    protected function canBeCached($request)
    {
        return ! $request->get('preview');
    }

    /**
     * Clean the cookies of the given response
     *
     * @param  \Illuminate\Http\Response $response
     */
    protected function cleanCookies($response)
    {
        foreach ($response->headers->getCookies(ResponseHeaderBag::COOKIES_ARRAY) as $path) {
            foreach ($path as $cookies) {
                foreach ($cookies as $cookie) {
                    $response->headers->removeCookie($cookie->getName(), $cookie->getPath(), $cookie->getDomain());
                }
            }
        }
    }
}

app_Services_Cache_ActionCacheManager.php

<?php

namespace App\Services\Cache;

/**
 * Manages how controller actions are cached
 */
class ActionCacheManager extends BaseManager
{
    /**
     * Generates a cache key for the given url. It's here that you
     * should differentiate the cache key for each request. Parameters
     * such as "page" should be considered in order not to overlap the
     * cache keys.
     *
     * @param string $key String that identifies a resource.
     *
     * @return string Cache key for the given $key.
     */
    protected function getCacheKeyFor(string $key)
    {
        // Avoid "cache conflict" between different methods like, GET, POST, etc
        $method = request()->method();
        
        // Avoid "cache conflict" from ajax routes. If a controller answers differently when json is wanted
        if (request()->ajax() || request('json')) {
            $method = $method . "_ajax";
        }

        // Avoid "cache conflict" between domains.
        $domainHash = substr(md5(request()->root()), 0, 5);

        // Avoid "cache conflict" for other stuff, "page", "language", etc.

        return sprintf(
            '%s:%s:%s:%s',
            static::KEY_PREFIX,
            $domainHash,
            $key,
            strtolower($method)
        );
    }
}

app_Services_Cache_BaseManager.php

<?php

namespace App\Services\Cache;

use Illuminate\Contracts\Cache\Repository;

/**
 * Base class for specific purpose cache managers
 */
abstract class BaseManager
{
    const KEY_PREFIX = "managedcache";

    protected $cacheRepo;

    /**
     * Injects the dependencies of the class
     *
     * @param Repository $cacheRepo Cache repository being used by the manager.
     */
    public function __construct(Repository $cacheRepo)
    {
        $this->cacheRepo = $cacheRepo;
    }

    /**
     * Checks if the given identificator is cached
     *
     * @param string $key String that identifies a value that may be cached.
     *
     * @return boolean Is the resource of the given key is cached?
     */
    public function isCached(string $key)
    {
        return $this->cacheRepo->has($this->getCacheKeyFor($key));
    }

    /**
     * Caches the given $value within the $key
     *
     * @param  string  $key     String that identifies the value being cached.
     * @param  mixed   $value   Value being cached.
     * @param  integer $minutes For how long will the cache be stored.
     *
     * @return void
     */
    public function cache(string $key, $value, int $minutes = 10)
    {
        $this->cacheRepo->put(
            $this->getCacheKeyFor($key),
            $value,
            $minutes
        );
    }

    /**
     * Retrieves a cached value
     *
     * @param string $key String that identifies a value.
     *
     * @return mixed
     */
    public function get(string $key)
    {
        return $this->cacheRepo->get($this->getCacheKeyFor($key));
    }

    /**
     * Generates a cache key for the given key
     *
     * @param string $key String that identifies a resource.
     *
     * @return string Cache key for the given $key.
     */
    abstract protected function getCacheKeyFor(string $key);
}

helpers.php

<?php

if (! function_exists('cached_include')) {

    /**
     * Mimics the blade include function but caches the rendered for $time
     * minutes in key 'cache:partials:<view_name>:<context>_<$cache_key>'
     * in order to avoid conflicts and to be able to flush the view using
     * patterns.
     *     Ex: Cache::clear('cache:partials:myview_*');
     *
     * @param  string  $view The name of the view that are going to be included.
     * @param  array   $vars Variables that are being passed to the view.
     * @param  integer $time The amount of minutes that the result of the view is going to be stored.
     *
     * @return string             Html code of the included view
     */
    function cached_include($view, $vars = null, $time = 60)
    {
        $cacheKey = $view . md5(serialize($vars));

        return Cache::remember(
            $cacheKey,
            $time,
            function () use ($view) {
                return view(
                    $view,
                    is_array($vars) ? $vars : array_except(get_defined_vars(), ['__data', '__path'])
                )->render();
            }
        );
    }

    /**
     * Registers the cached_include as blade's @cached_include in order to be able
     * to be used in the template engine.
     */
    Blade::extend(
        function ($view) {
            $pattern = '/@cached_include\((.*)\)/';

            return preg_replace($pattern, "<?php echo cached_include($1); ?>", $view);
        }
    );
}

info.md

Info

Video: https://www.youtube.com/watch?v=z8qkUITz5rU

Slides: https://speakerdeck.com/zizaco/estrategias-de-caching-escalando-sua-aplicacao-para-milhoes-de-visitas

Apresentado em: http://www.meetup.com/Laravel-SP/events/230694300/

Apresentador por:

Luiz Fernando / Zizaco

http://zizaco.net

https://www.linkedin.com/in/zizaco

Outros resources

https://murze.be/2015/07/speed-up-a-laravel-app-by-caching-the-entire-response/

https://github.com/spatie/laravel-responsecache

http://markvaneijk.com/caching-routes-using-filters-in-laravel-4