✅ 適合：讀多寫少、需要低延遲、可接受資料短暫遺失的場景
❌ 不適合：需要複雜查詢、資料量超過記憶體、強一致性要求

# 1. 快取熱門商品資料
SET product:1001 '{"name":"iPhone","price":35000}' EX 3600

# 2. Session 管理
SET session:abc123 '{"userId":1,"role":"admin"}' EX 1800

# 3. 計數器
INCR page:views:homepage

# 4. 排行榜
ZADD leaderboard 1000 "player1" 950 "player2"

┌─────────────────────────────────┐
│          Application            │
└─────────────┬───────────────────┘
              │
              ▼
┌─────────────────────────────────┐
│        Redis Server             │
│   ┌─────────────────────────┐   │
│   │      Memory Data        │   │
│   └─────────────────────────┘   │
│   ┌─────────────────────────┐   │
│   │    RDB/AOF (Disk)       │   │
│   └─────────────────────────┘   │
└─────────────────────────────────┘

# redis.conf on Replica
replicaof 192.168.1.100 6379
masterauth your_master_password
replica-read-only yes

# sentinel.conf
sentinel monitor mymaster 192.168.1.100 6379 2
sentinel auth-pass mymaster your_password
sentinel down-after-milliseconds mymaster 30000
sentinel failover-timeout mymaster 180000
sentinel parallel-syncs mymaster 1

CLUSTER KEYSLOT mykey
# 結果：5798（該 key 會落在負責 5798 slot 的節點）

# 1. 安裝相依套件
sudo apt update
sudo apt install build-essential tcl

# 2. 下載並解壓縮
wget https://download.redis.io/redis-stable.tar.gz
tar xzf redis-stable.tar.gz
cd redis-stable

# 3. 編譯
make
make test  # 可選，執行測試

# 4. 安裝
sudo make install

# 5. 驗證安裝
redis-server --version
# Redis server v=7.2.4 sha=00000000:0 malloc=jemalloc-5.3.0 bits=64 build=...

# 添加官方 Redis 儲存庫
curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg

echo "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/redis.list

# 安裝
sudo apt update
sudo apt install redis

# 啟動服務
sudo systemctl start redis-server
sudo systemctl enable redis-server

# 拉取映像
docker pull redis:7.2

# 啟動容器
docker run -d \
  --name redis \
  -p 6379:6379 \
  -v /data/redis:/data \
  -v /etc/redis/redis.conf:/usr/local/etc/redis/redis.conf \
  redis:7.2 redis-server /usr/local/etc/redis/redis.conf

# docker-compose.yml
version: '3.8'

services:
  redis:
    image: redis:7.2
    container_name: redis
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data
      - ./redis.conf:/usr/local/etc/redis/redis.conf
    command: redis-server /usr/local/etc/redis/redis.conf
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 3

volumes:
  redis-data:

# docker-compose-sentinel.yml
version: '3.8'

services:
  redis-master:
    image: redis:7.2
    container_name: redis-master
    ports:
      - "6379:6379"
    command: redis-server --requirepass mypassword
    volumes:
      - redis-master-data:/data

  redis-replica-1:
    image: redis:7.2
    container_name: redis-replica-1
    ports:
      - "6380:6379"
    command: redis-server --replicaof redis-master 6379 --masterauth mypassword --requirepass mypassword
    depends_on:
      - redis-master

  redis-replica-2:
    image: redis:7.2
    container_name: redis-replica-2
    ports:
      - "6381:6379"
    command: redis-server --replicaof redis-master 6379 --masterauth mypassword --requirepass mypassword
    depends_on:
      - redis-master

  sentinel-1:
    image: redis:7.2
    container_name: sentinel-1
    ports:
      - "26379:26379"
    command: redis-sentinel /etc/redis/sentinel.conf
    volumes:
      - ./sentinel.conf:/etc/redis/sentinel.conf
    depends_on:
      - redis-master
      - redis-replica-1
      - redis-replica-2

volumes:
  redis-master-data:

/etc/redis/
├── redis.conf          # 主要設定檔
├── sentinel.conf       # Sentinel 設定檔（如使用）
└── users.acl           # ACL 使用者設定

/var/lib/redis/
├── dump.rdb            # RDB 快照檔
└── appendonly.aof      # AOF 持久化檔

/var/log/redis/
└── redis-server.log    # 日誌檔

/var/run/redis/
└── redis-server.pid    # PID 檔

# 本地連線
redis-cli

# 遠端連線
redis-cli -h 192.168.1.100 -p 6379

# 帶密碼連線
redis-cli -h 192.168.1.100 -p 6379 -a your_password

# 連線到特定資料庫
redis-cli -n 1

# 測試連線
127.0.0.1:6379> PING
PONG

# 查看伺服器資訊
127.0.0.1:6379> INFO

# 查看記憶體使用
127.0.0.1:6379> INFO memory

# 查看所有 Key（生產環境慎用）
127.0.0.1:6379> SCAN 0 MATCH "user:*" COUNT 100

# 監控即時命令
127.0.0.1:6379> MONITOR

# 查看慢查詢
127.0.0.1:6379> SLOWLOG GET 10

# 清空資料庫（危險！）
127.0.0.1:6379> FLUSHDB    # 清空當前 DB
127.0.0.1:6379> FLUSHALL   # 清空所有 DB

# 1. 檢查服務狀態
sudo systemctl status redis-server

# 2. 查看日誌
sudo tail -f /var/log/redis/redis-server.log

# 3. 檢查 Port 監聽
sudo netstat -tlnp | grep 6379

# 4. 測試連線
redis-cli ping

# 5. 檢查設定檔語法
redis-server /etc/redis/redis.conf --test-memory 256

# 綁定 IP（安全性考量）
bind 127.0.0.1 192.168.1.100

# 監聽 Port
port 6379

# 背景執行
daemonize yes

# PID 檔案位置
pidfile /var/run/redis/redis-server.pid

# 日誌等級：debug, verbose, notice, warning
loglevel notice

