Redis Store

The RedisStore class provides a Redis-backed cache store implementation with support for distributed caching, cache tagging, and distributed locking. This store is designed for production environments where high performance, persistence, and multi-server cache coordination are required.

For information about other cache stores, see page 3. For cache tagging implementation details, see page 4.1. For distributed locking features, see page 4.2.

Class Structure

The RedisStore class extends TaggableStore and implements the LockProvider interface, providing comprehensive Redis-backed caching with tagging and locking capabilities.

Class Hierarchy and Dependencies Diagram

Sources: src/RedisStore.php1-265

Store Interface Implementation

The RedisStore implements all methods from the Store contract. The following table lists all public methods and their Redis operations:

Method	Parameters	Return	Redis Commands	Purpose
get()	string $key	mixed	GET	Retrieve single item
many()	array $keys	array	MGET	Retrieve multiple items
put()	string $key, mixed $value, int $seconds	bool	SETEX	Store item with TTL
putMany()	array $values, int $seconds	bool	MULTI/EXEC	Store multiple items atomically
add()	string $key, mixed $value, int $seconds	bool	Lua script	Store if not exists
increment()	string $key, int $value = 1	int	INCRBY	Increment numeric value
decrement()	string $key, int $value = 1	int	DECRBY	Decrement numeric value
forever()	string $key, mixed $value	bool	SET	Store without expiration
forget()	string $key	bool	DEL	Delete item
flush()	-	bool	FLUSHDB	Clear all items

Sources: src/RedisStore.php42-175

RedisFactory Integration

The RedisStore uses Hyperf's RedisFactory for connection management and pooling. The factory provides RedisProxy instances that handle connection lifecycle and pooling automatically.

RedisFactory Connection Flow

Sources: src/RedisStore.php33-38 src/RedisStore.php191-202

Connection Configuration

The store supports separate connections for data and lock operations to isolate workloads:

Property	Type	Purpose	Default
$factory	RedisFactory	Connection factory instance	Injected via constructor
$connection	string	Data operation connection name	'default'
$lockConnection	string	Lock operation connection name	Falls back to $connection
$prefix	string	Key prefix for namespace isolation	''

Connection Methods

Sources: src/RedisStore.php191-220

Cache Operation Details

Read Operations

Single Item Retrieval

Sources: src/RedisStore.php43-48

Bulk Retrieval

The many() method uses Redis MGET for efficient multi-key retrieval:

Sources: src/RedisStore.php54-67

Write Operations

Standard Write

The put() method uses SETEX for atomic write-with-TTL:

Sources: src/RedisStore.php72-79

Bulk Write with Transaction

The putMany() method wraps multiple put() calls in a Redis transaction:

Sources: src/RedisStore.php84-99

Permanent Storage

The forever() method stores without expiration:

Sources: src/RedisStore.php138-141

Atomic Operations and Lua Scripts

Numeric Operations

The store provides atomic increment/decrement using Redis native commands:

These operations are atomic at the Redis server level, ensuring thread-safe counter updates across multiple processes.

Sources: src/RedisStore.php122-133

Conditional Write with Lua

The add() method uses a Lua script for atomic "set-if-not-exists" with TTL:

Lua Script Execution Flow

Implementation

Sources: src/RedisStore.php104-117

Serialization Strategy

The RedisStore implements intelligent serialization to optimize storage for different data types:

Serialization Decision Tree

Implementation

Data Type	Storage Method	Reason
Integer, Float (normal)	Raw numeric string	Redis native support, no overhead
INF, -INF, NaN	PHP serialize()	Special float values need preservation
String, Array, Object	PHP serialize()	Complex types require serialization

Sources: src/RedisStore.php249-264

Cache Tagging Support

The RedisStore extends TaggableStore to provide cache tagging capabilities through the RedisTaggedCache and RedisTagSet classes.

Tagged Cache Creation Flow

Implementation

The method accepts either an array of tag names or variadic arguments, creating a RedisTaggedCache instance that wraps the store and manages tag associations through RedisTagSet.

For detailed information about the tagging system implementation, see page 4.1.

Sources: src/RedisStore.php178-186

Distributed Locking

The RedisStore implements the LockProvider interface to create distributed locks via RedisLock instances. These locks coordinate access across multiple processes and servers.

Lock Creation and Connection Routing

Lock Methods

Method	Parameters	Return	Purpose
lock()	string $name, int $seconds, ?string $owner	RedisLock	Create new lock instance
restoreLock()	string $name, string $owner	RedisLock	Restore lock with specific owner

Implementation

Note that locks use the dedicated lockConnection() (or fall back to the main connection) and automatically apply the key prefix. For detailed lock implementation and usage patterns, see page 4.2.

Sources: src/RedisStore.php146-157

Rate Limiting Backend

While RedisStore does not directly implement rate limiting logic, it serves as the storage backend for rate limiters that use atomic increment operations and TTL-based key expiration.

Rate limiting systems built on RedisStore typically use:

Operation	Store Method	Purpose
Counter initialization	add()	Create counter key if not exists (atomic)
Attempt increment	increment()	Atomic counter increment
Attempt check	get()	Retrieve current attempt count
Counter expiration	TTL in put()/add()	Automatic cleanup after decay period

Typical Rate Limit Flow

The Limit class defines rate limit configurations (maxAttempts, decay time) but does not directly interact with the store. For rate limiting implementation details, see page 4.3.

Sources: src/RedisStore.php104-133 src/RateLimiting/Limit.php1-92

Key Management and Prefixing

The Redis store implements a flexible key prefixing system to avoid collisions and organize cache data:

Prefix management methods:

Method	Purpose	Behavior
setPrefix(string $prefix)	Set key prefix	Adds ':' if non-empty
getPrefix()	Get current prefix	Returns prefix with ':'

All Redis operations automatically apply the prefix through the $this->prefix . $key pattern used throughout the class.

Sources: src/RedisStore.php222-244