// Spring Cache示例
@Cacheable(value="products", key="#productId")
public Product getProduct(String productId) {
    return productDao.findById(productId); 
}

// SETNX實(shí)現(xiàn)
String lockKey = "order_lock_"+orderId;
String clientId = UUID.randomUUID().toString();
try {
    Boolean result = redisTemplate.opsForValue().setIfAbsent(lockKey, clientId, 30, TimeUnit.SECONDS);
    if(result) {
        // 執(zhí)行業(yè)務(wù)邏輯
    } else {
        // 獲取鎖失敗
    }
} finally {
    // 使用Lua腳本保證原子性
    String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
    redisTemplate.execute(new DefaultRedisScript<>(script, Long.class), 
                        Collections.singletonList(lockKey), clientId);
}

RLock lock = redissonClient.getLock("order_lock_"+orderId);
try {
    // 嘗試加鎖，最多等待100秒，上鎖后30秒自動(dòng)解鎖
    if(lock.tryLock(100, 30, TimeUnit.SECONDS)) {
        // 執(zhí)行業(yè)務(wù)邏輯
    }
} finally {
    lock.unlock();
}

// 文章閱讀量計(jì)數(shù)
redisTemplate.opsForValue().increment("article:read:count:"+articleId);
// 獲取閱讀量
Long count = redisTemplate.opsForValue().increment("article:read:count:"+articleId, 0);

public boolean isAllowed(String key, int maxCount, int period) {
    long now = System.currentTimeMillis();
    long windowStart = now - period * 1000;
    // 刪除舊時(shí)間戳
    redisTemplate.opsForZSet().removeRangeByScore(key, 0, windowStart);
    // 獲取當(dāng)前請(qǐng)求數(shù)
    long count = redisTemplate.opsForZSet().zCard(key);
    if(count < maxCount) {
        // 添加當(dāng)前請(qǐng)求
        redisTemplate.opsForZSet().add(key, String.valueOf(now), now);
        return true;
    }
    return false;
}

// 生產(chǎn)者
redisTemplate.opsForList().leftPush("queue:order", orderJson);
// 消費(fèi)者
String orderJson = redisTemplate.opsForList().rightPop("queue:order", 30, TimeUnit.SECONDS);

// 創(chuàng)建消費(fèi)者組
redisTemplate.opsForStream().createGroup("order_stream", "order_group");
// 生產(chǎn)者
Map<String, String> message = new HashMap<>();
message.put("orderId", "1001");
message.put("amount", "99.9");
redisTemplate.opsForStream().add("order_stream", message);
// 消費(fèi)者
List<MapRecord<String, String, String>> records = redisTemplate.opsForStream()
    .read(Consumer.from("order_group", "consumer1"),
        StreamReadOptions.empty().count(1).block(Duration.ofSeconds(1)),
        StreamOffset.create("order_stream", ReadOffset.lastConsumed()));

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

# application.properties
spring.session.store-type=redis
spring.session.timeout=1800 # 30分鐘

// 自動(dòng)將Session存儲(chǔ)到Redis
@RestController
@SessionAttributes("user")
public class UserController {
    @PostMapping("/login")
    public String login(@RequestParam String username, Model model) {
        model.addAttribute("user", username);
        return "login success";
    }
}

# 下載 Redis 源碼包
wget https://download.redis.io/releases/redis-6.2.6.tar.gz
# 驗(yàn)證下載完整性（可選）
wget https://download.redis.io/releases/redis-6.2.6.tar.gz.asc
gpg --verify redis-6.2.6.tar.gz.asc
# 解壓 Redis 源碼包
tar -zxvf redis-6.2.6.tar.gz
# 進(jìn)入解壓后的目錄
cd redis-6.2.6

# 安裝編譯依賴（CentOS/RHEL）
yum install -y gcc make tcl
# 或 Ubuntu/Debian
apt-get install -y build-essential tcl
# 編譯 Redis（此過程可能需要幾分鐘）
make
# 運(yùn)行測(cè)試（可選，但推薦）
make test
# 安裝 Redis 到系統(tǒng)目錄
make install

# 創(chuàng)建 Redis 配置目錄
mkdir -p /etc/redis
# 復(fù)制配置文件模板
cp redis.conf /etc/redis/redis.conf
# 創(chuàng)建數(shù)據(jù)存儲(chǔ)目錄
mkdir -p /var/lib/redis

# 使用 vim 或其他編輯器修改配置文件
vim /etc/redis/redis.conf

# 允許遠(yuǎn)程訪問（注釋掉或修改為）
# bind 127.0.0.1
bind 0.0.0.0

# 關(guān)閉保護(hù)模式
protected-mode no
# 設(shè)置密碼（生產(chǎn)環(huán)境必須）
requirepass your_strong_password

# 以守護(hù)進(jìn)程方式運(yùn)行
daemonize yes

# 指定日志文件路徑
logfile "/var/log/redis/redis-server.log"

# RDB 持久化配置
save 900 1
save 300 10
save 60 10000
# AOF 持久化配置（可選）
appendonly yes
appendfsync everysec

# 創(chuàng)建日志目錄
mkdir -p /var/log/redis
chown -R redis:redis /var/log/redis
# 啟動(dòng) Redis 服務(wù)
redis-server /etc/redis/redis.conf
# 驗(yàn)證服務(wù)狀態(tài)
ps aux | grep redis
netstat -tulnp | grep 6379

# 本地連接測(cè)試
redis-cli -h 127.0.0.1 -p 6379 -a your_password ping
# 遠(yuǎn)程連接測(cè)試（從其他服務(wù)器）
redis-cli -h your_server_ip -p 6379 -a your_password ping

# 創(chuàng)建 systemd 服務(wù)文件
vim /etc/systemd/system/redis.service