# 日誌檔案
logfile /var/log/redis/redis-server.log

# 資料庫數量（預設 16 個，編號 0-15）
databases 16

# 工作目錄（RDB/AOF 儲存位置）
dir /var/lib/redis

# 最大記憶體限制（建議設為實體記憶體的 70-80%）
maxmemory 4gb

# 記憶體淘汰策略
maxmemory-policy allkeys-lru

# 儲存條件（滿足任一條件就儲存）
save 900 1      # 900 秒內有 1 次修改
save 300 10     # 300 秒內有 10 次修改
save 60 10000   # 60 秒內有 10000 次修改

# 停用 RDB
# save ""

# RDB 檔名
dbfilename dump.rdb

# 壓縮（建議開啟）
rdbcompression yes

# 校驗（建議開啟）
rdbchecksum yes

# 啟用 AOF
appendonly yes

# AOF 檔名
appendfilename "appendonly.aof"

# 同步策略
# always: 每次寫入都同步（最安全，最慢）
# everysec: 每秒同步一次（建議）
# no: 由作業系統決定（最快，最不安全）
appendfsync everysec

# AOF 重寫設定
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

# 混合持久化（Redis 4.0+，建議開啟）
aof-use-rdb-preamble yes

# 設定密碼供 Replica 連線
requirepass your_master_password
masterauth your_master_password  # 如果 Master 也可能變成 Replica

# 指定 Master
replicaof 192.168.1.100 6379

# Master 密碼
masterauth your_master_password

# Replica 唯讀（建議）
replica-read-only yes

# 複寫積壓緩衝區（支援部分重同步）
repl-backlog-size 64mb

# 複寫超時
repl-timeout 60

# 啟用 Cluster 模式
cluster-enabled yes

# Cluster 設定檔（自動維護）
cluster-config-file nodes.conf

# 節點超時時間
cluster-node-timeout 15000

# 至少需要多少 Replica 才允許 Master 失敗
cluster-replica-validity-factor 10

# 是否允許部分 Slot 不可用時繼續服務
cluster-require-full-coverage yes

# 監控的 Master
sentinel monitor mymaster 192.168.1.100 6379 2

# Master 密碼
sentinel auth-pass mymaster your_password

# 判定主觀下線時間（毫秒）
sentinel down-after-milliseconds mymaster 30000

# 故障轉移超時
sentinel failover-timeout mymaster 180000

# 同時進行同步的 Replica 數量
sentinel parallel-syncs mymaster 1

# 綁定特定 IP（不要使用 0.0.0.0）
bind 127.0.0.1 192.168.1.100

# 保護模式（建議開啟）
protected-mode yes

# 設定密碼
requirepass your_strong_password_here

# 停用危險命令
rename-command FLUSHDB ""
rename-command FLUSHALL ""
rename-command DEBUG ""
rename-command CONFIG "ADMIN_CONFIG"

# ACL（Redis 6.0+）- 詳見 ACL 章節
# aclfile /etc/redis/users.acl

# 建立使用者
ACL SETUSER app_user on >app_password ~app:* +@read +@write -@dangerous

# 建立唯讀使用者
ACL SETUSER readonly_user on >readonly_password ~* +@read -@write

# 查看使用者列表
ACL LIST

# 儲存 ACL 設定
ACL SAVE

# 設定值
SET key value
SET key value EX 3600              # 設定並指定過期時間（秒）
SET key value PX 3600000           # 設定並指定過期時間（毫秒）
SET key value NX                   # 只在 Key 不存在時設定
SET key value XX                   # 只在 Key 存在時設定
SETNX key value                    # 等同 SET key value NX
SETEX key 3600 value               # 等同 SET key value EX 3600

# 取得值
GET key
MGET key1 key2 key3                # 批次取得

# 批次設定
MSET key1 value1 key2 value2

# 數值操作
INCR counter                       # +1
INCRBY counter 10                  # +10
INCRBYFLOAT counter 1.5            # +1.5
DECR counter                       # -1
DECRBY counter 10                  # -10

# 字串操作
APPEND key " appended"             # 追加
STRLEN key                         # 長度
GETRANGE key 0 4                   # 子字串

# 快取使用者資料
SET user:1001 '{"id":1001,"name":"John","email":"john@example.com"}' EX 3600

# 頁面瀏覽計數
INCR page:views:homepage

# 分散式鎖（簡易版）
SET lock:order:123 "owner_id" NX EX 30
# 成功回傳 OK，失敗回傳 nil

# 設定欄位
HSET user:1001 name "John"
HSET user:1001 email "john@example.com" age 30

# 取得欄位
HGET user:1001 name
HMGET user:1001 name email
HGETALL user:1001

# 欄位操作
HDEL user:1001 age                 # 刪除欄位
HEXISTS user:1001 name             # 檢查欄位是否存在
HLEN user:1001                     # 欄位數量
HKEYS user:1001                    # 所有欄位名稱
HVALS user:1001                    # 所有欄位值

# 數值操作
HINCRBY user:1001 login_count 1
HINCRBYFLOAT user:1001 balance 10.5

# 掃描（大 Hash 時使用）
HSCAN user:1001 0 MATCH "name*" COUNT 10

# 儲存使用者資料
HSET user:1001 name "John" email "john@example.com" age 30 login_count 0

# 更新登入次數
HINCRBY user:1001 login_count 1

# 取得特定欄位
HMGET user:1001 name email

# 新增元素
LPUSH mylist value1 value2         # 從左邊加入
RPUSH mylist value3 value4         # 從右邊加入

# 取出元素
LPOP mylist                        # 從左邊取出
RPOP mylist                        # 從右邊取出
BLPOP mylist 10                    # 阻塞式取出（等待 10 秒）
BRPOP mylist 10

# 查詢
LRANGE mylist 0 -1                 # 取得所有元素
LRANGE mylist 0 9                  # 取得前 10 個
LINDEX mylist 0                    # 取得指定位置元素
LLEN mylist                        # 長度

