第七章-springboot整合redis

飞一样的编程

擅长邻域：Java,MySQL,Linux,nginx,springboot,mongodb,微信小程序,vue

分类： springboot 专栏： springboot3.0新教材标签：整合redis

2024-01-08 15:33:49 3228浏览

整合redis

redis简介

Redis是一款基于key-value的内存数据存储系统，有以下一些优点：速度快：Redis非常快，每秒可执行大约110000次的设置(SET)操作，每秒大约可执行81000次的读取/获取(GET)操作。

支持丰富的数据类型：Redis支持五种数据类型: string (字符串) , hash(哈希) , list(列表) , set(集合)及zset(sorted set:有序集合)。

操作具有原子性：所有Redis操作都是原子操作，这确保如果两个客户端并发访问，Redis服务器能接收更新的值。

应用广泛：可用于缓存，消息队列(Redis本地支持发布/订阅)，应用程序中的任何短期数据如web应用程序中的会话（Session）、网页计数、排行榜等。

redis的安装与运行

安装windows版本的Redis即可，另外可以下载Redis图形化客户端工具，方便直观查看数据库信息，这里下载的是RedisDesktopManager。

启动redis:双击redis-server.exe就行

疑问：那如果我要设置密码启动呢？

修改redis.windows.conf里的配置

然后启动的时候，是在redis安装目录下，cmd里输入redis-server.exe redis.windows.conf回车

redis的常用命令

a. 通用命令

select：选择数据库，Redis默认有16个数据库，编号是0-15，默认当前数据库是0，如果要选择其他编号的数据库则用“select 编号”的命令。

keys：查看键，后面接键的名称或包含通配符*的字符串，如果要查看所有的键，则用 keys *。

exists key：是否存个某个键，key代表键的名称。

del key：删除某个键，key代表键的名称。

flushall:删除所有的键

flushdb：删除当前数据库中的所有Key

b. 值为String类型的有关命令

set key value：添加一个键值对到Redis数据库中，如果键存在，则修改键的值。

mset key1 value1 key2 value…：一次设置多个键值对。

get key：通过键查找值。

mget key1 key2 key3…：一次读取多个键的值。

append key value：追加value值到键原有值上，如果没有这个键，则新建。

c. 值为 List类型的有关命令

lpush key value：添加一个值到列表的头部（左侧添加）。

rpush key value：添加一个值到列表的尾部（右侧添加）。

lrange key start stop：查看列表中索引从start到stop之间的值。

lpop key：返回并删除列表中的头部的值。

rpop key: 返回并删除列表中的尾部的值。

springboot访问redis

Spring Boot访问Redis的技术称为Spring Data Redis，Spring Boot提供了RedisAutoConfiguration自动配置类，该自动配置类检测到spring-boot-start-data-redis依赖包被使用时生效，只需要在Spring Boot中导入spring-boot-start-data-redis依赖包就可以使用Spring Data Redis。Spring Data Redis默认创建了RedisTemplate和StringRedisTemplate两个bean，用户可以从Spring容器中注入并使用它们进行Redis的常用操作。此外用户还可以使用RedisRepository来访问Redis数据库。RedisTemplate提供了操作Redis中的多种数据类型的API，StringRedisTemplate只针对键值都是字符串类型的数据进行操作。RedisTemplate默认使用JdkSerializationRedisSerializer进行序列化，StringRedisTemplate默认使用StringRedisSerializer进行序列化。

RedisAutoConfiguration自动配置类创建RedisTemplate和StringRedisTemplate实例（bean）时使用了RedisProperties类提供的属性，包括Redis服务器地址、端口号、密码等等属性，这些属性很多都有默认值，比如服务器地址默认为localhost、端口号默认为6379，同时该类上面有@ConfigurationProperties(prefix = "spring.redis")注解，表示可以加载Spring Boot的主配置文件application.properties中前缀为spring.redis的配置信息，这样用户既可以不在application.properties做任何有关Redis的配置，也可以在application.properties中使用spring.redis前缀重新配置Redis。查看RedisProperties源码，可以看到Spring Boot有关Redis的默认配置如下，如果要重新配置，拷贝这些代码到application.properties中并适当修改即可。代码如下：

redis template操作string类型

a. 依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

b. 配置application.properties

Spring Boot自动配置了Redis，默认配置可以满足本项目要求，所以这里application.properties不需要任何配置。

c. 创建实体类。注意实体类Book必须实现序列化接口。


@Data
@AllArgsConstructor
@NoArgsConstructor
public class Book implements Serializable {
    private Integer id;
    private String name;
    private Double price;
    private String category;
    private Integer pnum;
    private String imgurl;
    private String description;
    private String author;
    private Integer sales;
}

d. 写单元测试类

然后开始直接写单元测试类(完成以下功能)

    //存储字符串类型的key-value
    //通过键获取字符串类型的值
    //删除某个键值对
    //保存一本书
    
    //通过id号查找一本书
    //保存多本书 list
    //查找所有书
    //从多本book集合中找到某个id的书
 	//根据id删除book集合中的某本书

 Book book = new Book(1, "三国演义", 100.00, "文学", 100, "101.png", "四大名著", "罗贯中", 55);


new Book(1,"C语言程序设计",50.0,"计算机",100,"101.jpg","","zhangsan",50),
new Book(2,"java语言程序设计",60.0,"计算机",100,"102.jpg","","zhangsan",50),
new Book(3,"python语言程序设计",70.0,"计算机",100,"103.jpg","","zhangsan",50)

@SpringBootTest
public class RedisTemplateTest {

    @Autowired
    StringRedisTemplate stringRedisTemplate;

    @Autowired
    RedisTemplate redisTemplate;