[Unit]
Description=Redis In-Memory Data Store
After=network.target
[Service]
User=redis
Group=redis
ExecStart=/usr/local/bin/redis-server /etc/redis/redis.conf
ExecStop=/usr/local/bin/redis-cli shutdown
Restart=always
[Install]
WantedBy=multi-user.target

# 重新加載 systemd
systemctl daemon-reload
# 啟用開機(jī)自啟
systemctl enable redis
# 啟動(dòng)服務(wù)
systemctl start redis
# 檢查狀態(tài)
systemctl status redis

<!-- Jedis 核心依賴 -->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>4.3.1</version>
</dependency>
<!-- 連接池依賴（必須） -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
    <version>2.11.1</version>
</dependency>
<!-- 可選：JSON 序列化支持 -->
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.9.0</version>
</dependency>

<!-- Redisson 核心依賴 -->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.17.6</version>
</dependency>
<!-- 可選：配置支持（如 JSON/YAML 配置文件） -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.13.3</version>
</dependency>

import redis.clients.jedis.Jedis;
public class RedisTest {
    public static void main(String[] args) {
        // 創(chuàng)建連接
        Jedis jedis = new Jedis("localhost", 6379);
        jedis.auth("your_password");  // 如果有密碼
        // 測(cè)試連接
        System.out.println("連接狀態(tài)：" + jedis.ping());
        // 基本操作
        jedis.set("test_key", "Hello Redis");
        System.out.println("獲取值：" + jedis.get("test_key"));
        // 關(guān)閉連接
        jedis.close();
    }
}

JedisPoolConfig poolConfig = new JedisPoolConfig();
poolConfig.setMaxTotal(128);       // 最大連接數(shù)
poolConfig.setMaxIdle(32);         // 最大空閑連接
poolConfig.setMinIdle(8);          // 最小空閑連接
poolConfig.setTestOnBorrow(true);  // 獲取連接時(shí)測(cè)試

import redis.clients.jedis.Jedis;
public class JedisBasicDemo {
    public static void main(String[] args) {
        // 1. 創(chuàng)建Jedis實(shí)例（參數(shù)說明：Redis地址、端口、連接超時(shí)時(shí)間(毫秒)、密碼）
        // 注意：如果Redis服務(wù)器在同一臺(tái)機(jī)器，地址可以是"localhost"
        Jedis jedis = new Jedis("192.168.1.100", 6379, 5000); 
        try {
            // 2. 驗(yàn)證密碼（若Redis未設(shè)置密碼，可跳過此步驟）
            // 如果密碼錯(cuò)誤，會(huì)拋出redis.clients.jedis.exceptions.JedisDataException
            jedis.auth("your_password");
            // 3. 測(cè)試連接
            // ping()返回"PONG"表示連接正常
            System.out.println("Redis連接狀態(tài)：" + jedis.ping()); // 期望輸出：PONG
            // 4. 操作String類型數(shù)據(jù)
            jedis.set("username", "zhangsan"); // 存入數(shù)據(jù)，默認(rèn)永不過期
            // 帶過期時(shí)間的設(shè)置（單位秒）
            jedis.setex("temp_token", 3600, "abcd1234"); 
            String username = jedis.get("username"); // 獲取數(shù)據(jù)
            System.out.println("獲取到的用戶名：" + username); // 輸出：zhangsan
            // 5. 操作Hash類型數(shù)據(jù)
            // 存儲(chǔ)用戶信息
            jedis.hset("user:1001", "name", "lisi");
            jedis.hset("user:1001", "age", "25");
            jedis.hset("user:1001", "gender", "male");
            // 獲取Hash中所有字段和值（返回Map<String,String>）
            System.out.println("用戶1001信息：" + jedis.hgetAll("user:1001"));
            // 輸出：{name=lisi, age=25, gender=male}
            // 獲取單個(gè)字段
            System.out.println("用戶年齡：" + jedis.hget("user:1001", "age")); // 輸出：25
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 6. 關(guān)閉連接（重要！避免連接泄漏）
            if (jedis != null) {
                jedis.close();
            }
        }
    }
}