# 修剪
LTRIM mylist 0 99                  # 只保留前 100 個元素

# 移動（Redis 6.2+）
LMOVE source destination LEFT RIGHT

# 訊息佇列 - 生產者
RPUSH queue:orders '{"orderId":1001,"amount":500}'

# 訊息佇列 - 消費者
BLPOP queue:orders 30

# 最新動態（保留最新 100 則）
LPUSH timeline:user:1001 '{"type":"post","content":"Hello"}'
LTRIM timeline:user:1001 0 99

# 新增成員
SADD myset member1 member2 member3

# 移除成員
SREM myset member1

# 查詢
SMEMBERS myset                     # 所有成員
SISMEMBER myset member1            # 是否為成員
SCARD myset                        # 成員數量
SRANDMEMBER myset 3                # 隨機取 3 個（不移除）
SPOP myset 1                       # 隨機取出 1 個（移除）

# 集合運算
SINTER set1 set2                   # 交集
SUNION set1 set2                   # 聯集
SDIFF set1 set2                    # 差集

# 掃描
SSCAN myset 0 MATCH "member*" COUNT 10

# 使用者標籤
SADD user:1001:tags "vip" "active" "premium"

# 共同好友
SADD user:1001:friends "user:1002" "user:1003" "user:1004"
SADD user:1002:friends "user:1001" "user:1003" "user:1005"
SINTER user:1001:friends user:1002:friends
# 結果：user:1003

# 抽獎
SADD lottery:participants "user:1001" "user:1002" "user:1003"
SRANDMEMBER lottery:participants 1  # 抽出 1 位中獎者

# 新增成員
ZADD leaderboard 1000 "player1"
ZADD leaderboard 950 "player2" 900 "player3"

# 更新分數
ZINCRBY leaderboard 50 "player1"   # +50 分

# 查詢排名
ZRANK leaderboard "player1"        # 排名（從 0 開始，分數低到高）
ZREVRANK leaderboard "player1"     # 反向排名（分數高到低）
ZSCORE leaderboard "player1"       # 取得分數

# 範圍查詢
ZRANGE leaderboard 0 9             # 前 10 名（分數低到高）
ZREVRANGE leaderboard 0 9          # 前 10 名（分數高到低）
ZREVRANGE leaderboard 0 9 WITHSCORES  # 含分數

# 分數範圍查詢
ZRANGEBYSCORE leaderboard 900 1000
ZCOUNT leaderboard 900 1000        # 分數在 900-1000 的數量

# 移除
ZREM leaderboard "player1"
ZREMRANGEBYRANK leaderboard 0 -11  # 移除排名外的（保留前 10）
ZREMRANGEBYSCORE leaderboard -inf 500  # 移除分數 500 以下

# 集合運算
ZUNIONSTORE out 2 zset1 zset2 WEIGHTS 1 2
ZINTERSTORE out 2 zset1 zset2

# 排行榜
ZADD game:leaderboard 1000 "player1" 950 "player2" 900 "player3"
ZREVRANGE game:leaderboard 0 9 WITHSCORES  # Top 10

# 延遲佇列（分數 = 執行時間戳）
ZADD delay:queue 1706500000 '{"task":"send_email","to":"user@example.com"}'
# 取得到期任務
ZRANGEBYSCORE delay:queue -inf 1706499999

# 滑動視窗限流
# 記錄請求時間戳
ZADD rate:limit:user:1001 1706499990 "req1" 1706499991 "req2"
# 移除過期記錄
ZREMRANGEBYSCORE rate:limit:user:1001 -inf 1706499900
# 計算視窗內請求數
ZCARD rate:limit:user:1001

# 設定位元
SETBIT user:1001:signin 0 1        # 第 0 天簽到
SETBIT user:1001:signin 1 1        # 第 1 天簽到
SETBIT user:1001:signin 2 0        # 第 2 天未簽到

# 取得位元
GETBIT user:1001:signin 1          # 回傳 1

# 統計
BITCOUNT user:1001:signin          # 總簽到天數

# 位元運算
BITOP AND result bitmap1 bitmap2

# 新增元素
PFADD visitors "user1" "user2" "user3"

# 估算數量
PFCOUNT visitors

# 合併
PFMERGE result hll1 hll2

# 新增訊息
XADD mystream * field1 value1 field2 value2

# 讀取訊息
XREAD COUNT 10 STREAMS mystream 0

# 消費者群組
XGROUP CREATE mystream mygroup $ MKSTREAM
XREADGROUP GROUP mygroup consumer1 COUNT 10 STREAMS mystream >

# 確認處理完成
XACK mystream mygroup message_id

// Java 範例（Spring Boot）
public User getUser(Long userId) {
    String key = "user:" + userId;
    
    // 1. 查詢快取
    String cached = redisTemplate.opsForValue().get(key);
    if (cached != null) {
        return objectMapper.readValue(cached, User.class);
    }
    
    // 2. 查詢資料庫
    User user = userRepository.findById(userId).orElse(null);
    if (user != null) {
        // 3. 寫入快取
        redisTemplate.opsForValue().set(key, objectMapper.writeValueAsString(user), 
            Duration.ofHours(1));
    }
    return user;
}

格式：{業務}:{模組}:{實體}:{識別碼}

範例：
- user:profile:1001          # 使用者資料
- order:detail:ORD202401001  # 訂單詳情
- cache:product:list:page:1  # 商品列表第 1 頁
- session:abc123             # Session
- lock:order:create:1001     # 分散式鎖

# 設定 TTL
SET key value EX 3600          # 1 小時
EXPIRE key 3600                # 對已存在的 Key 設定
EXPIREAT key 1706500000        # 指定 Unix 時間戳

# 查詢剩餘時間
TTL key                        # 秒
PTTL key                       # 毫秒

# 移除 TTL
PERSIST key

<!-- pom.xml -->
<dependency>
    <groupId>org.springframework.session</groupId>
    <artifactId>spring-session-data-redis</artifactId>
</dependency>