    //存储字符串类型的key-value
    @Test
    void testKeyV(){
        stringRedisTemplate.opsForValue().set("username","xiaojie");
    }
    //通过键获取字符串类型的值
    @Test
    void getValue(){
        String username = stringRedisTemplate.opsForValue().get("username");

        System.out.println(username);
    }
    //删除某个键值对
    @Test
    void delKey(){
        stringRedisTemplate.delete("username");
    }
    //保存一本书
    @Test
    void saveBook(){
        Book book = new Book(1, "三国演义", 100.00, "文学", 100, "101.png", "四大名著", "罗贯中", 55);
        redisTemplate.opsForValue().set(1,book);
    }
    //通过id号查找一本书
    @Test
    void getBook(){
        Book book = (Book) redisTemplate.opsForValue().get(1);
        System.out.println(book);
    }
    //保存多本书 list
    @Test
    void saveBooks(){
        List<Book> books= Arrays.asList(
                new Book(1,"C语言程序设计",50.0,"计算机",100,"101.jpg","","zhangsan",50),
                new Book(2,"java语言程序设计",60.0,"计算机",100,"102.jpg","","zhangsan",50),
                new Book(3,"python语言程序设计",70.0,"计算机",100,"103.jpg","","zhangsan",50)
        );
        redisTemplate.opsForValue().set("books",books);
    }
    //查找所有书
    @Test
    void searchBooks(){
        System.out.println(redisTemplate.opsForValue().get("books"));
    }

    //从多本book集合中找到某个id的书
    @Test
    void getBookById(){
        Integer id =1;
        List<Book> books =(List<Book>) redisTemplate.opsForValue().get("books");
        Book book = books.get(id - 1);
        System.out.println(book);
    }

    //根据id删除book集合中的某本书
    @Test
    void delBook(){
        Integer id =1;
        List<Book> books =(List<Book>) redisTemplate.opsForValue().get("books");
        books.remove(id-1);
        redisTemplate.opsForValue().set("books",books);
    }
}

e. 解决序列化问题

使用StringRedisTemplate操作的数据没什么问题，但RedisTemplate操作的数据为乱码，无法直接查看，这是因为RedisTemplate默认的序列化为JdkSerializationRedisSerializer，这样对象数据就会使用Java对象流保存为序列化后的字符串（无法直接查看）。对于这种情况，可以通过在配置类中重新创建RedisTemplate的bean，使用Jackson2JsonRedisSerialize替换默认序列化，使对象转换成JSON格式的字符串再进行保存。

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate  redisTemplate( RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

        //objectMapper, 必须加，解决查询缓存转换异常的问题
        Jackson2JsonRedisSerializer ser = new Jackson2JsonRedisSerializer(objectMapper,Object.class);
        template.setDefaultSerializer(ser);

        return template;
    }
}

redis template操作redis各种数据类型

RedisTemplate提供了以下5种方法分别操作Redis的5种类型的数据。

(1) opsForValue()方法：操作字符串。

(2) opsForHash()方法：操作散列。

(3) opsForList()方法：操作列表。

(4) opsForSet()方法：操作集合。

(5) opsForZSet()方法：操作有序集合。

1. opsForValue()方法

void set(K key,V value)方法：用于存储键值对，键和值都是字符串，其中值可以是序列化后的对象

void set(K key,V value,long timeout,timeUnit unit)方法：存储键值对的同时规定了失效时间，timeout代表失效时间，unit代表时间单位，可以取以下值：

(1) TimeUnit.DAYS：日

(2) TimeUnit.HOURS：时

(3) TimeUnit.MINUTES：分

(4) TimeUnit.SECONDS：秒

(5) TimeUnit.MILLISECONDS：毫秒

a. 测试案例1：set

@SpringBootTest
class RedisdemoApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void test1() throws InterruptedException { //测试失效时间
        redisTemplate.opsForValue().set("test1", "Test Timeout 5 seconds", 5, TimeUnit.SECONDS);
        System.out.println("第0秒取值：" + redisTemplate.opsForValue().get("test1"));
        Thread.sleep(4000);
        System.out.println("第4秒取值：" + redisTemplate.opsForValue().get("test1"));
        Thread.sleep(2000);
        System.out.println("第6秒取值：" + redisTemplate.opsForValue().get("test1"));
    }

第0秒取值：Test Timeout 5 seconds
第4秒取值：Test Timeout 5 seconds
第6秒取值：null

可见一旦超过时间，就会被redis删掉

b. 测试案例2：getAndSet

V getAndSet(K key,V value)方法：先获取并返回key的旧值，再设置为新值。

   @Test
    void test2() throws InterruptedException { //测试getAndSet方法
        redisTemplate.opsForValue().set("test2", "Test getAndSet1");
        System.out.println(redisTemplate.opsForValue().getAndSet("test2", "Test getAndSet2"));
        System.out.println(redisTemplate.opsForValue().get("test2"));
    }

Test getAndSet1
Test getAndSet2

c. 案例3：append

Integer append(K key,String value)方法：如果key不存在则创建，相当于set方法，如果key存在则追加字符串到未尾。

@Test
    void test3() { //测试append方法
        redisTemplate.setValueSerializer(new StringRedisSerializer());//设置字符串序列化
        redisTemplate.opsForValue().append("test3", "test3"); //首次追加相当于set方法
        System.out.println(redisTemplate.opsForValue().get("test3"));
        redisTemplate.opsForValue().append("test3", " OK！");//追加内容到未尾
        System.out.println(redisTemplate.opsForValue().get("test3"));
    }

test3
test3 OK！

2. opsForHash()方法

opsForHash()方法又提供操作Hash类型的值的方法如下：void put(H h, HK hk,HV hv)方法：用于存储指定键中的字段与值。Map<HK, HV> entries(H h)方法：获取指定键的所有字段与值。

分别存储书的名称与价格信息

 @Test
    void testHash1() { //测试put方法，存入一个键值
        redisTemplate.opsForHash().put("book1", "bookname", "三国演义");
        redisTemplate.opsForHash().put("book1", "price", "69.0");
        System.out.println(redisTemplate.opsForHash().entries("book1")); //读取整个hash类型（键与值）
    }

{bookname=三国演义, price=69.0}

a. putAll

void putAll(H h, java.util.Map<? extends HK, ? extends HV> map)方法:用Map 封装多个字段与值，一次性存储多个字段与值。

  @Test
    void testHash2() { //测试Hash类型，putAll方法，将整个hashmap存入
        Map<String, Object> map = new HashMap();
        map.put("bookname", "西游记");
        map.put("category", "文学");
        redisTemplate.opsForHash().putAll("book2", map);
        System.out.println(redisTemplate.opsForHash().entries("book2")); //读取整个hash类型
    }

b. keys

Set<HK> keys(H h)方法:获取指定键的字段的集合。

