Cheatsheet Redis

Mental model awal Redis sebagai cache, data structure server, coordination primitive, rate limiter backend, idempotency store, queue, stream, pub/sub, dan session store.

Redis server process, event loop, command execution, memory model, persistence, replication, Sentinel, Cluster, Pub/Sub, dan Streams.

Key, value, string, hash, list, set, sorted set, bitmap, bitfield, HyperLogLog, geospatial, stream, TTL, atomic command, command complexity, blocking command, pipelining, transaction, Lua, and data structure selection for enterprise Java/JAX-RS systems.

Namespace, prefix, environment, service, tenant, entity, version, composite key, separator convention, key cardinality, key length, hot key, big key, expiring key, persistent key, scan-safe design, ownership, lifecycle, documentation, and review checklist.

TTL discipline, expiry behavior, active/passive expiration, TTL jitter, no-expiry risk, eviction policy, memory pressure, and production review checklist for Redis in enterprise Java/JAX-RS systems.

Jedis, Lettuce, Redisson, synchronous/asynchronous/reactive clients, connection pooling, Netty event loop awareness, timeout, reconnect, retry, cluster/sentinel awareness, serialization, metrics, and production review checklist.

HTTP request to Redis command flow, JAX-RS resource boundary, service layer boundary, Redis client injection, request context, timeout propagation, correlation ID, error mapping, fallback, circuit breaker, bulkhead, cache failure behavior, Redis unavailable/slow scenarios, graceful shutdown, connection cleanup, and production review checklist.

String serialization, JSON, Jackson/JSON-B integration, binary serialization, Protobuf, Avro awareness, compression, versioned payload, backward/forward compatibility, schema drift, class rename risk, enum evolution, null handling, date/time format, BigDecimal/currency precision, serialization performance, and review checklist.

Cache mental model, cache hit, miss, fill, expiry, invalidation, cache-aside, read-through, write-through, write-behind, refresh-ahead, local cache, distributed cache, multi-level cache, negative cache, stale cache, consistency, correctness, failure modes, observability, and PR review checklist.

Cache-aside read, cache miss load, cache fill, TTL, invalidation, race condition, double load, stale read, database update plus cache delete, transaction boundary, PostgreSQL/MyBatis integration, Java/JAX-RS implementation, failure modes, observability, and PR review checklist.

Manual, TTL-based, event-driven, Kafka/RabbitMQ-based, write-path invalidation, versioned key, tenant/entity/catalog/rules invalidation, stale data window, invalidation failure modes, Java/JAX-RS implementation, PostgreSQL/MyBatis transaction boundary, observability, and PR review checklist.

Cache stampede, dogpile effect, thundering herd, hot key reload, lock-based protection, single-flight, probabilistic early refresh, TTL jitter, stale-while-revalidate, request coalescing, rate-limited reload, backpressure, fallback to stale, database protection, detection, prevention checklist, and Java/JAX-RS production patterns.

Hot key, big key, wide hash, large list, large set, large sorted set, large stream, network amplification, CPU amplification, memory fragmentation, cluster slot hotspot, key splitting, manual sharding, local cache, approximate data structures, detection, remediation, and production review checklist.

Redis string values, GET/SET, SET NX/XX/EX/PX, INCR/DECR, MGET/MSET, GETSET/GETDEL awareness, counters, tokens, lock primitive, idempotency primitive, simple cache entry, binary value, size consideration, command performance, and Java/JAX-RS production review checklist.

Redis Hash mental model, HGET/HSET, sparse object cache, tenant config, partial update, hash vs JSON string, field TTL limitation, large hash risk, and production review checklist for Java/JAX-RS systems.

Redis List mental model, LPUSH/RPUSH, LPOP/RPOP, BLPOP/BRPOP, LMOVE/BLMOVE, simple queue, work queue, reliable queue pattern, visibility timeout limitation, trimming, large list risk, and list vs stream decision-making.

Redis Set mental model, SADD/SREM, SISMEMBER, SMEMBERS risk, SSCAN, SINTER/SUNION/SDIFF, deduplication, membership, permission set, tenant feature set, idempotency set, cardinality, large set risk, and production review checklist.

Redis Sorted Set mental model, ZADD/ZREM, ZRANGE, ZRANGEBYSCORE, ZCARD, ZCOUNT, ZPOPMIN/ZPOPMAX, ranking, leaderboard, delayed queue, sliding window rate limiter, time-based index, expiry-like cleanup, large sorted set risk, score precision, and production review checklist.

Advanced Redis data structures for compact boolean tracking, packed counters, approximate cardinality, and geospatial lookup, with enterprise Java/JAX-RS production trade-offs.

Redis Pub/Sub mental model, publish/subscribe lifecycle, fire-and-forget delivery, no durability, no replay, subscriber offline behavior, message loss, cache invalidation use case, and comparison with Streams, Kafka, and RabbitMQ.

Redis keyspace and keyevent notifications, expired and evicted event behavior, configuration requirements, Pub/Sub nature, durability limits, expiry caveats, operational risks, and safe enterprise usage.

Redis Streams mental model, stream entries, IDs, XADD, XREAD, consumer groups, XREADGROUP, XACK, pending entry list, XPENDING, XCLAIM, XAUTOCLAIM, trimming, retention, and comparison with lists and Kafka.

Redis Streams as durable queue and event log-lite: worker groups, ack discipline, retry, stale pending claim, poison message handling, DLQ-like stream, trimming, replay, backpressure, ordering, scaling, and production review for Java/JAX-RS systems.

Redis job queue patterns using Lists, Streams, and Sorted Sets: job message design, workers, delayed jobs, retries, poison jobs, priorities, idempotency, timeout, progress, cancellation, visibility-like patterns, observability, and production review.

Rate limiting mental model for enterprise Java/JAX-RS systems: throttling, quotas, burst control, fixed window, sliding window, sliding log, token bucket, leaky bucket, per-IP/user/tenant/endpoint/global limits, local vs distributed limiters, Redis as backend, and production design checklist.

Production-oriented Redis rate limiter implementation patterns: INCR+EXPIRE fixed window, Lua atomicity, sliding log with sorted set, sliding window counter, token bucket, leaky bucket, TTL handling, clock source, Retry-After, 429 responses, memory growth, fairness, performance, and PR review checklist.

Production-oriented idempotency mental model for Java/JAX-RS enterprise systems: idempotency key, request fingerprint, response replay, processing/completed/failed/unknown states, TTL, duplicate requests, retries, concurrent submissions, timeout ambiguity, exactly-once illusion, correctness boundary, and PR review checklist.

Production-oriented Redis idempotency store design: SET NX acquisition, processing marker, response cache, state machine, TTL policy, lock + response pattern, concurrent duplicate requests, request hash mismatch, expired keys, Redis/database failure windows, PostgreSQL integration, Kafka/RabbitMQ integration, and PR review checklist.

Distributed lock mental model for enterprise Java/JAX-RS systems: mutual exclusion, lease, lock owner, lock value, expiry, renewal, fencing token, critical section, clock problem, network partition, process pause, GC pause, correctness boundary, and when not to use distributed locks.

Redis-specific distributed locking implementation: SET NX PX, unique lock value, safe unlock with Lua, lease expiry, renewal, watchdog, Redisson awareness, Redlock algorithm, Redlock controversy, fencing token requirement, database/external/scheduler locks, failure modes, and PR review checklist.

Single-flight, deduplication, distributed semaphore, counter, leader election-lite, global throttle, barrier-like coordination, work claiming, integrity guard, maintenance flag, kill switch, feature flag cache, dan correctness boundary Redis sebagai coordination helper.