# application.yml
spring:
  session:
    store-type: redis
    timeout: 30m
  redis:
    host: localhost
    port: 6379
    password: your_password

@Configuration
@EnableRedisHttpSession(maxInactiveIntervalInSeconds = 1800)
public class SessionConfig {
}

# Lua Script
local key = KEYS[1]
local limit = tonumber(ARGV[1])
local window = tonumber(ARGV[2])

local current = redis.call('GET', key)
if current and tonumber(current) >= limit then
    return 0
end

current = redis.call('INCR', key)
if tonumber(current) == 1 then
    redis.call('EXPIRE', key, window)
end
return 1

public boolean isAllowed(String userId, int limit, int windowSeconds) {
    String key = "rate:" + userId;
    long now = System.currentTimeMillis();
    long windowStart = now - (windowSeconds * 1000L);
    
    // 移除過期記錄
    redisTemplate.opsForZSet().removeRangeByScore(key, 0, windowStart);
    
    // 計算當前視窗請求數
    Long count = redisTemplate.opsForZSet().count(key, windowStart, now);
    
    if (count != null && count >= limit) {
        return false;
    }
    
    // 記錄本次請求
    redisTemplate.opsForZSet().add(key, UUID.randomUUID().toString(), now);
    redisTemplate.expire(key, Duration.ofSeconds(windowSeconds));
    
    return true;
}

# 獲取鎖
SET lock:resource:123 "owner_uuid" NX EX 30

# 釋放鎖（Lua Script 確保原子性）
if redis.call("GET", KEYS[1]) == ARGV[1] then
    return redis.call("DEL", KEYS[1])
else
    return 0
end

@Service
public class DistributedLockService {
    
    @Autowired
    private StringRedisTemplate redisTemplate;
    
    public boolean tryLock(String key, String value, long expireSeconds) {
        Boolean result = redisTemplate.opsForValue()
            .setIfAbsent(key, value, Duration.ofSeconds(expireSeconds));
        return Boolean.TRUE.equals(result);
    }
    
    public boolean unlock(String key, String value) {
        String script = 
            "if redis.call('GET', KEYS[1]) == ARGV[1] then " +
            "    return redis.call('DEL', KEYS[1]) " +
            "else " +
            "    return 0 " +
            "end";
        
        Long result = redisTemplate.execute(
            new DefaultRedisScript<>(script, Long.class),
            Collections.singletonList(key),
            value
        );
        return Long.valueOf(1).equals(result);
    }
}

# 生產者
RPUSH queue:tasks '{"taskId":1,"type":"email"}'

# 消費者（阻塞式）
BLPOP queue:tasks 30

# 訂閱者
SUBSCRIBE channel:notifications

# 發布者
PUBLISH channel:notifications '{"type":"alert","message":"System update"}'

# 建立消費者群組
XGROUP CREATE orders:stream orders-group $ MKSTREAM

# 生產者
XADD orders:stream * orderId 1001 status pending

# 消費者
XREADGROUP GROUP orders-group consumer-1 COUNT 10 BLOCK 5000 STREAMS orders:stream >

# 確認處理完成
XACK orders:stream orders-group 1706500000000-0

# 查看待處理訊息
XPENDING orders:stream orders-group

<dependencies>
    <!-- Spring Data Redis -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    
    <!-- Connection Pool -->
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
    </dependency>
</dependencies>

# application.yml
spring:
  redis:
    # 單節點
    host: localhost
    port: 6379
    password: your_password
    database: 0
    
    # Connection Pool
    lettuce:
      pool:
        max-active: 8
        max-idle: 8
        min-idle: 2
        max-wait: -1ms
      shutdown-timeout: 100ms
    
    # 超時設定
    timeout: 3000ms
    connect-timeout: 3000ms

---
# Sentinel 設定
spring:
  redis:
    sentinel:
      master: mymaster
      nodes:
        - 192.168.1.101:26379
        - 192.168.1.102:26379
        - 192.168.1.103:26379
    password: your_password

---
# Cluster 設定
spring:
  redis:
    cluster:
      nodes:
        - 192.168.1.101:6379
        - 192.168.1.102:6379
        - 192.168.1.103:6379
        - 192.168.1.104:6379
        - 192.168.1.105:6379
        - 192.168.1.106:6379
      max-redirects: 3
    password: your_password

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        
        // Key 序列化
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        
        // Value 序列化（使用 JSON）
        Jackson2JsonRedisSerializer<Object> jsonSerializer = 
            new Jackson2JsonRedisSerializer<>(Object.class);
        
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.activateDefaultTyping(
            LaissezFaireSubTypeValidator.instance,
            ObjectMapper.DefaultTyping.NON_FINAL
        );
        jsonSerializer.setObjectMapper(objectMapper);
        
        template.setValueSerializer(jsonSerializer);
        template.setHashValueSerializer(jsonSerializer);
        
        template.afterPropertiesSet();
        return template;
    }
    
    @Bean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory factory) {
        return new StringRedisTemplate(factory);
    }
}

@Service
public class UserCacheService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    
    private static final String USER_KEY_PREFIX = "user:";
    private static final Duration DEFAULT_TTL = Duration.ofHours(1);
    
    // 儲存使用者
    public void saveUser(User user) {
        String key = USER_KEY_PREFIX + user.getId();
        redisTemplate.opsForValue().set(key, user, DEFAULT_TTL);
    }
    
    // 取得使用者
    public User getUser(Long userId) {
        String key = USER_KEY_PREFIX + userId;
        return (User) redisTemplate.opsForValue().get(key);
    }
    
    // 刪除使用者快取
    public void deleteUser(Long userId) {
        String key = USER_KEY_PREFIX + userId;
        redisTemplate.delete(key);
    }
    
    // 批次操作
    public List<User> getUsers(List<Long> userIds) {
        List<String> keys = userIds.stream()
            .map(id -> USER_KEY_PREFIX + id)
            .collect(Collectors.toList());
        
        List<Object> results = redisTemplate.opsForValue().multiGet(keys);
        return results.stream()
            .filter(Objects::nonNull)
            .map(obj -> (User) obj)
            .collect(Collectors.toList());
    }
    
    // 使用 Hash
    public void saveUserAsHash(User user) {
        String key = "user:hash:" + user.getId();
        Map<String, Object> map = new HashMap<>();
        map.put("name", user.getName());
        map.put("email", user.getEmail());
        map.put("age", String.valueOf(user.getAge()));
        
        redisTemplate.opsForHash().putAll(key, map);
        redisTemplate.expire(key, DEFAULT_TTL);
    }
}