@Test
    void testHash3() { //测试keys方法。获取所有键的集合
        redisTemplate.opsForHash().put("book3", "bookname", "红楼梦");
        redisTemplate.opsForHash().put("book3", "price", "89.0");
        System.out.println(redisTemplate.opsForHash().keys("book3")); //读取所有键的集合
    }

[bookname, price]

c. values

List<HV> values(H h)方法:获取指定键的值的集合。

 @Test
    void testHash4() { //测试values方法。获取所有值的集合
        redisTemplate.opsForHash().put("book4", "bookname", "封神榜");
        redisTemplate.opsForHash().put("book4", "price", "79.0");
        System.out.println(redisTemplate.opsForHash().values("book4")); //读取所有值的集合
    }

[封神榜, 79.0]

d. size、hasKey、delete

Long size(H h)方法：返回指定键中字段的数量。

Boolean hasKey(H h, Object o)方法：查找指定键中是否包含某个字段。

Long delete(H h, Object... objects)方法：删除指定键中的某个字段。

@Test
    void testHash5() { //测试delete方法。删除某个键的某个字段,hasKey方法，size方法
        redisTemplate.opsForHash().put("book5", "bookname", "封神榜");
        redisTemplate.opsForHash().put("book5", "price", "89.0");
        System.out.println(redisTemplate.opsForHash().entries("book5"));
        System.out.println(redisTemplate.opsForHash().size("book5"));//字段个数
        System.out.println(redisTemplate.opsForHash().hasKey("book5", "price")); //判断字段是否存在
        redisTemplate.opsForHash().delete("book5", "price"); //删除一个字段
        System.out.println(redisTemplate.opsForHash().hasKey("book5", "price"));//再次判断
        System.out.println(redisTemplate.opsForHash().entries("book5"));
    }

{bookname=封神榜, price=89.0}
2
true
false
{bookname=封神榜}

3. opsForList()方法

a. leftPush:从左侧添加一个元素到列表

Long leftPush(K k, V v)：从左侧添加一个元素到列表。

Long leftPushAll(K k, V... vs)：从左侧一次添加多个元素到列表。

Long size(K k)：获取集合中的元素个数。

java.util.List<V> range(K k,long l, long l1)：返回某个列表指定索引区间的元素。索引从0算起，-1表示最右侧第一个元素。

 @Test
    void TestList1() {//测试leftPush方法，leftPushAll方法，range方法,size方法
        redisTemplate.opsForList().leftPush("mylist1", "a");
        redisTemplate.opsForList().leftPush("mylist1", "b");
        redisTemplate.opsForList().leftPush("mylist1", "c");
        System.out.println(redisTemplate.opsForList().size("mylist1"));
        System.out.println(redisTemplate.opsForList().range("mylist1", 0, -1));
        redisTemplate.opsForList().leftPushAll("mylist1", "1","2");//添加多个元素
        String[] str = {"3", "4", "5"};
        redisTemplate.opsForList().leftPushAll("mylist1", str);//使用数组添加多个元素
        System.out.println(redisTemplate.opsForList().size("mylist1"));
        System.out.println(redisTemplate.opsForList().range("mylist1", 0, -1));

    }

3
[c, b, a]
8
[5, 4, 3, 2, 1, c, b, a]

b. rightPushAll：从右侧添加多个元素到列表

Long rightPushAll(K k, V... vs):从右侧一次添加多个元素到列表。

@Test
    void TestList2() {//测试rightPush方法，rightPushAll方法
        redisTemplate.opsForList().rightPush("mylist2", "a");
        redisTemplate.opsForList().rightPush("mylist2", "b");
        redisTemplate.opsForList().rightPush("mylist2", "c");
        System.out.println(redisTemplate.opsForList().size("mylist2"));
        System.out.println(redisTemplate.opsForList().range("mylist2", 0, -1));
        redisTemplate.opsForList().rightPushAll("mylist2", "1","2");//一次添加多个元素
        String[] str = {"3", "4", "5"};
        redisTemplate.opsForList().rightPushAll("mylist2", str);//使用数组一次添加多个元素
        System.out.println(redisTemplate.opsForList().size("mylist2"));
        System.out.println(redisTemplate.opsForList().range("mylist2", 0, -1));

    }

3
[a, b, c]
8
[a, b, c, 1, 2, 3, 4, 5]

c. remove：删除集合中指定数量个元素

【例7-11】 Long remove(K k, long l, Object o):删除集合中指定数量个元素，如果数量为0，则该元素全部从集合删除，如果数量为正数，则从左到右删除，如果为负数，则从右到左删除。

 @Test
    void testList3() { //测试remove
        String[] str = {"10", "20", "30", "10", "20", "30", "10", "20", "30"};
        redisTemplate.opsForList().rightPushAll("mylist3", str);
        System.out.println(redisTemplate.opsForList().range("mylist3", 0, -1));
        redisTemplate.opsForList().remove("mylist3", 0, "10");//全部删除
        System.out.println(redisTemplate.opsForList().range("mylist3", 0, -1));
        redisTemplate.opsForList().remove("mylist3", 2, "20");//从左到右删
        System.out.println(redisTemplate.opsForList().range("mylist3", 0, -1));
        redisTemplate.opsForList().remove("mylist3", -2, "30");//从右到左删
        System.out.println(redisTemplate.opsForList().range("mylist3", 0, -1));
    }

[10, 20, 30, 10, 20, 30, 10, 20, 30]
[20, 30, 20, 30, 20, 30]
[30, 30, 20, 30]
[30, 20]

d. leftPop和rightPop:删除并返回左侧/右侧第一个元素

V leftPop(K k):删除并返回左侧第一个元素。

V rightPop(K k):删除并返回右侧第一个元素。

@Test
    void testList4() {//测试leftPop,rightPop方法
        String[] str = {"a", "b", "c","d","e"};
        redisTemplate.opsForList().rightPushAll("mylist4", str);
        System.out.println(redisTemplate.opsForList().range("mylist4", 0, -1));
        System.out.println(redisTemplate.opsForList().leftPop("mylist4"));//从左侧删
        System.out.println(redisTemplate.opsForList().range("mylist4", 0, -1));
        System.out.println(redisTemplate.opsForList().rightPop("mylist4"));//从右侧删
        System.out.println(redisTemplate.opsForList().range("mylist4", 0, -1));


    }

