Redis的五种数据结构及常用的场景

//String
/**
 * redis String类型 批量设置缓存
 */
@Test
public void redisMultiSetTest() {
    Map<String, String> map = new HashMap<>();
    map.put("user:1:peter", "peter liu");
    map.put("user:2:peter_1", "peter liu 1");
    redisTemplate.opsForValue().multiSet(map);
}

/**
 * redis String类型 批量获取
 */
@Test
public void redisMultiGetTest() {
    List<String> list = new ArrayList<>();
    list.add("user:1:peter");
    List<String> result = redisTemplate.opsForValue().multiGet(list);
    System.out.println(result);
}

/**
 * redis String类型 setnx
 */
@Test
public void testSetNx() {
    Boolean absent = redisTemplate.opsForValue().setIfAbsent("key1", "value2");
    System.out.println(absent);
}

/**
 * redis 使用IfAbsent 实现分布式锁 并设置超时时间
 */
@Test
public void testLock() {
    Boolean absent = redisTemplate.opsForValue().setIfAbsent("key1", "value2", 10, SECONDS);
    if (Boolean.TRUE.equals(absent)) {
        log.info("获取锁成功");
    } else {
        log.info("获取锁失败");
    }
}

/**
 * redis 实现订单全局唯一主键id
 */
@Test
public void testIncrement() {
    //定义一个java线程池
    for (int i = 0; i < 2000; i++) {
        new Thread(() -> {
            long orderId = orderIdService.getOrderId();
            log.info("orderId:{}", orderId);
        }).start();
    }
}

/**
 * Redis 使用hash类型 批量缓存 User 对象
 */
public void cacheUsers(List<User> users) {
    // 初始化一个HashMap，用于存储User对象
    Map<String, Object> usersMap = new HashMap<>();
    for (int i = 0; i < users.size(); i++) {
        User user = users.get(i);
        usersMap.put("user:" + user.getId(), JSON.toJSONString(user));
    }
    // 使用RedisTemplate批量插入多个键值对到Redis Hash中
    redisTemplate.opsForHash().putAll("users", usersMap);
}

/**
 * 从Redis缓存中批量取User对象
 */
public void batchGetUsers(Set<String> ids) {
    // 从Redis缓存中批量获取指定的User对象
    List<Object> objects = redisTemplate.opsForHash().multiGet("users", Arrays.asList(ids.toArray()));
    List<User> users = new ArrayList<>();
    for (Object object : objects) {
        User user = JSON.parseObject(object.toString(), User.class);
        users.add(user);
    }
   log.info("users:{}",users);
}


/**
 * 修改某个用户
 */
public void updateUser(User user) {
    // 将修改后的User对象重新缓存到Redis中
    redisTemplate.opsForHash().put("users", "user:" + user.getId(), JSON.toJSONString(user));
}

/**
 * 删除某个用户
 */
public void deleteUser(Long userId) {
    // 从Redis缓存中删除指定的User对象
    redisTemplate.opsForHash().delete("users", "user:" + userId);
}

/**
 * redis list类型 实现消息队列
 */
public void RedisBlocking() {
    CountDownLatch producer = new CountDownLatch(3);
    CountDownLatch consumer = new CountDownLatch(3);
    new Thread(() -> {
        for (int i = 0; i < 3; i++) {
            log.info("生产消息");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            redisTemplate.opsForList().rightPush("message_queue", "message" + i);
            consumer.countDown();
        }
    }).start();

    new Thread(() -> {
        for (int i = 0; i < 3; i++) {
            log.info("消费消息");
            producer.countDown();
            log.info("popMessageBlocking start");
            //不设置超时时间为非阻塞队列，设置为0 一直阻塞
            String message_queue = redisTemplate.opsForList().leftPop("message_queue", 10, SECONDS);
            log.info("message_queue:{}", message_queue);
            log.info("popMessageBlocking end");
        }
    }).start();
    try {
        consumer.await();
        producer.await();
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }

}
/**
 * redis list类型 实现栈
 */
public void redisStack() {
    redisTemplate.opsForList().leftPush("stack", "java");
    String stackMassage = redisTemplate.opsForList().leftPop("stack");
    log.info("stackMassage:{}", stackMassage);
}