@Configuration
@EnableCaching
public class CacheConfig {

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofHours(1))
            .serializeKeysWith(
                RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer())
            )
            .serializeValuesWith(
                RedisSerializationContext.SerializationPair.fromSerializer(
                    new GenericJackson2JsonRedisSerializer()
                )
            )
            .disableCachingNullValues();
        
        return RedisCacheManager.builder(factory)
            .cacheDefaults(config)
            .build();
    }
}

@Service
public class ProductService {

    @Cacheable(value = "products", key = "#id")
    public Product getProduct(Long id) {
        // 查詢資料庫
        return productRepository.findById(id).orElse(null);
    }
    
    @CachePut(value = "products", key = "#product.id")
    public Product updateProduct(Product product) {
        return productRepository.save(product);
    }
    
    @CacheEvict(value = "products", key = "#id")
    public void deleteProduct(Long id) {
        productRepository.deleteById(id);
    }
    
    @CacheEvict(value = "products", allEntries = true)
    public void clearAllProductCache() {
        // 清除所有 products 快取
    }
}

const Redis = require('ioredis');

// 單節點
const redis = new Redis({
  host: 'localhost',
  port: 6379,
  password: 'your_password',
  db: 0,
  retryDelayOnFailover: 100,
  maxRetriesPerRequest: 3
});

// Sentinel
const redis = new Redis({
  sentinels: [
    { host: '192.168.1.101', port: 26379 },
    { host: '192.168.1.102', port: 26379 },
    { host: '192.168.1.103', port: 26379 }
  ],
  name: 'mymaster',
  password: 'your_password'
});

// Cluster
const redis = new Redis.Cluster([
  { host: '192.168.1.101', port: 6379 },
  { host: '192.168.1.102', port: 6379 },
  { host: '192.168.1.103', port: 6379 }
], {
  redisOptions: { password: 'your_password' }
});

// 使用
await redis.set('key', 'value', 'EX', 3600);
const value = await redis.get('key');

import redis
from redis.sentinel import Sentinel

# 單節點
r = redis.Redis(
    host='localhost',
    port=6379,
    password='your_password',
    db=0,
    decode_responses=True
)

# Sentinel
sentinel = Sentinel([
    ('192.168.1.101', 26379),
    ('192.168.1.102', 26379),
    ('192.168.1.103', 26379)
], socket_timeout=0.5)

master = sentinel.master_for('mymaster', password='your_password')
slave = sentinel.slave_for('mymaster', password='your_password')

# Cluster
from redis.cluster import RedisCluster

rc = RedisCluster(
    host='192.168.1.101',
    port=6379,
    password='your_password'
)

# 使用
r.set('key', 'value', ex=3600)
value = r.get('key')

@Configuration
public class RedisResilienceConfig {

    @Bean
    public LettuceClientConfiguration lettuceClientConfiguration() {
        return LettuceClientConfiguration.builder()
            .commandTimeout(Duration.ofSeconds(3))       // 命令超時
            .shutdownTimeout(Duration.ofMillis(100))
            .clientOptions(ClientOptions.builder()
                .disconnectedBehavior(
                    ClientOptions.DisconnectedBehavior.REJECT_COMMANDS
                )
                .autoReconnect(true)
                .build())
            .build();
    }
}

@Service
public class ResilientCacheService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private UserRepository userRepository;
    
    private static final int MAX_RETRIES = 3;
    
    public User getUserWithFallback(Long userId) {
        String key = "user:" + userId;
        
        // 嘗試從快取取得
        for (int i = 0; i < MAX_RETRIES; i++) {
            try {
                User cached = (User) redisTemplate.opsForValue().get(key);
                if (cached != null) {
                    return cached;
                }
                break; // 快取未命中，跳出重試
            } catch (Exception e) {
                log.warn("Redis 存取失敗，重試 {}/{}", i + 1, MAX_RETRIES, e);
                if (i == MAX_RETRIES - 1) {
                    log.error("Redis 不可用，改為直接查詢資料庫");
                }
            }
        }
        
        // Fallback: 直接查詢資料庫
        User user = userRepository.findById(userId).orElse(null);
        
        // 嘗試更新快取（非同步，不影響回應）
        if (user != null) {
            try {
                redisTemplate.opsForValue().set(key, user, Duration.ofHours(1));
            } catch (Exception e) {
                log.warn("更新快取失敗", e);
            }
        }
        
        return user;
    }
}

@Service
public class CircuitBreakerCacheService {

    private final CircuitBreaker circuitBreaker;
    private final RedisTemplate<String, Object> redisTemplate;
    
    public CircuitBreakerCacheService(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
        this.circuitBreaker = CircuitBreaker.ofDefaults("redis");
    }
    
    public Optional<User> getUser(Long userId) {
        return Try.ofSupplier(
            CircuitBreaker.decorateSupplier(circuitBreaker, () -> {
                String key = "user:" + userId;
                return Optional.ofNullable((User) redisTemplate.opsForValue().get(key));
            })
        ).recover(throwable -> {
            log.error("Redis Circuit Breaker 觸發", throwable);
            return Optional.empty();
        }).get();
    }
}

# 完整資訊
INFO

# 特定區塊
INFO server          # 伺服器資訊
INFO clients         # 用戶端資訊
INFO memory          # 記憶體資訊
INFO persistence     # 持久化資訊
INFO stats           # 統計資訊
INFO replication     # 複寫資訊
INFO cpu             # CPU 使用
INFO cluster         # Cluster 資訊
INFO keyspace        # 資料庫統計