[a, b, c, d, e]
a
[b, c, d, e]
e
[b, c, d]

e. index:获取指定索引处的元素值 set:为指定索引处的元素设置值，原有值将被覆盖

V index(K k, long l):获取指定索引处的元素值-

void set(K k, long l, V v):为指定索引处的元素设置值，原有值将被覆盖。

@Test
    void testList5(){ //测试set和index方法
        String[] str = {"a", "b", "c"};
        redisTemplate.opsForList().rightPushAll("mylist5", str);
        System.out.println(redisTemplate.opsForList().range("mylist5", 0, -1));
        System.out.println(redisTemplate.opsForList().index("mylist5",1));//获取索引1处的值
        redisTemplate.opsForList().set("mylist5", 1,"d");//将索引1处的值改为b
        System.out.println(redisTemplate.opsForList().range("mylist5", 0, -1));
        System.out.println(redisTemplate.opsForList().index("mylist5",1));

    }

[a, b, c]
b
[a, d, c]
d

4. opsForSet()方法

a. add size members remove pop

Long add(K k, V... vs)方法：添加数据（元素）到集合。

Long size(K k)方法：返回集合的长度，即集合中元素的个数。

java.util.Set<V> members(K k)：返回集合中的所有元素。

Long remove(K k, Object... objects)：删除元素。

V pop(K k)：随机删除。

@Test
    void testSet1(){ //测试添加 删除，size,members方法

        redisTemplate.opsForSet().add("myset1","a");
        redisTemplate.opsForSet().add("myset1","b","c");
        String[] str={"1","2"};
        redisTemplate.opsForSet().add("myset1",str);
        System.out.println("size:"+redisTemplate.opsForSet().size("myset1"));
        System.out.println(redisTemplate.opsForSet().members("myset1"));//查看所有元素
        System.out.println(redisTemplate.opsForSet().remove("myset1","a"));//删除一个元素
        System.out.println(redisTemplate.opsForSet().members("myset1"));
        System.out.println(redisTemplate.opsForSet().remove("myset1",str));//删除多个元素
        System.out.println(redisTemplate.opsForSet().members("myset1"));
        redisTemplate.opsForSet().add("myset1",str);//重新添加
        System.out.println(redisTemplate.opsForSet().members("myset1")); //再次查看
        System.out.println(redisTemplate.opsForSet().pop("myset1"));//随机删除
        System.out.println(redisTemplate.opsForSet().members("myset1"));

    }

size:5
[b, a, 1, c, 2]
1
[1, c, 2, b]
2
[b, c]
[2, b, 1, c]
2
[b, 1, c]

b. move:移动元素到另一个集合

Boolean move(K k, V v,K k1)方法:移动元素到另一个集合。

 @Test
    void testSet2(){ //测试移动
        String[] str1={"1","2","3"};
        String[] str2={"a","b","c"};
        System.out.println(redisTemplate.opsForSet().add("myset2",str1));
        System.out.println(redisTemplate.opsForSet().add("myset3",str2));
        System.out.println(redisTemplate.opsForSet().members("myset2"));
        System.out.println(redisTemplate.opsForSet().members("myset3"));
        redisTemplate.opsForSet().move("myset2","1","myset3");
        System.out.println(redisTemplate.opsForSet().members("myset2"));
        System.out.println(redisTemplate.opsForSet().members("myset3"));


    }

[3, 1, 2]
[c, a, b]
[3, 2]
[c, a, 1, b]

c. scan:遍历集合中所有元素

Cursor<V> scan(K k, ScanOptions scanOptions):遍历集合中所有元素。

  @Test
    void testSet3(){
        String[] str={"a","b","c"};
        redisTemplate.opsForSet().add("myset4",str);
        Cursor<Object> cursor=redisTemplate.opsForSet().scan("myset4", ScanOptions.NONE);
        while(cursor.hasNext()){
            System.out.println(cursor.next());
        }
    }

5. opsForZSet()方法

Boolean add(K k, V v, double v1)：添加元素。

Long size(K k)：返回集合中元素的个数。

Set<V> range(K k, long l, long l1)：返回指定索引范围的元素。

Long rank(K k, Object o)：返回某个元素的索引。

@Test
    void testZset1(){
        redisTemplate.opsForZSet().add("zset1","f1",80);
        redisTemplate.opsForZSet().add("zset1","f2",70);
        redisTemplate.opsForZSet().add("zset1","f3",90);
        System.out.println("size:"+redisTemplate.opsForZSet().size("zset1"));
        System.out.println(redisTemplate.opsForZSet().range("zset1",0,-1));
        System.out.println(redisTemplate.opsForZSet().rank("zset1","f1"));



    }

size:3
[f2, f1, f3]
1

a. score:返回某个元素的分数

Double score(K k, Object o):返回某个元素的分数。

Set<V> rangeByScore(K k, double v, double vl):返回指定分数范围的元素。

Long count(K k, double v, double vl):返回指定分数范围的元素的个数。

  @Test
    void testZset2(){
        redisTemplate.opsForZSet().add("zset2","f1",80);
        redisTemplate.opsForZSet().add("zset2","f2",70);
        redisTemplate.opsForZSet().add("zset2","f3",90);
        redisTemplate.opsForZSet().add("zset2","f4",60);
        System.out.println(redisTemplate.opsForZSet().score("zset2","f1"));
        System.out.println(redisTemplate.opsForZSet().range("zset2",0,-1));

        System.out.println(redisTemplate.opsForZSet().rangeByScore("zset2",70,90));
        System.out.println(redisTemplate.opsForZSet().count("zset2",70,90));


    }

80.0
[f4, f2, f1, f3]
[f2, f1, f3]
3

b. remove：删除指定元素

 @Test
    void testZset3(){
        redisTemplate.opsForZSet().add("zset3","f1",40);
        redisTemplate.opsForZSet().add("zset3","f2",50);
        redisTemplate.opsForZSet().add("zset3","f3",60);
        redisTemplate.opsForZSet().add("zset3","f4",70);
        redisTemplate.opsForZSet().add("zset3","f5",80);
        redisTemplate.opsForZSet().add("zset3","f6",90);
        redisTemplate.opsForZSet().add("zset3","f7",100);
        System.out.println(redisTemplate.opsForZSet().range("zset3",0,-1));
        redisTemplate.opsForZSet().remove("zset3","f1");
        System.out.println(redisTemplate.opsForZSet().range("zset3",0,-1));
        redisTemplate.opsForZSet().removeRange("zset3",0,1);
        System.out.println(redisTemplate.opsForZSet().range("zset3",0,-1));
        redisTemplate.opsForZSet().removeRangeByScore("zset3",70,80);
        System.out.println(redisTemplate.opsForZSet().range("zset3",0,-1));

    }

