Weave Code
Cache Contracts Laravel Package
symfony/cache-contracts
Symfony Cache Contracts defines lightweight, PSR-friendly interfaces for cache and tag-aware caching, enabling consistent cache usage across Symfony components and third-party libraries. Use it to type-hint against stable APIs while swapping cache implementations.
Generic abstractions related to caching
Frequently asked questions about Cache Contracts
- How does symfony/cache-contracts integrate with Laravel’s built-in Cache facade?
- Laravel’s Cache facade (e.g., `Cache::get()`) already uses these contracts under the hood, so no changes are needed. The package provides the interfaces (`CacheItemPoolInterface`, `CacheInterface`) that Laravel’s core drivers (Redis, Memcached, etc.) implement. You can type-hint against these interfaces in your code while relying on Laravel’s facade for usage.
- Can I use this package to build a custom cache driver for Laravel?
- Yes. Implement `CacheItemPoolInterface` (PSR-6) or `CacheInterface` (Symfony’s subset) for your driver, then register it in `config/cache.php` under `stores`. Laravel’s Cache facade will automatically use it via `Cache::store('your_driver')->get()`. Example: A database-backed cache or multi-CDN cache.
- What Laravel versions support symfony/cache-contracts?
- All Laravel versions since 5.5+ rely on these contracts (via `symfony/cache`). The package itself is version-agnostic—it’s a dependency of Laravel’s core cache system. No additional setup is required for existing projects.
- Does this package add overhead to my caching operations?
- Minimal. The contracts are lightweight interfaces; the performance impact is negligible unless you’re using a custom driver with heavy logic. Benchmark your specific implementation against Laravel’s default drivers (e.g., Redis) to compare. For most use cases, the abstraction is transparent.
- How do I handle cache failures (e.g., Redis downtime) with these contracts?
- Use Laravel’s built-in fallback mechanisms or implement a decorator pattern (e.g., `CachePoolDecorator`) to wrap your cache pool. For example, return cached data from a secondary store if the primary fails. Laravel’s `Cache::rememberForever()` already handles this gracefully.
- What’s the difference between PSR-6 and Symfony’s CacheInterface here?
- PSR-6 (`CacheItemPoolInterface`) is the standard for advanced caching (tags, TTL precision). Symfony’s `CacheInterface` is a simpler subset (PSR-16-like). Laravel’s Cache facade supports both. Use PSR-6 for tag-aware caching or distributed invalidation; `CacheInterface` for basic key-value stores.
- Can I use this with Doctrine Cache or other third-party libraries?
- Yes. Libraries like Doctrine Cache (PSR-6 compliant) will work seamlessly. The contracts ensure interoperability across PHP ecosystems. Just implement the same interfaces in your Laravel project, and third-party tools will recognize them.
- How do I test a custom cache driver built with these contracts?
- Use Laravel’s built-in cache testing helpers or mock the interfaces directly. For example, test `doFetch()`/`doSave()` methods in isolation with PHPUnit. Laravel’s `Cache::shouldReceive()` methods can also simulate cache behavior for unit tests.
- Will this package conflict with other Symfony components in my project?
- Unlikely. Symfony Cache Contracts are interface-only and designed for backward compatibility. Conflicts might arise if other dependencies enforce a different `symfony/cache` version, but Laravel’s dependency resolution (via `composer.lock`) typically handles this.
- What’s the best way to migrate from Laravel’s default cache to a custom driver using these contracts?
- Start by implementing the contracts for your driver (e.g., `DatabaseCachePool`). Register it in `config/cache.php`, then gradually replace `Cache::store('file')` with `Cache::store('database')` for non-critical data. Monitor performance and roll back if needed.
Weaver
How can I help you explore Laravel packages today?