# 記憶體相關
used_memory:1073741824              # 已使用 1GB
used_memory_human:1.00G
used_memory_rss:1200000000          # 系統實際分配
mem_fragmentation_ratio:1.12        # 碎片率（1.0-1.5 正常）
maxmemory:4294967296                # 上限 4GB
maxmemory_policy:allkeys-lru        # 淘汰策略

# 效能相關
total_connections_received:10000    # 總連線數
total_commands_processed:5000000    # 總命令數
instantaneous_ops_per_sec:1234      # 當前 QPS

# 命中率
keyspace_hits:4500000
keyspace_misses:500000
# 命中率 = 4500000 / (4500000 + 500000) = 90%

# 複寫相關
role:master
connected_slaves:2
slave0:ip=192.168.1.101,port=6379,state=online,offset=1234567,lag=0
slave1:ip=192.168.1.102,port=6379,state=online,offset=1234567,lag=1

# 設定慢查詢閾值（微秒）
CONFIG SET slowlog-log-slower-than 10000   # 10ms

# 設定慢查詢日誌長度
CONFIG SET slowlog-max-len 128

# 查看慢查詢
SLOWLOG GET 10

# 結果範例：
# 1) 1) (integer) 14                 # ID
#    2) (integer) 1706500000         # Unix 時間戳
#    3) (integer) 15000              # 執行時間（微秒）
#    4) 1) "KEYS"                    # 命令
#       2) "*"
#    5) "192.168.1.100:12345"        # 用戶端

# 清空慢查詢日誌
SLOWLOG RESET

# 查看慢查詢數量
SLOWLOG LEN

# 使用 redis-cli（推薦）
redis-cli --bigkeys

# 輸出範例：
# Biggest string found 'user:session:abc123' has 10240 bytes
# Biggest hash found 'config:settings' has 1000 fields
# Biggest list found 'queue:tasks' has 50000 members

# 使用 MEMORY USAGE（Redis 4.0+）
MEMORY USAGE key_name

# 掃描特定 pattern
redis-cli --scan --pattern "cache:*" | while read key; do
  size=$(redis-cli MEMORY USAGE "$key")
  echo "$key: $size bytes"
done

# 大 Hash 分片
# 原本：user:1001（含 10000 個欄位）
# 改為：user:1001:0, user:1001:1, ... user:1001:9（每個 1000 欄位）

# 大 List 分頁
# 原本：queue:tasks（100000 筆）
# 改為：queue:tasks:page:1, queue:tasks:page:2, ...

// 批次操作優化
public void batchSet(Map<String, String> data) {
    redisTemplate.executePipelined((RedisCallback<Object>) connection -> {
        StringRedisConnection stringConn = (StringRedisConnection) connection;
        data.forEach((key, value) -> {
            stringConn.set(key, value);
        });
        return null;
    });
}

# 1. 升級 Replica（逐一進行）
sudo systemctl stop redis-server
# 備份資料與設定
cp /var/lib/redis/dump.rdb /backup/
cp /etc/redis/redis.conf /backup/

# 升級 Redis
sudo apt update && sudo apt upgrade redis-server

# 啟動並驗證
sudo systemctl start redis-server
redis-cli INFO server | grep redis_version

# 2. 確認複寫正常
redis-cli INFO replication
# 確認 master_link_status:up

# 3. 手動故障轉移（讓已升級的 Replica 成為 Master）
redis-cli -p 26379 SENTINEL failover mymaster

# 4. 升級舊 Master（現在是 Replica）
# 重複步驟 1

# 5. 升級所有 Sentinel
sudo systemctl stop redis-sentinel
sudo apt upgrade redis-sentinel
sudo systemctl start redis-sentinel

# 1. 逐一升級 Replica
# 對每個 Replica 執行：
redis-cli -h replica-host CLUSTER FAILOVER  # 先故障轉移
# 升級後重新加入 Cluster

# 2. 升級原 Master（現為 Replica）

# 3. 驗證 Cluster 狀態
redis-cli CLUSTER INFO
redis-cli CLUSTER NODES

# 1. 停止服務
sudo systemctl stop redis-server

# 2. 降級版本
sudo apt install redis-server=6.2.x  # 指定舊版本

# 3. 還原設定
cp /backup/redis.conf /etc/redis/

# 4. 還原資料（如需要）
cp /backup/dump.rdb /var/lib/redis/

# 5. 啟動服務
sudo systemctl start redis-server

# 6. 驗證
redis-cli INFO server
redis-cli PING

# 升級前備份
redis-cli BGSAVE
cp /var/lib/redis/dump.rdb /backup/dump.rdb.$(date +%Y%m%d)

# 升級後驗證資料完整性
redis-cli DBSIZE
redis-cli INFO keyspace

# 僅允許應用程式伺服器存取
iptables -A INPUT -p tcp --dport 6379 -s 192.168.1.0/24 -j ACCEPT
iptables -A INPUT -p tcp --dport 6379 -j DROP

# 或使用 Redis 設定
bind 192.168.1.100      # 僅綁定內網 IP
protected-mode yes      # 保護模式

# 建立不同角色的使用者

# 1. 管理員（完整權限）
ACL SETUSER admin on >StrongAdminPass!123 ~* &* +@all

# 2. 應用程式使用者（限制危險命令）
ACL SETUSER app_user on >AppUserPass!456 ~app:* +@all -@dangerous -@admin -DEBUG -SHUTDOWN

# 3. 唯讀使用者
ACL SETUSER readonly_user on >ReadOnlyPass!789 ~* +@read -@write -@admin -@dangerous

# 4. 特定前綴使用者
ACL SETUSER order_service on >OrderPass!000 ~order:* ~cache:order:* +@read +@write +@connection -KEYS -FLUSHALL -FLUSHDB

# 查看使用者
ACL LIST
ACL WHOAMI