[f1, f2, f3, f4, f5, f6, f7]
[f2, f3, f4, f5, f6, f7]
[f4, f5, f6, f7]
[f6, f7]

如果是降序排列呢？

redisTemplate.opsForZSet().reverseRange("zset3",0,-1)

redis实现分布式session共享

如果服务端做了负载均衡，服务端同时部署了多个服务器，当用户在服务器1上进行了登录，然后下次访问的是服务器2，则有可能不能识别用户的登录状态，这时就要通过共享Session来解决，其思路是将Session放在多个服务器之外的共同的Redis中，让多个服务器共享。

a. 依赖

 <dependency>
            <groupId>org.springframework.session</groupId>
            <artifactId>spring-session-data-redis</artifactId>
<!--            <version>2.5.0</version>-->
        </dependency>

b. 启动类添加@EnableRedisHttpSession注解。

c. 创建控制器

d. 多环境配置

删除application.properties文件，

创建application-dev.properties文件表示开发环境，配置如下：

server.port=8081

创建application-prod.properties文件表示生产环境，配置如下：

server.port=8082

e. 运行测试

先打包项目，然后切换到jar包所在目录的命令提示符，运行两个服务器端程序，模拟两个不同的服务器,分别输入两条命令如下：

服务器安装jdk17

wget https://download.oracle.com/java/17/latest/jdk-17_linux-x64_bin.tar.gz

配置环境变量

export JAVA_HOME=/path/to/jdk17
export PATH=$PATH:$JAVA_HOME/bin

使其生效

source /etc/profile

nohup java -jar redisSession-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev &

nohup java -jar redisSession-0.0.1-SNAPSHOT.jar --spring.profiles.active=prod &

#＆表示让项目在后台运行

java -jar xxx.jar &

#nohup表示当窗口(xshell)关闭时服务不挂起，继续在后台运行

nohup java -jar xxx.jar &
nohup java -jar -Dserver.port=8088 xxx.jar &

也可以换个思路解决

复制一个出来，相当于集群，两个项目源码是一模一样的，只是激活的profiles不一样（一个是dev的，一个是prop的）

f. 配置Nginx

浏览器访问localhost:80 时，并多次刷新，发现将轮流实际访问127.0.0.1:8081和127.0.0.1:8082，实现了反向代理和负载均衡的功能

新闻阅读与点赞次数实战

实战说明：首页是新闻列表，点击任一标题，可以进入该新闻详情页面，详情页面显示该条新闻阅读次数，点赞次数，初次进入阅读次数为1，点赞数为0，提供一个按钮可以点赞，点赞完后点赞数立即更新，刷新页面，阅读次数和点赞次数都刷新。阅读和点赞次数都保存到redis内存数据库中，速度快，但每隔一分钟都将最新数据持久化保存到mysql数据库中进行持久化。

考虑用redis自增自减

自增(increment):使用opsForHash().increment(key, hashKey, delta)方法来对指定的hash字段进行自增操作。其中，key表示存储在Redis中的键名称; hashKey表示要自增的字段名称; delta表示每次自增的值。如果该字段不存在或者为空，则会将其初始化为0后再进行自增操作。

a. 添加依赖

 <!--quartz相关依赖 -->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
        </dependency>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz-jobs</artifactId>
        </dependency>

b. 创建NewsController控制器

主要提供访问首页的功能，查看新闻详情的功能，查看详情时把该新闻id存储在redis中包含阅读次数和点赞次数的hash类型数据读取出来，阅读次数还要加1，存入model域供前端展示，并更新到redis。还有点赞功能，从redis中提取数据，然后点赞次数加1

@Controller
public class NewsController {

    @Autowired
    RedisTemplate redisTemplate;
    //更新浏览量
    @GetMapping("/detail/{id}")
    public String see(@PathVariable Integer id, Model model){

        //阅读量自增1
        redisTemplate.opsForHash().increment("news_" + id, "read", 1);
        //查询出数据放到model中，方便前端页面展示点赞量和阅读量
        Map map = redisTemplate.opsForHash().entries("news_" + id);
        model.addAllAttributes(map);

        return "news"+id;

    }
    //点赞功能
    @RequestMapping("/addZan/{id}/{opType}")
    @ResponseBody
    public Long addZan(@PathVariable Integer id ,@PathVariable Integer opType){
        Long countZan;
        if (opType==1) {//点赞
            countZan = redisTemplate.opsForHash().increment("news_" + id, "countZan", 1);


        }else{//取消点赞
            countZan=redisTemplate.opsForHash().increment("news_"+id,"countZan",-1);

       }
        return countZan;
    }
}

c. 定时任务

Redis中的数据每隔一分钟要保存到数据库用到Spring的定时任务，

创建NewJob类，创建SaveNewsData方法，在方法前面添加@Scheduled注解实现每隔一分钟执行该方法功能，此外启动类上面要加上@EnableScheduling注解，表示开启定时任务

@Slf4j
@Component
public class NewsJob {
    @Autowired
    private RedisTemplate redisTemplate;

    @Scheduled(cron = "0 0/1 * * * ? ")
    public void saveNew(){
        Set<String> keys = redisTemplate.keys("news_*");
        for(String key:keys){
            Map  map=redisTemplate.opsForHash().entries(key);
            String id=key.substring(5);//获取key中包含的id号，key是news_+id的格式
            //然后就可调用业务层将这些数据update到数据库，自行实现。
            log.info("编号："+id+",阅读次数："+map.get("read")+",点赞次数："+map.get("countZan"));
        }

        log.info("以上数据已保存到数据库");
    }
}

补充：cron表达式（七子表达式）

d. 创建视图

?jquery-1.12.4.js

前端页面

<h1>新闻列表</h1>

<ul>
    <li>
        <a th:href="@{/detail/1}">新闻1</a>

    </li>
    <li>
        <a th:href="@{/detail/2}">新闻2</a>
    </li>