import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
public class JedisPoolDemo {
    // 初始化Jedis連接池（使用靜態(tài)代碼塊確保只初始化一次）
    private static JedisPool jedisPool;
    static {
        // 1. 配置連接池參數(shù)
        GenericObjectPoolConfig<Jedis> poolConfig = new GenericObjectPoolConfig<>();
        // 關(guān)鍵參數(shù)配置（根據(jù)實(shí)際業(yè)務(wù)需求調(diào)整）
        poolConfig.setMaxTotal(100);       // 最大連接數(shù)（根據(jù)Redis服務(wù)器配置調(diào)整）
        poolConfig.setMaxIdle(20);         // 最大空閑連接數(shù)（建議設(shè)為MaxTotal的20%-50%）
        poolConfig.setMinIdle(5);          // 最小空閑連接數(shù)（保持一定數(shù)量的熱連接）
        poolConfig.setBlockWhenExhausted(true); // 連接耗盡時(shí)是否阻塞等待（建議true）
        poolConfig.setMaxWaitMillis(3000); // 獲取連接最大等待時(shí)間（毫秒）
        poolConfig.setTestOnBorrow(true);  // 獲取連接時(shí)是否測(cè)試有效性（建議true，但會(huì)有性能損耗）
        poolConfig.setTestOnReturn(false); // 歸還連接時(shí)是否測(cè)試（建議false）
        poolConfig.setTestWhileIdle(true); // 空閑時(shí)是否測(cè)試（建議true）
        // 2. 初始化連接池
        String redisHost = "192.168.1.100";
        int redisPort = 6379;
        int timeout = 5000; // 連接超時(shí)時(shí)間（毫秒）
        String password = "your_password";
        jedisPool = new JedisPool(
            poolConfig, 
            redisHost, 
            redisPort, 
            timeout, 
            password
        );
    }
    // 從連接池獲取Jedis實(shí)例
    public static Jedis getJedis() {
        return jedisPool.getResource();
    }
    // 測(cè)試連接池使用
    public static void main(String[] args) {
        // 使用try-with-resources語法自動(dòng)管理連接
        try (Jedis jedis = getJedis()) {
            // 1. 操作String類型
            jedis.set("product:1001", "iPhone 13");
            System.out.println("商品1001名稱：" + jedis.get("product:1001"));
            // 2. 操作List類型（模擬消息隊(duì)列）
            jedis.lpush("message:queue", "msg1", "msg2", "msg3"); // 左推（入隊(duì)）
            // 右拉（出隊(duì)），0表示無限期阻塞等待
            String msg = jedis.brpop(0, "message:queue").get(1); 
            System.out.println("消費(fèi)的消息：" + msg);
            // 3. 批量操作（使用pipeline提升性能）
            long start = System.currentTimeMillis();
            for (int i = 0; i < 1000; i++) {
                jedis.set("key_" + i, "value_" + i);
            }
            long end = System.currentTimeMillis();
            System.out.println("普通操作耗時(shí)：" + (end - start) + "ms");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

// 典型生產(chǎn)環(huán)境配置
poolConfig.setMaxTotal(200);       // 根據(jù)QPS估算，一般(平均QPS*平均耗時(shí)(ms))/1000
poolConfig.setMaxIdle(50);         // 根據(jù)業(yè)務(wù)波動(dòng)情況調(diào)整
poolConfig.setMinIdle(10);         // 保持一定熱連接
poolConfig.setMaxWaitMillis(1000); // 根據(jù)系統(tǒng)容忍度設(shè)置
poolConfig.setTestOnBorrow(true);  // 確保獲取的連接可用
poolConfig.setTimeBetweenEvictionRunsMillis(30000); // 30秒檢測(cè)一次

try (Jedis jedis = JedisPoolDemo.getJedis()) {
    // 1. 添加元素（自動(dòng)去重）
    jedis.sadd("tags:java", "spring", "mybatis", "redis");
    jedis.sadd("tags:java", "spring"); // 重復(fù)元素不會(huì)被添加
    // 2. 獲取所有元素（無序）
    System.out.println("Java相關(guān)標(biāo)簽：" + jedis.smembers("tags:java")); 
    // 輸出可能是：[redis, spring, mybatis]
    // 3. 判斷元素是否存在
    System.out.println("是否包含spring：" + jedis.sismember("tags:java", "spring")); 
    // 輸出：true
    // 4. 移除元素
    jedis.srem("tags:java", "mybatis");
    // 5. 計(jì)算集合大小
    System.out.println("標(biāo)簽數(shù)量：" + jedis.scard("tags:java")); // 輸出：2
    // 6. 集合運(yùn)算
    jedis.sadd("tags:backend", "spring", "django", "redis");
    // 交集
    System.out.println("交集：" + jedis.sinter("tags:java", "tags:backend"));
    // 輸出：[spring, redis]
    // 并集
    System.out.println("并集：" + jedis.sunion("tags:java", "tags:backend"));
    // 輸出：[spring, redis, django]
    // 差集（tags:java有而tags:backend沒有的）
    System.out.println("差集：" + jedis.sdiff("tags:java", "tags:backend"));
    // 輸出：[]
}

try (Jedis jedis = JedisPoolDemo.getJedis()) {
    // 1. 添加元素（如果成員已存在，則更新分?jǐn)?shù)）
    jedis.zadd("rank:java", 95, "zhangsan");
    jedis.zadd("rank:java", 88, "lisi");
    jedis.zadd("rank:java", 92, "wangwu");
    jedis.zadd("rank:java", 90, "lisi"); // 更新lisi的分?jǐn)?shù)
    // 2. 按分?jǐn)?shù)升序獲?。?到-1表示全部）
    System.out.println("升序排名：" + jedis.zrange("rank:java", 0, -1));
    // 輸出：[lisi, wangwu, zhangsan]
    // 3. 按分?jǐn)?shù)降序獲?。◣Х?jǐn)?shù)）
    Set<Tuple> results = jedis.zrevrangeWithScores("rank:java", 0, -1);
    results.forEach(tuple -> 
        System.out.println(tuple.getElement() + ":" + tuple.getScore())
    );
    // 輸出：
    // zhangsan:95.0
    // wangwu:92.0
    // lisi:90.0
    // 4. 獲取分?jǐn)?shù)
    System.out.println("lisi的分?jǐn)?shù)：" + jedis.zscore("rank:java", "lisi"));
    // 輸出：90.0
    // 5. 獲取排名（從0開始）
    System.out.println("zhangsan的降序排名：" + jedis.zrevrank("rank:java", "zhangsan"));
    // 輸出：0
    // 6. 范圍查詢（80<=score<=90）
    System.out.println("80-90分的學(xué)生：" + 
        jedis.zrangeByScoreWithScores("rank:java", 80, 90));
    // 輸出：[lisi:90.0, wangwu:92.0]（注意包含邊界）
    // 7. 原子操作：增加分?jǐn)?shù)
    jedis.zincrby("rank:java", 5, "lisi"); // lisi分?jǐn)?shù)+5
    System.out.println("新分?jǐn)?shù)：" + jedis.zscore("rank:java", "lisi"));
    // 輸出：95.0
}

// Geo地理位置操作
try (Jedis jedis = JedisPoolDemo.getJedis()) {
    // 添加地理位置（經(jīng)度、緯度、名稱）
    jedis.geoadd("cities", 116.404, 39.915, "beijing");
    jedis.geoadd("cities", 121.474, 31.230, "shanghai");
    // 計(jì)算兩地距離（單位：km）
    Double dist = jedis.geodist("cities", "beijing", "shanghai", GeoUnit.KM);
    System.out.println("北京到上海距離：" + dist + "km");
    // 查找附近位置
    List<GeoRadiusResponse> nearby = jedis.georadiusByMember(
        "cities", 
        "beijing", 
        1000, 
        GeoUnit.KM
    );
    nearby.forEach(r -> System.out.println(r.getMemberByString()));
}
// HyperLogLog基數(shù)統(tǒng)計(jì)
try (Jedis jedis = JedisPoolDemo.getJedis()) {
    // 添加元素（用于統(tǒng)計(jì)不重復(fù)元素?cái)?shù)量）
    for (int i = 0; i < 10000; i++) {
        jedis.pfadd("visitors", "user_" + i);
        jedis.pfadd("visitors", "user_" + (i % 5000)); // 50%重復(fù)
    }
    // 獲取基數(shù)估計(jì)值
    System.out.println("獨(dú)立訪客數(shù)：" + jedis.pfcount("visitors"));
    // 輸出約7500（誤差率約0.81%）
}

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
/**
 * Redisson客戶端工廠類（推薦單例模式）
 * 典型應(yīng)用場(chǎng)景：Spring Bean管理、靜態(tài)工具類等
 */
public class RedissonClientFactory {
    // 使用volatile保證多線程可見性
    private static volatile RedissonClient redissonClient;
    // 雙重檢查鎖實(shí)現(xiàn)線程安全初始化
    public static RedissonClient getRedissonClient() {
        if (redissonClient == null) {
            synchronized (RedissonClientFactory.class) {
                if (redissonClient == null) {
                    // 1. 創(chuàng)建配置構(gòu)建器
                    Config config = new Config();
                    // 2. 配置單點(diǎn)模式（生產(chǎn)環(huán)境建議使用YAML/JSON配置文件）
                    config.useSingleServer()
                          .setAddress("redis://192.168.1.100:6379") // 支持rediss://協(xié)議（SSL加密）
                          .setPassword("your_password")             // 密碼特殊字符需URL編碼
                          .setDatabase(0)                           // 默認(rèn)DB索引
                          .setConnectionPoolSize(100)               // 最大連接數(shù)（默認(rèn)64）
                          .setConnectionMinimumIdleSize(10)         // 最小空閑連接（默認(rèn)10）
                          .setConnectTimeout(5000)                  // 連接超時(shí)（毫秒）
                          .setIdleConnectionTimeout(30000)          // 空閑連接超時(shí)
                          .setRetryAttempts(3)                      // 命令重試次數(shù)
                          .setRetryInterval(1000);                  // 重試間隔
                    // 3. 創(chuàng)建客戶端實(shí)例（實(shí)際會(huì)啟動(dòng)連接池和定時(shí)任務(wù)）
                    redissonClient = Redisson.create(config);
                }
            }
        }
        return redissonClient;
    }
    // 優(yōu)雅關(guān)閉方法
    public static void shutdown() {
        if (redissonClient != null) {
            redissonClient.shutdown();
        }
    }
}

config.useSentinelServers()
      .addSentinelAddress("redis://sentinel1:26379")
      .addSentinelAddress("redis://sentinel2:26379")
      .setMasterName("mymaster");

config.useClusterServers()
      .addNodeAddress("redis://node1:6379")
      .addNodeAddress("redis://node2:6379")
      .setScanInterval(2000); // 集群狀態(tài)掃描間隔

import org.redisson.api.RBucket;
import org.redisson.api.RedissonClient;
public class RedissonStringDemo {
    public static void main(String[] args) {
        // 獲取 RedissonClient 實(shí)例
        RedissonClient redissonClient = RedissonClientFactory.getRedissonClient();
        try {
            // 獲取 RBucket 對(duì)象（對(duì)應(yīng) Redis 的 String 類型）
            RBucket<String> usernameBucket = redissonClient.getBucket("username");
            // 存入數(shù)據(jù)，并設(shè)置過期時(shí)間為 3600 秒（1小時(shí)）
            usernameBucket.set("zhangsan", 3600);
            // 獲取數(shù)據(jù)
            String username = usernameBucket.get();
            System.out.println("用戶名：" + username); // 輸出：zhangsan
            // 判斷 key 是否存在
            System.out.println("是否存在：" + usernameBucket.isExists()); // 輸出：true
            // 刪除數(shù)據(jù)
            usernameBucket.delete();
            System.out.println("刪除后是否存在：" + usernameBucket.isExists()); // 輸出：false
        } finally {
            // 關(guān)閉客戶端（若為長(zhǎng)期運(yùn)行的服務(wù)，無需頻繁關(guān)閉）
            redissonClient.shutdown();
        }
    }
}

import org.redisson.api.RMap;
import org.redisson.api.RedissonClient;
public class RedissonHashDemo {
    public static void main(String[] args) {
        RedissonClient redissonClient = RedissonClientFactory.getRedissonClient();
        try {
            // 獲取 RMap 對(duì)象（對(duì)應(yīng) Redis 的 Hash 類型）
            RMap<String, String> userMap = redissonClient.getMap("user:1001");
            // 存入數(shù)據(jù)
            userMap.put("name", "lisi");
            userMap.put("age", "25");
            userMap.put("gender", "male");
            // 獲取數(shù)據(jù)
            System.out.println("用戶姓名：" + userMap.get("name")); // 輸出：lisi
            System.out.println("用戶所有信息：" + userMap); // 輸出：{name=lisi, age=25, gender=male}
            // 刪除字段
            userMap.remove("gender");
            System.out.println("刪除 gender 后的信息：" + userMap); // 輸出：{name=lisi, age=25}
            // 判斷字段是否存在
            System.out.println("是否包含 age：" + userMap.containsKey("age")); // 輸出：true
        } finally {
            // 關(guān)閉客戶端
            redissonClient.shutdown();
        }
    }
}

import org.redisson.api.RList;
import org.redisson.api.RedissonClient;
public class RedissonListDemo {
    public static void main(String[] args) {
        RedissonClient redissonClient = RedissonClientFactory.getRedissonClient();
        try {
            // 獲取 RList 對(duì)象（對(duì)應(yīng) Redis 的 List 類型）
            RList<String> messageList = redissonClient.getList("message:queue");
            // 添加元素（右添加，等同于 RPUSH）
            messageList.add("msg1");
            // 左添加（等同于 LPUSH）
            messageList.add(0, "msg0");
            // 獲取指定索引元素
            System.out.println("索引 0 的元素：" + messageList.get(0)); // 輸出：msg0
            // 獲取所有元素
            System.out.println("所有消息：" + messageList); // 輸出：[msg0, msg1]
            // 移除并返回最后一個(gè)元素（等同于 RPOP）
            String lastMsg = messageList.remove(messageList.size() - 1);
            System.out.println("移除的最后一條消息：" + lastMsg); // 輸出：msg1
            // 獲取列表長(zhǎng)度
            System.out.println("列表長(zhǎng)度：" + messageList.size()); // 輸出：1
        } finally {
            redissonClient.shutdown();
        }
    }
}

import org.redisson.api.RSet;
import org.redisson.api.RedissonClient;
public class RedissonSetDemo {
    public static void main(String[] args) {
        RedissonClient redissonClient = RedissonClientFactory.getRedissonClient();
        try {
            // 獲取 RSet 對(duì)象（對(duì)應(yīng) Redis 的 Set 類型）
            RSet<String> tagSet = redissonClient.getSet("tags:java");
            // 添加元素
            tagSet.add("spring");
            tagSet.add("mybatis");
            tagSet.add("redis");
            // 判斷元素是否存在
            System.out.println("是否包含 spring：" + tagSet.contains("spring")); // 輸出：true
            // 獲取所有元素
            System.out.println("Java 標(biāo)簽集合：" + tagSet); // 輸出：[spring, mybatis, redis]
            // 創(chuàng)建另一個(gè) Set
            RSet<String> backendTagSet = redissonClient.getSet("tags:backend");
            backendTagSet.add("spring");
            backendTagSet.add("django");
            backendTagSet.add("redis");
            // 計(jì)算并返回交集
            System.out.println("Java 與 Backend 標(biāo)簽交集：" + tagSet.retainAll(backendTagSet));
            // 輸出：[spring, redis]（retainAll 方法會(huì)保留交集元素并返回）
            // 獲取集合大小
            System.out.println("交集大?。? + tagSet.size()); // 輸出：2
        } finally {
            redissonClient.shutdown();
        }
    }
}

import org.redisson.api.RSortedSet;
import org.redisson.api.RedissonClient;
import org.redisson.api.ScoredEntry;
import java.util.Collection;
public class RedissonSortedSetDemo {
    public static void main(String[] args) {
        RedissonClient redissonClient = RedissonClientFactory.getRedissonClient();
        try {
            // 獲取 RSortedSet 對(duì)象（對(duì)應(yīng) Redis 的 Sorted Set 類型）
            RSortedSet<String> rankSet = redissonClient.getSortedSet("rank:java");
            // 添加元素（指定分?jǐn)?shù)）
            rankSet.add(95, "zhangsan");
            rankSet.add(88, "lisi");
            rankSet.add(92, "wangwu");
            // 按分?jǐn)?shù)升序獲取元素
            System.out.println("成績(jī)升序排名：" + rankSet); // 輸出：[lisi, wangwu, zhangsan]
            // 按分?jǐn)?shù)降序獲取元素（含分?jǐn)?shù)）
            Collection<ScoredEntry<String>> scoredEntries = rankSet.entryRangeReversed(0, -1);
            for (ScoredEntry<String> entry : scoredEntries) {
                System.out.println(entry.getValue() + "：" + entry.getScore());
                // 輸出：
                // zhangsan：95.0
                // wangwu：92.0
                // lisi：88.0
            }
            // 獲取指定元素的排名（降序）
            System.out.println("zhangsan 的排名：" + rankSet.revRank("zhangsan")); // 輸出：0
            // 獲取分?jǐn)?shù)范圍內(nèi)的元素
            Collection<String> range = rankSet.valueRange(90, true, 95, true);
            System.out.println("分?jǐn)?shù)在 90~95 之間的學(xué)生：" + range); // 輸出：[wangwu, zhangsan]
        } finally {
            redissonClient.shutdown();
        }
    }
}

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import java.util.concurrent.TimeUnit;
public class RedissonDistributedLockDemo {
    // 鎖的key命名規(guī)范：業(yè)務(wù)類型:業(yè)務(wù)ID（如訂單創(chuàng)建鎖）
    private static final String LOCK_KEY = "lock:order:create"; 
    public static void createOrder(RedissonClient redissonClient) {
        // 1. 獲取分布式鎖實(shí)例（非阻塞）
        RLock lock = redissonClient.getLock(LOCK_KEY);
        try {
            // 2. 嘗試獲取鎖（參數(shù)說明）
            // - waitTime: 獲取鎖的最大等待時(shí)間（建議設(shè)置短于業(yè)務(wù)超時(shí)時(shí)間）
            // - leaseTime: 鎖自動(dòng)釋放時(shí)間（業(yè)務(wù)完成前應(yīng)足夠長(zhǎng)）
            // - TimeUnit: 時(shí)間單位
            boolean isLocked = lock.tryLock(3, 30, TimeUnit.SECONDS);
            if (isLocked) {
                try {
                    // 3. 加鎖成功，執(zhí)行業(yè)務(wù)邏輯
                    System.out.println(Thread.currentThread().getName() + "獲取分布式鎖成功，開始創(chuàng)建訂單...");
                    // 模擬業(yè)務(wù)處理耗時(shí)（如數(shù)據(jù)庫操作、遠(yuǎn)程調(diào)用等）
                    Thread.sleep(5000);
                    System.out.println("訂單創(chuàng)建完成！");
                } finally {
                    // 4. 確保業(yè)務(wù)完成后再釋放鎖
                    if (lock.isHeldByCurrentThread()) {
                        lock.unlock();
                        System.out.println("分布式鎖已釋放！");
                    }
                }
            } else {
                // 5. 獲取鎖失敗處理（可記錄日志、返回友好提示或重試）
                System.out.println("獲取分布式鎖失敗，請(qǐng)稍后再試！");
                // 可拋出特定異?；蚍祷劐e(cuò)誤碼
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.err.println("線程被中斷：" + e.getMessage());
        } catch (Exception e) {
            System.err.println("業(yè)務(wù)處理異常：" + e.getMessage());
        }
    }
    public static void main(String[] args) {
        RedissonClient redissonClient = RedissonClientFactory.getRedissonClient();
        // 模擬3個(gè)并發(fā)線程嘗試獲取鎖
        for (int i = 0; i < 3; i++) {
            new Thread(() -> createOrder(redissonClient), "Thread-"+i).start();
        }
        // 注意：實(shí)際應(yīng)用中RedissonClient應(yīng)該是單例長(zhǎng)期存在
        // redissonClient.shutdown();
    }
}

import org.redisson.api.RBlockingQueue;
import org.redisson.api.RDelayedQueue;
import org.redisson.api.RedissonClient;
import java.util.concurrent.TimeUnit;
public class RedissonDelayedQueueDemo {
    // 延遲隊(duì)列命名規(guī)范：業(yè)務(wù)類型:業(yè)務(wù)目的
    private static final String DELAY_QUEUE_KEY = "delay:queue:order"; 
    private static final String BLOCKING_QUEUE_KEY = "blocking:queue:order";
    /**
     * 生產(chǎn)者：添加延遲消息
     * @param redissonClient Redisson客戶端
     * @param message 消息內(nèi)容（建議包含業(yè)務(wù)ID）
     * @param delayTime 延遲時(shí)間（單位：秒）
     */
    public static void produceDelayMessage(RedissonClient redissonClient, String message, long delayTime) {
        // 1. 獲取阻塞隊(duì)列（底層實(shí)際存儲(chǔ)結(jié)構(gòu)）
        RBlockingQueue<String> blockingQueue = redissonClient.getBlockingQueue(BLOCKING_QUEUE_KEY);
        // 2. 創(chuàng)建延遲隊(duì)列（與阻塞隊(duì)列關(guān)聯(lián)）
        try (RDelayedQueue<String> delayedQueue = redissonClient.getDelayedQueue(blockingQueue)) {
            // 3. 添加延遲消息
            delayedQueue.offer(message, delayTime, TimeUnit.SECONDS);
            System.out.println("[" + System.currentTimeMillis() + "] 添加延遲消息：" + message 
                + "，延遲時(shí)間：" + delayTime + "秒");
        } // 自動(dòng)關(guān)閉延遲隊(duì)列（Java 7+ try-with-resources）
    }
    /**
     * 消費(fèi)者：持續(xù)消費(fèi)延遲消息
     * @param redissonClient Redisson客戶端
     */
    public static void consumeDelayMessage(RedissonClient redissonClient) {
        // 1. 獲取阻塞隊(duì)列（與生產(chǎn)者使用的相同）
        RBlockingQueue<String> blockingQueue = redissonClient.getBlockingQueue(BLOCKING_QUEUE_KEY);
        System.out.println("消費(fèi)者啟動(dòng)，等待消費(fèi)延遲消息...");
        while (!Thread.currentThread().isInterrupted()) {
            try {
                // 2. 阻塞獲取消息（當(dāng)有消息到期時(shí)自動(dòng)喚醒）
                String message = blockingQueue.take();
                // 3. 處理消息
                long currentTime = System.currentTimeMillis();
                System.out.println("[" + currentTime + "] 消費(fèi)延遲消息：" + message);
                // 根據(jù)消息內(nèi)容處理業(yè)務(wù)
                if (message != null && message.startsWith("order:")) {
                    String[] parts = message.split(":");
                    if (parts.length >= 2) {
                        String orderId = parts[1];
                        System.out.println("處理訂單超時(shí)：訂單" + orderId + "超時(shí)未支付，已自動(dòng)取消！");
                        // 實(shí)際業(yè)務(wù)中此處會(huì)調(diào)用訂單服務(wù)取消訂單
                    }
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.err.println("消費(fèi)者線程被中斷");
                break;
            } catch (Exception e) {
                System.err.println("消費(fèi)消息異常：" + e.getMessage());
                // 可添加重試或錯(cuò)誤處理邏輯
            }
        }
    }
    public static void main(String[] args) {
        RedissonClient redissonClient = RedissonClientFactory.getRedissonClient();
        // 啟動(dòng)消費(fèi)者線程（實(shí)際應(yīng)用中通常是獨(dú)立服務(wù)）
        Thread consumerThread = new Thread(() -> consumeDelayMessage(redissonClient));
        consumerThread.setDaemon(true);
        consumerThread.start();
        // 模擬生產(chǎn)3個(gè)訂單延遲消息
        produceDelayMessage(redissonClient, "order:10001", 5);  // 5秒后超時(shí)
        produceDelayMessage(redissonClient, "order:10002", 10); // 10秒后超時(shí)
        produceDelayMessage(redissonClient, "order:10003", 15); // 15秒后超時(shí)
        // 保持主線程運(yùn)行（演示用）
        try {
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        // 實(shí)際應(yīng)用中不需要關(guān)閉（長(zhǎng)期運(yùn)行的服務(wù)）
        // redissonClient.shutdown();
    }
}

<!-- Spring Boot Redis Starter -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <!-- 排除默認(rèn)的Lettuce客戶端（若需使用Jedis，可添加此配置） -->
    <!-- <exclusions>
        <exclusion>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
        </exclusion>
    </exclusions> -->
</dependency>
<!-- 若排除Lettuce后，需添加Jedis依賴 -->
<!-- <dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency> -->
<!-- Spring Boot Web Starter（用于演示接口） -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

spring:
  redis:
    host: 192.168.1.100 # Redis服務(wù)地址，生產(chǎn)環(huán)境建議使用域名或內(nèi)網(wǎng)IP
    port: 6379 # Redis端口，默認(rèn)6379
    password: your_password # Redis密碼（若未設(shè)，可省略）
    database: 0 # Redis數(shù)據(jù)庫索引（0-15），默認(rèn)0
    timeout: 5000ms # 連接超時(shí)時(shí)間
    lettuce: # Lettuce客戶端配置（若使用Jedis，需改為jedis配置）
      pool: # 連接池配置
        max-active: 100 # 最大連接數(shù)，默認(rèn)8
        max-idle: 20 # 最大空閑連接數(shù)，默認(rèn)8
        min-idle: 5 # 最小空閑連接數(shù)，默認(rèn)0
        max-wait: 3000ms # 連接池耗盡時(shí)的最大等待時(shí)間，默認(rèn)-1（無限等待）

spring:
  redis:
    host: 192.168.1.100
    port: 6379
    jedis:
      pool:
        max-active: 100
        max-idle: 20
        min-idle: 5
        max-wait: 3000ms

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        // 設(shè)置連接工廠（必需）
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        // Key序列化配置（String類型）
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringRedisSerializer);
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        // Value序列化配置（JSON格式）
        GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = 
            new GenericJackson2JsonRedisSerializer();
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        // 初始化模板（必需）
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.*;
import java.util.Map;
import java.util.concurrent.TimeUnit;
@RestController
@RequestMapping("/redis/string")
public class StringRedisController {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    // 存儲(chǔ)String數(shù)據(jù)（帶過期時(shí)間）
    @PostMapping("/set")
    public String setString(@RequestParam String key,
                           @RequestParam String value,
                           @RequestParam(required = false, defaultValue = "3600") long timeout) {
        stringRedisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
        return "存儲(chǔ)成功！Key：" + key + "，Value：" + value;
    }
    // 獲取String數(shù)據(jù)
    @GetMapping("/get/{key}")
    public String getString(@PathVariable String key) {
        String value = stringRedisTemplate.opsForValue().get(key);
        return "獲取到的數(shù)據(jù)：Key：" + key + "，Value：" + (value == null ? "無" : value);
    }
    // 存儲(chǔ)Hash數(shù)據(jù)
    @PostMapping("/hash/set")
    public String setHash(@RequestParam String key,
                        @RequestParam Map<String, String> hashMap) {
        stringRedisTemplate.opsForHash().putAll(key, hashMap);
        return "Hash數(shù)據(jù)存儲(chǔ)成功！Key：" + key;
    }
    // 獲取Hash數(shù)據(jù)
    @GetMapping("/hash/get/{key}")
    public Map<Object, Object> getHash(@PathVariable String key) {
        return stringRedisTemplate.opsForHash().entries(key);
    }
    // 設(shè)置過期時(shí)間
    @PostMapping("/expire")
    public Boolean expireKey(@RequestParam String key, 
                          @RequestParam long timeout) {
        return stringRedisTemplate.expire(key, timeout, TimeUnit.SECONDS);
    }
}

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private Long id;
    private String name;
    private Integer age;
    private String gender;
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.*;
import java.util.concurrent.TimeUnit;
@RestController
@RequestMapping("/redis/object")
public class ObjectRedisController {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    // 存儲(chǔ)User對(duì)象
    @PostMapping("/user/set")
    public String setUser(@RequestBody User user,
                        @RequestParam(required = false, defaultValue = "86400") long timeout) {
        String key = "user:" + user.getId();
        redisTemplate.opsForValue().set(key, user, timeout, TimeUnit.SECONDS);
        return "User對(duì)象存儲(chǔ)成功！Key：" + key + "，User：" + user;
    }
    // 獲取User對(duì)象
    @GetMapping("/user/get")
    public User getUser(@RequestParam Long userId) {
        String key = "user:" + userId;
        return (User) redisTemplate.opsForValue().get(key);
    }
    // 刪除User對(duì)象
    @PostMapping("/user/delete")
    public String deleteUser(@RequestParam Long userId) {
        String key = "user:" + userId;
        Boolean isDeleted = redisTemplate.delete(key);
        return isDeleted ? "User對(duì)象刪除成功！Key：" + key : "刪除失敗，Key不存在";
    }
}

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
@SpringBootApplication
@EnableCaching // 開啟緩存注解支持，自動(dòng)配置CacheManager
public class RedisSpringBootApplication {
    public static void main(String[] args) {
        SpringApplication.run(RedisSpringBootApplication.class, args);
    }
}

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
@Service
public class UserService {
    /**
     * 根據(jù)用戶ID查詢用戶信息
     * @param userId 用戶ID
     * @return 用戶對(duì)象
     * 
     * 緩存配置說明：
     * - value="userCache": 指定緩存名稱（相當(dāng)于Redis中的key前綴）
     * - key="#userId": 動(dòng)態(tài)生成緩存key（使用SpEL表達(dá)式獲取方法參數(shù)）
     * - unless="#result == null": 當(dāng)方法返回null時(shí)不緩存結(jié)果
     */
    @Cacheable(value = "userCache", key = "#userId", unless = "#result == null")
    public User getUserById(Long userId) {
        // 模擬從數(shù)據(jù)庫查詢數(shù)據(jù)（實(shí)際開發(fā)中替換為DAO層調(diào)用）
        System.out.println("從數(shù)據(jù)庫查詢用戶，userId：" + userId);
        return new User(userId, "張三", 25, "男");
    }
}

import org.springframework.cache.annotation.CachePut;
import org.springframework.stereotype.Service;
@Service
public class UserService {
    /**
     * 保存或更新用戶信息
     * @param user 用戶對(duì)象
     * @return 更新后的用戶對(duì)象
     * 
     * 緩存配置說明：
     * - value="userCache": 緩存名稱
     * - key="#user.id": 使用用戶ID作為緩存key
     * - unless="#result == null": 更新失敗不緩存
     */
    @CachePut(value = "userCache", key = "#user.id", unless = "#result == null")
    public User saveOrUpdateUser(User user) {
        // 模擬數(shù)據(jù)庫新增/更新操作
        System.out.println("數(shù)據(jù)庫新增/更新用戶，user：" + user);
        return user; // 將更新后的用戶對(duì)象存入緩存
    }
}

import org.springframework.cache.annotation.CacheEvict;
import org.springframework.stereotype.Service;
@Service
public class UserService {
    /**
     * 刪除用戶
     * @param userId 用戶ID
     * 
     * 緩存配置說明：
     * - value="userCache": 緩存名稱
     * - key="#userId": 指定要?jiǎng)h除的緩存key
     * - allEntries=false: 默認(rèn)只刪除指定key的緩存
     */
    @CacheEvict(value = "userCache", key = "#userId", allEntries = false)
    public void deleteUser(Long userId) {
        // 模擬數(shù)據(jù)庫刪除操作
        System.out.println("數(shù)據(jù)庫刪除用戶，userId：" + userId);
    }
    /**
     * 清空用戶緩存
     * 
     * 緩存配置說明：
     * - value="userCache": 緩存名稱
     * - allEntries=true: 刪除該緩存名稱下的所有緩存
     */
    @CacheEvict(value = "userCache", allEntries = true)
    public void clearUserCache() {
        System.out.println("清空用戶緩存");
    }
}

import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Caching;
import org.springframework.stereotype.Service;
@Service
public class UserService {
    /**
     * 更新用戶信息并清空用戶列表緩存
     * @param user 用戶對(duì)象
     * @return 更新后的用戶對(duì)象
     */
    @Caching(
        put = {
            // 更新用戶緩存
            @CachePut(value = "userCache", key = "#user.id")
        },
        evict = {
            // 刪除用戶列表緩存（假設(shè)存在用戶列表緩存）
            @CacheEvict(value = "userListCache", allEntries = true)
        }
    )
    public User updateUserAndClearListCache(User user) {
        // 模擬數(shù)據(jù)庫更新操作
        System.out.println("更新用戶并清空用戶列表緩存，user：" + user);
        return user;
    }
}

# 900秒(15分鐘)內(nèi)至少1個(gè)key變化，觸發(fā)RDB
save 900 1
# 300秒(5分鐘)內(nèi)至少10個(gè)key變化，觸發(fā)RDB
save 300 10
# 60秒內(nèi)至少10000個(gè)key變化，觸發(fā)RDB
save 60 10000
# RDB文件名稱
dbfilename dump.rdb
# 工作目錄(保存RDB文件和AOF文件的目錄)
dir /var/lib/redis

# 開啟AOF（默認(rèn)關(guān)閉，需手動(dòng)設(shè)置為yes）
appendonly yes
# AOF文件名稱
appendfilename "appendonly.aof"
# AOF刷盤策略（關(guān)鍵配置）
# everysec：每秒刷盤一次（推薦，平衡性能和數(shù)據(jù)安全性）
# always：每執(zhí)行一條命令刷盤一次（數(shù)據(jù)零丟失，性能較差）
# no：由操作系統(tǒng)決定刷盤時(shí)機(jī)（性能最好，數(shù)據(jù)丟失風(fēng)險(xiǎn)最高）
appendfsync everysec
# AOF重寫觸發(fā)條件
# 當(dāng)前AOF文件大小比起最后一次重寫時(shí)的大小增長(zhǎng)率達(dá)到100%時(shí)觸發(fā)
auto-aof-rewrite-percentage 100
# AOF文件最小重寫大小，避免文件很小就重寫
auto-aof-rewrite-min-size 64mb
# 加載AOF時(shí)發(fā)現(xiàn)文件末尾不完整時(shí)的處理方式
aof-load-truncated yes

# 內(nèi)存淘汰策略（當(dāng)內(nèi)存達(dá)到maxmemory時(shí)）
maxmemory-policy allkeys-lru
# 設(shè)置最大內(nèi)存（例如4GB）
maxmemory 4gb
# 避免內(nèi)存碎片
activedefrag yes

# 提高TCP連接隊(duì)列大小
tcp-backlog 511
# 客戶端空閑超時(shí)時(shí)間
timeout 0 # 0表示不超時(shí)
# 最大客戶端連接數(shù)
maxclients 10000

# 禁用持久化（僅用于純緩存場(chǎng)景）
save ""
appendonly no
# 如果使用RDB，適當(dāng)調(diào)整save參數(shù)
save 3600 1  # 1小時(shí)內(nèi)至少有1個(gè)變化則保存