# 測試權限
ACL DRYRUN app_user SET app:key value    # OK
ACL DRYRUN app_user FLUSHALL             # ERR

# 儲存到設定檔
ACL SAVE

user default off
user admin on >StrongAdminPass!123 ~* &* +@all
user app_user on >AppUserPass!456 ~app:* +@all -@dangerous -@admin
user readonly_user on >ReadOnlyPass!789 ~* +@read

# redis.conf - 重新命名或停用危險命令
rename-command FLUSHDB ""                    # 完全停用
rename-command FLUSHALL ""
rename-command DEBUG ""
rename-command CONFIG "ADMIN_CONFIG_a1b2c3"  # 重新命名
rename-command KEYS "ADMIN_KEYS_x1y2z3"
rename-command SHUTDOWN "ADMIN_SHUTDOWN_p1q2r3"

# ❌ 危險操作
KEYS *                    # 阻塞服務
FLUSHALL                  # 清空所有資料
DEBUG SEGFAULT            # 觸發 crash

# ✅ 安全替代
SCAN 0 MATCH "*" COUNT 100   # 非阻塞掃描
# 使用 ACL 限制 FLUSHALL
# 禁用 DEBUG 命令

# 定期備份 RDB
0 */4 * * * /usr/bin/redis-cli BGSAVE && cp /var/lib/redis/dump.rdb /backup/dump.rdb.$(date +\%Y\%m\%d\%H\%M)

# 保留策略
find /backup -name "dump.rdb.*" -mtime +7 -delete

# redis.conf 安全設定範本

# 1. 網路安全
bind 192.168.1.100 127.0.0.1    # 限制綁定 IP
port 6379
protected-mode yes
timeout 300                      # 閒置超時

# 2. 認證授權
requirepass YourVeryStrongPassword!@#$%
aclfile /etc/redis/users.acl

# 3. 停用危險命令
rename-command FLUSHDB ""
rename-command FLUSHALL ""
rename-command DEBUG ""
rename-command CONFIG "ADMIN_CONFIG_secret"
rename-command KEYS "ADMIN_KEYS_secret"

# 4. 資源限制
maxclients 10000
maxmemory 4gb
maxmemory-policy allkeys-lru

# 5. 日誌
loglevel notice
logfile /var/log/redis/redis-server.log

# 6. TLS（Redis 6.0+）
tls-port 6380
tls-cert-file /etc/redis/tls/redis.crt
tls-key-file /etc/redis/tls/redis.key
tls-ca-cert-file /etc/redis/tls/ca.crt
tls-auth-clients yes

# 產生憑證（測試用）
openssl genrsa -out ca.key 4096
openssl req -x509 -new -nodes -sha256 -key ca.key -days 3650 -subj "/CN=Redis-CA" -out ca.crt

openssl genrsa -out redis.key 2048
openssl req -new -sha256 -key redis.key -subj "/CN=redis-server" -out redis.csr
openssl x509 -req -sha256 -in redis.csr -CA ca.crt -CAkey ca.key -CAcreateserial -days 365 -out redis.crt

# redis.conf
tls-port 6380
tls-cert-file /etc/redis/tls/redis.crt
tls-key-file /etc/redis/tls/redis.key
tls-ca-cert-file /etc/redis/tls/ca.crt
tls-auth-clients yes

# 連線（使用 TLS）
redis-cli --tls --cert ./redis.crt --key ./redis.key --cacert ./ca.crt -p 6380

格式：{業務}:{模組}:{實體}:{識別碼}

範例：
✅ user:profile:1001
✅ order:detail:ORD202401001
✅ cache:product:list:category:electronics:page:1
✅ session:web:abc123def456
✅ lock:order:create:1001

❌ user_profile_1001          # 不使用底線
❌ UserProfile:1001           # 不使用大寫
❌ 1001                       # 無意義的 Key
❌ cache:product:list:category:electronics:brand:apple:page:1:sort:price:order:asc  # 過長

// 方案 1：本地快取
private LoadingCache<String, Object> localCache = CacheBuilder.newBuilder()
    .maximumSize(1000)
    .expireAfterWrite(10, TimeUnit.SECONDS)
    .build(new CacheLoader<String, Object>() {
        @Override
        public Object load(String key) {
            return redisTemplate.opsForValue().get(key);
        }
    });

// 方案 2：Key 分散
public String getHotData(String hotKey) {
    // 分散到多個 Key
    int shard = ThreadLocalRandom.current().nextInt(10);
    String shardedKey = hotKey + ":shard:" + shard;
    return redisTemplate.opsForValue().get(shardedKey);
}

@Service
@Transactional
public class UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    // 更新使用者（Cache Aside）
    public User updateUser(User user) {
        // 1. 更新資料庫
        User updated = userRepository.save(user);
        
        // 2. 刪除快取（而非更新，避免並發問題）
        String key = "user:" + user.getId();
        redisTemplate.delete(key);
        
        return updated;
    }
    
    // 防止快取穿透（查詢不存在的資料）
    public User getUser(Long userId) {
        String key = "user:" + userId;
        Object cached = redisTemplate.opsForValue().get(key);
        
        // 快取空值標記
        if ("NULL".equals(cached)) {
            return null;
        }
        
        if (cached != null) {
            return (User) cached;
        }
        
        User user = userRepository.findById(userId).orElse(null);
        if (user != null) {
            redisTemplate.opsForValue().set(key, user, Duration.ofHours(1));
        } else {
            // 快取空值，較短 TTL
            redisTemplate.opsForValue().set(key, "NULL", Duration.ofMinutes(5));
        }
        return user;
    }
}

// TTL 加上隨機偏移，避免同時過期
public void setWithRandomTtl(String key, Object value, Duration baseTtl) {
    // 基礎 TTL + 0~10% 隨機
    long randomOffset = (long) (baseTtl.toMillis() * Math.random() * 0.1);
    Duration ttl = baseTtl.plusMillis(randomOffset);
    redisTemplate.opsForValue().set(key, value, ttl);
}