</ul>

<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>warmer-redis</title>
    <script type="text/javascript" src="/js/jquery-1.12.4.js"></script>
    <script>
        function zan(id,opType){
            $.ajax({
                url:"/addZan/"+id+"/"+opType,
                type:"get",
                success:function(data){
                    $("#countZan").text(data);
                }
            });
        }

    </script>
</head>
<body>
<h1 style="text-align: center">新闻1</h1>
阅读数<font color="red" th:text="${read}" ></font>&nbsp;&nbsp; 点赞数<font id="countZan" color="red" th:text="${countZan==null?0:countZan}"></font>&nbsp;&nbsp;
<input type="button" onclick="zan(1,1)" value="点赞"/>
<input type="button" onclick="zan(1,0)" value="取消点赞"/>

</body>
</html>

e. 测试

浏览新闻2，结果类似。此外观察控制台，每隔一分钟会提示最新数据保存到数据库

使用RedisRepository访问redis

Spring Data推出了操作Redis的RedisRespository方式，提供类似Spring Data JPA一样的接口，使得操作Redis变得非常简单。只要在接口中继承CrudRepository接口，就能跟Spring Data JPA一样，其本的增删改操作不需要定义任何方法。

a. 加@RedisHash注解

注意必须要加@RedisHash注解，用于指定操作实体类对象在Redis数据库中的存储空间，此处表示针对Book实体类的数据操作都存储在Redis数据库中名为books的存储空间下

@Data
@AllArgsConstructor
@NoArgsConstructor
//@RedisHash(value = "bookinfo",timeToLive = 60)
@RedisHash(value = "bookinfo")
public class BookInfo {
    @Id
    private int id;
    @Indexed
    private String name;
    private String category;
    private String author;
    private double price;
}

b. dao层

@Repository
public interface BookInfoDao  extends CrudRepository<BookInfo,Integer> {
    Iterable<BookInfo> findByName(String name);
}

c. 测试

@SpringBootTest
public class RedisRepository {
    @Autowired
    BookInfoDao bookInfoDao;

    @Test //添加图书
    void testSaveBook() {
        BookInfo book1=new BookInfo(1,"西游记","文学","吴承恩",88);
        bookInfoDao.save(book1);
        BookInfo book2=new BookInfo(2,"三国演义","文学","罗贯中",78);
        bookInfoDao.save(book2);
        BookInfo book3=new BookInfo(3,"水浒传","文学","施耐俺",68);
        bookInfoDao.save(book3);
        BookInfo book4=new BookInfo(4,"三国志","文学","佚名",78);
        bookInfoDao.save(book4);
        System.out.println("添加成功！");
    }

    @Test //查询所有图书
    void testFindAllBooks() {
        Iterable<BookInfo> iterable=bookInfoDao.findAll();
        Iterator<BookInfo> it=iterable.iterator();
        while(it.hasNext()){
            BookInfo book= it.next();
            System.out.println(book);
        }
    }


    @Test //根据Id号图书
    void testFindBookById() {
        BookInfo book=bookInfoDao.findById(1).get();
        System.out.println(book);
    }

    @Test //根据Name查询图书
    void testFindBooksByName() {
        Iterable<BookInfo> iterable=bookInfoDao.findByName("三国志");
        Iterator<BookInfo> it=iterable.iterator();
        while(it.hasNext()){
            BookInfo book= it.next();
            System.out.println(book);
        }
    }

    @Test //修改图书
    void testUpdateBook() {
        BookInfo book=bookInfoDao.findById(1).get();
        book.setPrice(98);
        bookInfoDao.save(book);
        System.out.println("修改成功！");
    }

    @Test //删除图书
    void testDeleteBook() {
        bookInfoDao.deleteById(2);
        System.out.println("删除成功！");
    }
}

Linux服务器里redis安装和启动

1、解压安装包

2、进入到安装目录

3、make编译或者 make MALLOC=libc

如果报错的话，检查一下是否安装gcc

4、修改redis的配置文件redis.conf，

确保宿主机能连接到虚拟主机里的redis

本机redis客户端连接虚拟主机里的Redis，需要修改下redis的配置文件，bind 默认是127.0.0.1要将其改为0.0.0.0

修改成密码启动，

设置以后台的形式运行

5、启动redis

进入redis安装目录的src下输入./redis-server ../redis.conf启动redis

搭建redis集群

什么是redis集群呢？

Redis3.0加入了Redis的集群模式，实现了数据的分布式存储，对数据进行分片，将不同的数据存储在不同的master节点上面，从而解决了海量数据的存储问题。 Redis集群采用去中心化的思想，没有中心节点的说法，对于客户端来说，整个集群可以看成一个整体，可以连接任意一个节点进行操作，就像操作单一Redis实例一样，不需要任何代理中间件，当客户端操作的key没有分配到该node上时，Redis会返回转向指令，指向正确的node。

首先在Linux中搭建好Redis集群，

redis的三种集群方式

redis有三种集群方式：主从复制，哨兵模式和集群

1.主从复制

主从复制原理:

●从服务器连接主服务器,发送SYNC命令;

●主服务器接收到SYNC命名后,开始执行BGSAVE命令生成RDB文件并使用缓冲区记录此后执行的所有写命令;

●主服务器BGSAVE执行完后,向所有从服务器发送快照文件,并在发送期问继续记录被执行的写命令;

●从服务器收到快照文件后丢弃所有旧数据，载入收到的快照;

●主服务器快照发送完毕后开始向从服务器发送缓冲区中的写命令; .

●从服务器完成对快照的载入,开始接收命令请求,并执行来自主服务器缓冲区的写命令; (从服务器初始化完成)

●主服务器每执行一个写命令就会向从服务器发送相同的写命令,从服务器接收并执行收到的写命令(从服务器初始化完成后的操作)

主从复制优缺点:

优点:

●为了分载Master的读操作压力, Slave服务器可以为客户端提供只读操作的服务,写服务仍然必须由Master来完成

●Slave同样可以接受其它Slaves的连接和同步请求 ,这样可以有效的分载Master的同步压力。

●支持主从复制,主机会自动将数据同步到从机，可以进行读写分离

