<!--  SpringBoot Boot Redis  -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>
<!-- Spring Boot Starter Test -->
<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-test</artifactId>
     <scope>test</scope>
  </dependency>
<!-- JUnit 5 -->
<dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-api</artifactId>
      <version>5.8.2</version>
      <scope>test</scope>
</dependency>
<dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-engine</artifactId>
      <version>5.8.2</version>
      <scope>test</scope>
</dependency>

spring:
  redis:
    host: 你的ip
    port: 6379

package com.bwie.common.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
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.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new
                Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);

        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();

        return template;
    }
}

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;

import static org.junit.jupiter.api.Assertions.assertEquals;

@SpringBootTest
public class StringExampleTest {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Test
    public void testString() {
        // 設(shè)置字符串值
        redisTemplate.opsForValue().set("myStringKey", "Hello Redis!");

        // 獲取并驗(yàn)證字符串值
        String value = (String) redisTemplate.opsForValue().get("myStringKey");
        assertEquals("Hello Redis!", value);  // 驗(yàn)證值是否正確

        // 更新字符串值
        redisTemplate.opsForValue().set("myStringKey", "Updated Value");
        assertEquals("Updated Value", redisTemplate.opsForValue().get("myStringKey"));  // 驗(yàn)證更新后的值

        // 增加計(jì)數(shù)器值
        redisTemplate.opsForValue().increment("myCounter", 1);
        assertEquals(1, redisTemplate.opsForValue().get("myCounter"));  // 驗(yàn)證計(jì)數(shù)器值

        // 設(shè)置帶有過期時(shí)間的字符串
        redisTemplate.opsForValue().set("tempKey", "I will expire soon", 10);
        // 驗(yàn)證過期時(shí)間是否小于10秒（實(shí)際過期時(shí)間可能略小于10秒）
        assertEquals(true, redisTemplate.getExpire("tempKey") < 10L);
    }
}

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;

import java.util.List;

import static org.junit.jupiter.api.Assertions.assertEquals;

@SpringBootTest
public class ListExampleTest {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Test
    public void testList() {
        // 向列表中添加元素
        redisTemplate.opsForList().leftPush("myListKey", "item1");
        redisTemplate.opsForList().leftPush("myListKey", "item2");

        // 獲取并驗(yàn)證列表中的所有元素
        List<Object> list = redisTemplate.opsForList().range("myListKey", 0, -1);
        assertEquals(true, list.contains("item2"));  // 驗(yàn)證列表包含 item2
        assertEquals(true, list.contains("item1"));  // 驗(yàn)證列表包含 item1

        // 從列表中彈出元素
        Object poppedItem = redisTemplate.opsForList().rightPop("myListKey");
        assertEquals("item1", poppedItem);  // 驗(yàn)證彈出的元素是 item1

        // 獲取列表長(zhǎng)度
        Long size = redisTemplate.opsForList().size("myListKey");
        assertEquals(1L, size);  // 驗(yàn)證列表長(zhǎng)度為 1

        // 在列表開頭插入新元素
        redisTemplate.opsForList().insert("myListKey", 0, "item0");
        List<Object> updatedList = redisTemplate.opsForList().range("myListKey", 0, -1);
        assertEquals(true, updatedList.contains("item0"));  // 驗(yàn)證列表包含 item0
        assertEquals(true, updatedList.contains("item2"));  // 驗(yàn)證列表仍包含 item2
    }
}

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;

import java.util.Set;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;

@SpringBootTest
public class SetExampleTest {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Test
    public void testSet() {
        // 向集合中添加元素
        redisTemplate.opsForSet().add("mySetKey", "member1", "member2", "member3");

        // 獲取并驗(yàn)證集合中的所有成員
        Set<Object> members = redisTemplate.opsForSet().members("mySetKey");
        assertEquals(true, members.contains("member1"));  // 驗(yàn)證集合包含 member1
        assertEquals(true, members.contains("member2"));  // 驗(yàn)證集合包含 member2
        assertEquals(true, members.contains("member3"));  // 驗(yàn)證集合包含 member3

        // 從集合中刪除某個(gè)成員
        redisTemplate.opsForSet().remove("mySetKey", "member2");
        assertFalse(redisTemplate.opsForSet().members("mySetKey").contains("member2"));  // 驗(yàn)證 member2 已被刪除

        // 檢查某個(gè)成員是否在集合中
        Boolean isMember = redisTemplate.opsForSet().isMember("mySetKey", "member1");
        assertEquals(true, isMember);  // 驗(yàn)證 member1 仍在集合中
    }
}

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;

import java.util.HashMap;
import java.util.Map;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;

@SpringBootTest
public class HashExampleTest {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Test
    public void testHash() {
        // 創(chuàng)建 HashMap 并存儲(chǔ)到 Redis 中
        Map<String, Object> myHash = new HashMap<>();
        myHash.put("field1", "value1");
        myHash.put("field2", "value2");
        redisTemplate.opsForHash().putAll("myHashKey", myHash);

        // 獲取并驗(yàn)證哈希字段值
        String fieldValue = (String) redisTemplate.opsForHash().get("myHashKey", "field1");
        assertEquals("value1", fieldValue);  // 驗(yàn)證字段值

        // 更新哈希字段
        redisTemplate.opsForHash().put("myHashKey", "field1", "newValue");
        assertEquals("newValue", redisTemplate.opsForHash().get("myHashKey", "field1"));  // 驗(yàn)證更新后的值

        // 刪除哈希字段
        redisTemplate.opsForHash().delete("myHashKey", "field2");
        assertFalse(redisTemplate.opsForHash().hasKey("myHashKey", "field2"));  // 驗(yàn)證字段是否已刪除

        // 獲取所有字段及其值
        Map<Object, Object> entries = redisTemplate.opsForHash().entries("myHashKey");
        assertEquals(true, entries.containsKey("field1"));  // 驗(yàn)證字段存在
        assertEquals("newValue", entries.get("field1"));  // 驗(yàn)證字段值
    }
}

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;

import java.util.Set;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;

@SpringBootTest
public class ZSetExampleTest {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Test
    public void testZSet() {
        // 向有序集合中添加元素
        redisTemplate.opsForZSet().add("myZSetKey", "member1", 1);
        redisTemplate.opsForZSet().add("myZSetKey", "member2", 2);

        // 獲取并驗(yàn)證有序集合中的所有成員
        Set<Object> zSetMembers = redisTemplate.opsForZSet().range("myZSetKey", 0, -1);
        assertEquals(true, zSetMembers.contains("member1"));  // 驗(yàn)證 member1 存在
        assertEquals(true, zSetMembers.contains("member2"));  // 驗(yàn)證 member2 存在

        // 更新元素的分?jǐn)?shù)
        redisTemplate.opsForZSet().incrementScore("myZSetKey", "member1", 3);
        Double score = redisTemplate.opsForZSet().score("myZSetKey", "member1");
        assertEquals(4.0, score);  // 驗(yàn)證 member1 的分?jǐn)?shù)更新為 4.0

        // 獲取指定分?jǐn)?shù)范圍內(nèi)的成員
        Set<Object> rangeByScore = redisTemplate.opsForZSet().rangeByScore("myZSetKey", 1, 2);
        assertEquals(true, rangeByScore.contains("member2"));  // 驗(yàn)證 member2 在分?jǐn)?shù)范圍內(nèi)

        // 從有序集合中刪除某個(gè)成員
        redisTemplate.opsForZSet().remove("myZSetKey", "member2");
        assertFalse(redisTemplate.opsForZSet().range("myZSetKey", 0, -1).contains("member2"));  // 驗(yàn)證 member2 已被刪除
    }
}