# Redis 使用規範 v1.0

## 1. Key 命名規範
- 格式：{業務}:{模組}:{實體}:{識別碼}
- 全小寫，使用冒號分隔
- 長度不超過 100 bytes

## 2. TTL 規範
- 所有快取 Key 必須設定 TTL
- Session：30 分鐘
- 使用者資料：1-24 小時
- 列表/搜尋結果：5-30 分鐘
- 設定資料：1-7 天

## 3. 資料大小限制
- String Value：< 10KB
- Hash/Set/ZSet/List 成員數：< 1000
- 單一成員大小：< 1KB

## 4. 禁止操作
- 禁止使用 KEYS 命令
- 禁止在業務代碼中使用 FLUSHDB/FLUSHALL
- 禁止儲存敏感資料（密碼、金鑰等）

## 5. 效能要求
- 單一命令執行時間 < 10ms
- Pipeline 批次操作 < 100 個命令
- 連線池正確使用，禁止頻繁建立連線

## 6. 監控告警
- 記憶體使用率 > 80% 告警
- 命中率 < 90% 告警
- 延遲 > 10ms 告警

# 1. 檢查服務狀態
sudo systemctl status redis-server

# 2. 查看日誌
sudo tail -100 /var/log/redis/redis-server.log

# 3. 檢查系統資源
free -h                    # 記憶體
df -h                      # 磁碟空間
dmesg | tail -50           # 系統日誌（OOM Killer）

# 4. 檢查 Port
netstat -tlnp | grep 6379

# 從 RDB 恢復
sudo systemctl stop redis-server
cp /backup/dump.rdb /var/lib/redis/
sudo chown redis:redis /var/lib/redis/dump.rdb
sudo systemctl start redis-server

# 修復損壞的 AOF
redis-check-aof --fix /var/lib/redis/appendonly.aof

# 查看記憶體使用
redis-cli INFO memory

# 重要指標
used_memory_human:2.00G        # 實際使用
used_memory_rss_human:2.50G    # 系統分配
mem_fragmentation_ratio:1.25   # 碎片率

# 分析 Key 分布
redis-cli --bigkeys

# 查看各資料庫 Key 數量
redis-cli INFO keyspace

# 清理過期 Key（主動掃描）
redis-cli --scan --pattern "cache:*" | xargs -L 100 redis-cli DEL

# 整理記憶體碎片（Redis 4.0+）
redis-cli MEMORY PURGE

# 調整淘汰策略
redis-cli CONFIG SET maxmemory-policy allkeys-lru
redis-cli CONFIG SET maxmemory 4gb

# 計算命中率
redis-cli INFO stats | grep keyspace
# keyspace_hits:4500000
# keyspace_misses:500000
# Hit Rate = 4500000 / (4500000 + 500000) = 90%

# Master 端
redis-cli INFO replication
# role:master
# connected_slaves:2
# slave0:ip=192.168.1.101,port=6379,state=online,offset=1234567,lag=0
# slave1:ip=192.168.1.102,port=6379,state=online,offset=1234560,lag=1

# Replica 端
redis-cli INFO replication
# role:slave
# master_link_status:up
# master_last_io_seconds_ago:0
# master_sync_in_progress:0

# 調整 backlog size
redis-cli CONFIG SET repl-backlog-size 128mb

# 檢查是否在全量同步
redis-cli INFO replication | grep master_sync_in_progress

# 1. 檢查慢查詢
redis-cli SLOWLOG GET 10
# 發現大量 KEYS pattern* 命令

# 2. 追查來源
redis-cli CLIENT LIST
# 找到對應的 Client IP

# 3. 確認原因
# 開發人員在除錯時執行了 KEYS 命令

// TTL 加上隨機偏移
public void setCache(String key, Object value) {
    Duration baseTtl = Duration.ofHours(1);
    long randomOffset = ThreadLocalRandom.current().nextLong(0, 600); // 0-10 分鐘
    redisTemplate.opsForValue().set(key, value, baseTtl.plusSeconds(randomOffset));
}

// 提前異步刷新
@Scheduled(fixedRate = 60000)
public void refreshHotCache() {
    // 刷新即將過期的熱點快取
}

redis-cli INFO memory
# mem_fragmentation_ratio:2.0  # 碎片率過高

# 方案 1：在低峰期重啟
sudo systemctl restart redis-server

# 方案 2：使用 MEMORY PURGE（Redis 4.0+）
redis-cli MEMORY PURGE

# 方案 3：調整記憶體分配器
# redis.conf
# jemalloc 通常比 libc 更好

redis-cli -h host -p 6379 -a password
AUTH password
SELECT db_number

# String
SET key value [EX seconds] [NX|XX]
GET key
MSET k1 v1 k2 v2
MGET k1 k2
INCR key
EXPIRE key seconds
TTL key

# Hash
HSET key field value
HGET key field
HMSET key f1 v1 f2 v2
HGETALL key
HDEL key field

# List
LPUSH key value
RPUSH key value
LPOP key
RPOP key
LRANGE key start stop
BLPOP key timeout

# Set
SADD key member
SREM key member
SMEMBERS key
SISMEMBER key member
SINTER key1 key2

# Sorted Set
ZADD key score member
ZRANGE key start stop [WITHSCORES]
ZREVRANGE key start stop [WITHSCORES]
ZSCORE key member
ZRANK key member
ZREM key member

INFO [section]
DBSIZE
KEYS pattern        # 慎用！
SCAN cursor [MATCH pattern] [COUNT count]
SLOWLOG GET [count]
CLIENT LIST
CONFIG GET parameter
CONFIG SET parameter value
BGSAVE
BGREWRITEAOF

CLUSTER INFO
CLUSTER NODES
CLUSTER SLOTS
CLUSTER KEYSLOT key
CLUSTER FAILOVER

SENTINEL masters
SENTINEL master mymaster
SENTINEL slaves mymaster
SENTINEL failover mymaster
SENTINEL get-master-addr-by-name mymaster