● Master Server是以非阻塞的方式为Slaves提供服务。所以在Master-Slave同步期间,客户端仍然可以提交查询或修改请求。

●Slave Server同样是以非阻塞的方式完成数据同步。在同步期间，如果有客户端提交查询请求，Redis则返回同步之前的数据

缺点:

●Redis不具备自动容错和恢复功能,主机从机的宕机都会导致前端部分读写清求失败,需要等待机器重启或者手动切换前端的IP才能恢复。

●主机宕机,宕机前有部分数据未能及时同步到从机,切换IP后还会引入数据不一致的问题 ,降低了系统的可用性。

●Redis较难支持在线扩容,在集群容量达到上限时在线扩容会变得很复杂。

2.哨兵模式

当主服务器中断服务后,可以将一个从服务器升级为主服务器,以便继续提供服务,但是这个过程需要人工手动来操作。为此, Redis2.8中提供了哨兵工具来实现自动化的系统监控和故障恢复功能。

哨兵的作用就是监控Redis系统的运行状况。它的功能包括以下两个。

(1)监控主服务器和从服务器是否正常运行，

(2)主服务器出现故障时自动将从服务器转换为主服务器。

哨兵模式的优缺点

优点:

●哨兵模式是基于主从模式的,所有主从的优点,哨兵模式都具有。

●主从可以自动切换,系统更健壮,可用性更高。

缺点:

●Redis较难支持在线扩容,在集群容量达到上限时在线扩容会变得很复杂。

3.Redis-Cluster集群

redis的哨兵模式基本已经可以实现高可用,读写分离, 但是在这种模式下每台redis服务器都存储相同的数据,很浪费内存,所以在redis3.0上加入了cluster模式,实现的redis的分布式存储,也就是说每台redis节点上存储不同的内容。

Redis-Cluster采用无中心结构,它的特点如下:

●所有的redis节点彼此互联(PING-PONG机制),内部使用二进制协议优化传输速度和带宽.

●节点的fail是通过集群中超过半数的节点检测失效时才生效。

●客户端与redis节点直连,不需要中间代理层,客户端不需要连接集群所有节点，连接集群中任何一个可用节点即可。

工作方式:

在redis的每一个节点上, 都有这么两个东西, 一个是插槽(slot) ,它的的取值范围是:0-16383, 还有一个就是cluster ,可以理解为是-个集群管理的播件。当我们的存取的key到达的时候, redis会根据crc16的算法得出一个结果, 然后把结果对16384求余数,这样每个key都会对应一个编号在0-16383之间的哈希槽,通过这个值,去找到对应的插槽所对应的节点,然后直接自动跳转到这个对应的节点上进行存取操作。

为了保证高可用, redis-cluster体群引入了主从模式，一个主节点对应一个或者多个从节点,当主节点宕机的时候,就会启用从节点。当其它主节点ping一个主节点A时,如果半数以上的主节点与A通信超时,那么认为主节点A宕机了。如果主节点A和它的从节点A1都宕机了,那么该集群就无法再提供服务了。

开始搭建-redis版本5.0.9

在redis的安装目录下创建一个存放集群的文件夹，比如我建的是rediscluster

mkdir -p rediscluster

接着进入到rediscluster这个文件夹中创建7000——7005这六个文件夹，用来模拟集群中6个节点

mkdir -p 7000 7001 7002 7003 7004 7005

然后，把redis安装目录下的redis.conf分别复制进刚创建的6个文件夹中。（建议用最原始的redis.conf，而不是改动过的，因为要改的地方比较多，所以干脆直接在redis.conf里追加）

修改每个节点里的redis.conf，参考下面的，直接复制粘贴进去后，改改端口就行，比如有的是7000，有的端口是7001，还有那个bind的ip，改成你自己的

bind 192.168.56.15
protected-mode no
port 7000
daemonize yes
pidfile /var/run/redis_7000.pid
dir /opt/software/redis-5.0.9/rediscluster/7000/
appendonly yes
cluster-enabled yes
cluster-config-file nodes-7000.conf
cluster-node-timeout 5000
masterauth 123456
requirepass 123456

接着就是启动6个redis服务器

./redis-server ../rediscluster/7000/redis.conf

接着启动 Redis Cluster 集群

./redis-cli --cluster create 192.168.56.15:7000 192.168.56.15:7001 192.168.56.15:7002 192.168.56.15:7003 192.168.56.15:7004 192.168.56.15:7005 --cluster-replicas 1 -a 123456

然后就是验证集群的高可用性，

可以用以下命令让7000端口的redis宕机，看其他redis节点还能不能正常访问，正常存值取值。

./redis-cli -h 192.168.56.15  -a 123456 -c -p 7000 shutdown

查看集群中所有节点的情况，

cluster nodes

刚开始6个节点都是启动状态，7000，7001，7002是从机，7003，7004，7005是主机

干掉了从机 7000

干掉主机7005

7002变成了主机

然后干掉7001

再干到7002

然后就不行了

springboot访问Redis集群

data-redis依赖啥的要有。然后在application.yml里配置redis相关

# Redis连接信息
#spring.data.redis.host=192.168.56.15
spring.data.redis.database=0
spring.data.redis.cluster.nodes=192.168.56.15:7000,192.168.56.15:7001,192.168.56.15:7002,192.168.56.15:7003,192.168.56.15:7004,192.168.56.15:7005
spring.data.redis.password=123456

# Redis连接池设置
spring.data.redis.pool.max-active=8 # 最大活动连接数
spring.data.redis.pool.max-idle=8 # 最大空闲连接数
spring.data.redis.pool.min-idle=0 # 最小空闲连接数
spring.data.redis.timeout=3000

单元测试

@SpringBootTest
public class RedisCluster {
    @Autowired
    StringRedisTemplate stringRedisTemplate;
    @Test
    void test(){
        stringRedisTemplate.opsForValue().set("redis_cluster","hello");
        System.out.println(stringRedisTemplate.opsForValue().get("redis_cluster"));
    }
}

然后把6个redis服务器中宕机几个，看看还能不能正常存数据取数据

分布式锁

普通业务减库存操作

@RestController
public class StockController {
    @Autowired
    StringRedisTemplate stringRedisTemplate;
    @RequestMapping("/deduct_stock")
    public String deductStock(){
        Integer stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
        if(stock >0){
            stock--;
            stringRedisTemplate.opsForValue().set("stock",stock+"");
            System.out.println("扣减成功，剩余库存："+stock);
        }else{
            System.out.println("扣减失败，库存不足");
        }

        return "end";
    }

}