/**@param key 列表名称
* @param start 起始下标（包括）
* @param end 结束下标（包括）
* @return 从起始下标到结束下标之间的元素列表
*/
public List<Object> lrange(String key, long start, long end) {
   return redisTemplate.opsForList().range(key, start, end);
}

/**
 * redis set类型 批量新增
 */
@Test
public void redisSetAdd() {
    redisTemplate.opsForSet().add("set", "java", "python", "c++");
    Set<String> obj = redisTemplate.opsForSet().members("set");
    log.info("obj:{}", obj);
}

/**
 * redis set类型 随机抽取两个元素
 */
@Test
public void redisSetRandom() {
    redisTemplate.opsForSet().add("set", "java", "python", "c++");
    Set<String> obj = redisTemplate.opsForSet().distinctRandomMembers("set", 2);
    log.info("obj:{}", obj);
}

/**
 * redis set类型 随机抽取两个元素并删除
 */
@Test
public void redisSetSpop() {
    redisTemplate.opsForSet().add("set", "java", "python", "c++");
    List<String> set = redisTemplate.opsForSet().pop("set", 2);
    log.info("obj:{}", set);
}


/**
 * Redis 集合实现推荐模型
 */
@Test
public void redisSet(){
    redisTemplate.opsForSet().add("person_1", "person_2", "person_3", "person_4","person_5");
    redisTemplate.opsForSet().add("person_2", "person_1", "person_6", "person_5","person_3");
    redisTemplate.opsForSet().add("person_3", "person_8", "person_9", "person_7","person_2");

    //person_1和person_2的共同关注
    Set<String> set = redisTemplate.opsForSet().intersect("person_1", "person_2");
    log.info("person_1和person_2的共同关注:{}", set);
    //person_1和关注的人也关注 person_4
    Set<String> careToCare = new HashSet<>();
    redisTemplate.opsForSet().members("person_1").forEach(person -> {
        if (Boolean.TRUE.equals(redisTemplate.opsForSet().isMember(person, "person_4"))) {
            careToCare.add(person);
        }
    });
    log.info("person_1和关注的人也关注 person_4:{}", careToCare);
    //person_1可能认识的人
    Set<String> person1Set = redisTemplate.opsForSet().members("person_1");
    Set<String> person1MayKnow = redisTemplate.opsForSet().difference(person1Set);
    log.info("person_1可能认识的人:{}", person1MayKnow);

}

/**
 * 测试Redis Scan 命令
 */
@Test
public void testScan() {
    ScanOptions options = ScanOptions.scanOptions().match("person*").build();
    redisTemplate.executeWithStickyConnection(connection -> {
        //scan命令返回的是游标，游标为0表示遍历完成
        Cursor<byte[]> cursor = connection.scan(options);
        while (cursor.hasNext()) {
            byte[] next = cursor.next();
            log.info("next:{}", new String(next));
        }
        return null;
    });
}

/**
 * Redis实现分库分表获取订单唯一自增Id
 */
@Component
public class OrderIdService implements ApplicationRunner {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    private static final String unique_key_order_id_prefix = "unique_key:order_id";

    private static final int buffer_order_id_size = 1000;

    /**
     * 本机缓存orderId 起始值
     */
    private Long bufferOrderIdStart;

    /**
     * 本机缓存orderId 结束值
     */
    private Long bufferOrderIdEnd;


    public synchronized long getOrderId() {
        if (bufferOrderIdStart.equals(bufferOrderIdEnd)) {
            bufferOrderIdEnd = redisTemplate.opsForValue().increment(unique_key_order_id_prefix, buffer_order_id_size);
        }
        return ++bufferOrderIdStart;
    }

    @Override
    public void run(ApplicationArguments args) {
        bufferOrderIdEnd = redisTemplate.opsForValue().increment(unique_key_order_id_prefix, buffer_order_id_size);
        if (bufferOrderIdEnd == null){
            throw new RuntimeException("获取bufferOrderIdEnd失败");
        }
        bufferOrderIdStart = bufferOrderIdEnd - 100;
    }
}