import org.redisson.api.RBloomFilter;import org.redisson.api.RedissonClient;import org.springframework.stereotype.Component;import javax.annotation.PostConstruct;import javax.annotation.Resource;
@Componentpublic class RedissonBloomFilter {
    /**     * Redisson 客户端（自动注入）     */    @Resource    private RedissonClient redissonClient;
    /**     * 示例：用户ID布隆过滤器（可定义多个不同业务的过滤器）     */    private RBloomFilter<String> userBloomFilter;
    /**     * 初始化布隆过滤器（PostConstruct 确保容器启动时初始化）     * 核心参数：     * - 预期元素数（expectedInsertions）：预估要添加的元素总量     * - 误判率（falseProbability）：允许的最大误判率（如 0.01 = 1%）     */    @PostConstruct    public void initBloomFilter() {        // 1. 获取布隆过滤器实例（指定唯一名称，区分不同业务）        userBloomFilter = redissonClient.getBloomFilter("bloom:filter:user:id");
        // 2. 初始化参数（仅首次调用有效，重复调用会抛出异常）        // 预期元素数：100万，误判率：1%        userBloomFilter.tryInit(1000000L, 0.01);    }
    /**     * 添加元素到布隆过滤器     * @param value 待添加的元素（如用户ID、订单号）     * @return true=添加成功，false=元素已存在（或过滤器初始化失败）     */    public boolean add(String value) {        if (value == null) {            return false;        }        return userBloomFilter.add(value);    }
    /**     * 判断元素是否存在于布隆过滤器     * @param value 待查询的元素     * @return true=可能存在（误判），false=一定不存在     */    public boolean contains(String value) {        if (value == null) {            return false;        }        return userBloomFilter.contains(value);    }
    /**     * 扩展：获取自定义布隆过滤器（适用于多业务场景）     * @param filterName 过滤器名称     * @param expectedInsertions 预期元素数     * @param falseProbability 误判率     * @return 布隆过滤器实例     */    public <T> RBloomFilter<T> getCustomBloomFilter(String filterName, long expectedInsertions, double falseProbability) {        RBloomFilter<T> bloomFilter = redissonClient.getBloomFilter(filterName);        bloomFilter.tryInit(expectedInsertions, falseProbability);        return bloomFilter;    }}

import org.junit.jupiter.api.Test;import org.redisson.api.RBloomFilter;import org.springframework.boot.test.context.SpringBootTest;import javax.annotation.Resource;import static org.junit.jupiter.api.Assertions.*;
@SpringBootTestpublic class RedissonBloomFilterTest {
    @Resource    private RedissonBloomFilter redissonBloomFilter;
    @Test    public void testDefaultBloomFilter() {        // 测试元素        String existUserId = "100001";        String notExistUserId = "999999";
        // 1. 添加元素        boolean addResult = redissonBloomFilter.add(existUserId);        assertTrue(addResult); // 首次添加返回true
        // 2. 重复添加同一元素        boolean addRepeatResult = redissonBloomFilter.add(existUserId);        assertFalse(addRepeatResult); // 重复添加返回false
        // 3. 验证存在的元素（返回true）        assertTrue(redissonBloomFilter.contains(existUserId));
        // 4. 验证不存在的元素（返回false）        assertFalse(redissonBloomFilter.contains(notExistUserId));    }
    @Test    public void testCustomBloomFilter() {        // 获取自定义布隆过滤器（订单号过滤，预期10万元素，误判率0.1%）        RBloomFilter<String> orderBloomFilter = redissonBloomFilter.getCustomBloomFilter(                "bloom:filter:order:no",                100000L,                0.001        );
        // 添加订单号        orderBloomFilter.add("ORDER_20251210_001");
        // 验证        assertTrue(orderBloomFilter.contains("ORDER_20251210_001"));        assertFalse(orderBloomFilter.contains("ORDER_20251210_999"));    }}

// 1. 获取信号量（初始容量为10）RSemaphore semaphore = redissonClient.getSemaphore("semaphore:limited:interface");semaphore.trySetPermits(10); // 初始化容量（仅首次有效）
try {    // 2. 尝试获取许可（等待3秒，超时则拒绝）    boolean acquired = semaphore.tryAcquire(3, TimeUnit.SECONDS);    if (!acquired) {        return "当前请求过多，请稍后再试";    }    // 3. 执行业务逻辑    return "接口访问成功";} catch (InterruptedException e) {    Thread.currentThread().interrupt();    return "请求失败";} finally {    // 4. 释放许可（归还信号量）    semaphore.release();}

import org.redisson.api.RCountDownLatch;import org.redisson.api.RedissonClient;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;import java.util.concurrent.TimeUnit;
/** * Redisson RCountDownLatch 分布式倒计时闭锁 Demo */@RestControllerpublic class RedissonCountDownLatchDemo {    @Resource    private RedissonClient redissonClient;
    // 定义闭锁的唯一标识（分布式场景下，所有服务实例使用同一个标识）    private static final String LATCH_KEY = "distributed:latch:task:demo";    // 需要等待的子任务数量    private static final int TASK_COUNT = 3;
    /**     * 步骤1：主任务接口 - 等待所有子任务完成     * 访问该接口后，请求会阻塞，直到3个子任务都执行 countDown()     */    @GetMapping("/task/main")    public String mainTask() {        // 1. 获取分布式闭锁实例        RCountDownLatch latch = redissonClient.getCountDownLatch(LATCH_KEY);
        try {            // 2. 初始化闭锁计数（仅首次调用有效，重复调用会忽略）            latch.trySetCount(TASK_COUNT);            System.out.println("主任务开始等待，剩余子任务数：" + latch.getCount());
            // 3. 阻塞等待：直到计数归零，或超时（这里设置超时时间为60秒）            boolean awaitSuccess = latch.await(60, TimeUnit.SECONDS);
            if (awaitSuccess) {                return "所有子任务完成，主任务执行成功！";            } else {                return "等待子任务超时，主任务执行失败！";            }        } catch (InterruptedException e) {            Thread.currentThread().interrupt();            return "主任务被中断，执行失败！";        }    }
    /**     * 步骤2：子任务接口 - 完成一个子任务，计数减1     * 可在不同服务实例中调用，每次调用计数减1     */    @GetMapping("/task/child")    public String childTask() {        RCountDownLatch latch = redissonClient.getCountDownLatch(LATCH_KEY);
        // 校验闭锁是否已初始化（避免未调用mainTask就执行childTask）        if (latch.getCount() == 0 && !latch.trySetCount(TASK_COUNT)) {            return "闭锁未初始化，请先调用主任务接口！";        }
        // 原子操作：计数减1        latch.countDown();        long remaining = latch.getCount();        System.out.println("一个子任务完成，剩余子任务数：" + remaining);
        return "子任务完成，剩余子任务数：" + remaining;    }
    /**     * 重置闭锁（可选）：重新设置计数，用于重复测试     */    @GetMapping("/task/reset")    public String resetLatch() {        RCountDownLatch latch = redissonClient.getCountDownLatch(LATCH_KEY);        latch.trySetCount(TASK_COUNT); // 重新设置计数（会覆盖原有计数）        return "闭锁已重置，计数恢复为：" + TASK_COUNT;    }}

GEOADD key longitude latitude member [longitude latitude member ...]

# 添加3个门店的经纬度到store:geo中127.0.0.1:6379> GEOADD store:geo 116.39748 39.90882 store_01 116.40748 39.90882 store_02 116.39748 39.91882 store_03(integer) 3  # 成功添加的成员数量

GEOSEARCH key   [FROMMEMBER member]  # 以已有成员为中心  [FROMLONLAT lon lat] # 以经纬度为中心  BYRADIUS radius m|km|mi|ft  # 按半径查询（二选一）  [BYBOX width height m|km|mi|ft]  # 按矩形范围查询（二选一，宽高为矩形的尺寸）  [ASC|DESC]  # 排序  [COUNT count]  # 限制数量  [WITHCOORD] [WITHDIST] [WITHHASH]  # 返回附加信息

# 1. 按经纬度为中心，1km半径查询127.0.0.1:6379> GEOSEARCH store:geo FROMLONLAT 116.39748 39.90882 BYRADIUS 1 km WITHDIST ASC1) 1) "store_01"   2) "0.0000"2) 1) "store_02"   2) "0.8439"
# 2. 按已有成员为中心，1km半径查询127.0.0.1:6379> GEOSEARCH store:geo FROMMEMBER store_01 BYRADIUS 1 km WITHDIST ASC1) 1) "store_01"   2) "0.0000"2) 1) "store_02"   2) "0.8439"
# 3. 按矩形范围查询（宽1km，高1km）127.0.0.1:6379> GEOSEARCH store:geo FROMLONLAT 116.39748 39.90882 BYBOX 1 1 km WITHDIST ASC

# 向uv:20251211（12月11日的UV）中添加3个用户ID127.0.0.1:6379> PFADD uv:20251211 user_1001 user_1002 user_1003(integer) 1
# 重复添加user_1001，无更新127.0.0.1:6379> PFADD uv:20251211 user_1001(integer) 0

# 统计12月11日的UV127.0.0.1:6379> PFCOUNT uv:20251211(integer) 3  # 对应之前添加的3个独立用户
# 再添加一个用户，重新统计127.0.0.1:6379> PFADD uv:20251211 user_1004(integer) 1127.0.0.1:6379> PFCOUNT uv:20251211(integer) 4