存在超卖问题-单体项目解决

高并发场景下库存出现超卖情况，那么采用同步加锁的方式

  @RequestMapping("/deduct_stock")
    public String deductStock(){
        synchronized (this){
            Integer stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
            if(stock >0){
                stock--;
                stringRedisTemplate.opsForValue().set("stock",stock+"");
                System.out.println("扣减成功，剩余库存："+stock);
            }else{
                System.out.println("扣减失败，库存不足");
            }
        }


        return "end";
    }

分布式集群项目解决

如果是分布式项目，集群项目的话，sync同步是JVM进程级别锁，在集群环境下，每一个tomcat就是一个JVM进程，此时将不起作用

使用redis实现分布式锁，setnx命令，springboot中使用setIfAbsent命令，返回boolean类型，如果是true则表示set值成功

在Redis中，`setnx`是一个命令，用于设置一个键值对，但只有在键不存在时才会设置成功。如果键已经存在，则不会进行任何操作。

具体来说，`setnx`命令的语法如下：

setnx key value

其中，`key`是要设置的键的名称，`value`是要设置的值。如果键不存在，则会将`key`和`value`关联起来，并返回1。如果键已经存在，则不会进行任何操作，并返回0。

`setnx`命令通常用于实现分布式锁。在使用`setnx`命令实现分布式锁时，多个客户端可以同时尝试获取锁，只有一个客户端能够获取到锁，并且在获取到锁的过程中，其他客户端无法获取到锁。这种方式可以确保在分布式系统中，只有一个客户端可以访问共享资源，从而避免了竞态条件和死锁等问题。

当第一个进程进来接口，先set一把锁，下一个进程进来后，执行同样的命令那么会返回false。就直接返回错误！但依然存在问题！

 @RequestMapping("/deduct_stock")
    public String deductStock(){
        Boolean result = stringRedisTemplate.opsForValue().setIfAbsent("lockKey", "jf3q");
        if (!result) {
            return "error";
        }


        Integer stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
        if(stock >0){
            stock--;
            stringRedisTemplate.opsForValue().set("stock",stock+"");
            System.out.println("扣减成功，剩余库存："+stock);
        }else{
            System.out.println("扣减失败，库存不足");
        }
        return "end";
    }

解决第一个问题，当代码正常执行完了之后就要释放锁！但是还有问题！

@RequestMapping("/deduct_stock")
    public String deductStock(){
        String lockKey="product_001";
        Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, "jf3q");
        if (!result) {
            return "error";
        }


        Integer stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
        if(stock >0){
            stock--;
            stringRedisTemplate.opsForValue().set("stock",stock+"");
            System.out.println("扣减成功，剩余库存："+stock);
        }else{
            System.out.println("扣减失败，库存不足");
        }
        //释放锁
        stringRedisTemplate.delete(lockKey);
        return "end";
    }

解决第二个问题，加锁后抛了异常造成锁释放的代码没有执行，就会出现死锁使用finally模块来释放锁。但还是有问题！

@RequestMapping("/deduct_stock")
    public String deductStock(){
        String lockKey="product_001";

        try {
            Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, "jf3q");

            if (!result) {
                return "error";
            }
            Integer stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
            if(stock >0){
                stock--;
                stringRedisTemplate.opsForValue().set("stock",stock+"");
                System.out.println("扣减成功，剩余库存："+stock);
            }else{
                System.out.println("扣减失败，库存不足");
            }
        } finally {
            //释放锁
            stringRedisTemplate.delete(lockKey);
        }
        return "end";
    }

解决第三个问题，如果在执行减库存的业务逻辑时，服务器宕机了，或者kill-9杀了服务器进程，finally模块还是不会执行，依然会造成死锁，那么给这个锁加一个自动过期时间，比如10秒钟之后自动释放！但还是有问题！

解决第四个问题，如果在24，25行代码执行中间出现了异常，那么失效时间设置没有成功，则采用合并命令，让他们同时执行要不都成功，要不都失败！但还是有问题！

第5个问题，高并发场景下，可能会出现当前线程未执行完毕，但锁已经失效，然后当线程执行完了之后删除锁的时候是删除的下一个线程加的锁。

解决第五个问题，给锁的value值设置一个UUID随机数，删除锁之前判断一下，是自己的锁，才去删除！但还是有问题，如果业务没有执行完，锁就超时失效了，怎么办？

解决第六个问题，当主线程设置锁成功后，马上开启分线程，让分线程写定时任务去查询当前锁是否存在，如果存在的话，给他再蓄力10S过期失效时间，直到他被删除为止。就证明程序执行完毕。一般定时任务为过期时间的3分之1

最终解决方案：使用redisson客户端添加redisson依赖

<dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-boot-starter</artifactId>
            <version>3.23.1</version>
        </dependency>

初始化redisson连接

 @Bean
    public Redisson redisson(){
        Config config=new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379").setDatabase(0).setPassword("123456");
        return (Redisson)Redisson.create(config);

    }

redisson客户端，lock方法上锁之后，其他的进程进来后会阻塞，不会往下继续执行，当主线程执行完了之后才会继续往下执行。并且会自动延迟锁的时间。

 @Autowired
    Redisson redisson;
    @RequestMapping("/deduct_stock")
    public String deductStock(){
        String lockKey="product_001";
        String clientId = UUID.randomUUID().toString();
        RLock redissonLock = redisson.getLock(lockKey);
        try {
//            Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, clientId,10, TimeUnit.SECONDS);
//            if (!result) {
//                return "error";
//            }

            redissonLock.lock(30,TimeUnit.SECONDS);
            Integer stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
            if(stock >0){
                stock--;
                stringRedisTemplate.opsForValue().set("stock",stock+"");
                System.out.println("扣减成功，剩余库存："+stock);
            }else{
                System.out.println("扣减失败，库存不足");
            }
        } finally {
            redissonLock.unlock();
//            if(clientId.equals(stringRedisTemplate.opsForValue().get(lockKey))){
//                //释放锁
//                stringRedisTemplate.delete(lockKey);
//            }

        }
        return "end";
    }