SpringBoot使用Redis

Posted on 2024-01-21 In 编程 , Java , SpringBoot , Redis Waline:

[!NOTE]

本教程是《SpringBoot系列基础教程》之一，教程目录：https://laisc7301.github.io/blog/2024/01/29/202401290001SpringBoot%E7%B3%BB%E5%88%97%E5%9F%BA%E7%A1%80%E6%95%99%E7%A8%8B/

首先按照图示新建项目：

添加以下依赖：

找到application.properties文件，并写入下面内容：

server.port=8001

spring.redis.host=localhost
spring.redis.port=6379
spring.redis.password=
spring.redis.database=0


#也可以写成下面这样：
#spring:
#redis:
#host: localhost
#port: 6379
#password:
#database: 0

整个项目的文件结构如下图所示：

贴出代码，代码里注释写得比较多，就不解释太多了。

TestController.java

package com.laisc.example5.controller;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Controller
@RequestMapping("/test")
public class TestController {

    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @ResponseBody
    @RequestMapping("/setvalue1")
    public String setValue1() { //使用JDK序列化策略设置键
        redisTemplate.opsForValue().set("测试1", "测试123");
        String out = redisTemplate.opsForValue().get("测试1").toString();
        return out;
    }

    @ResponseBody
    @RequestMapping("/setmapvalue")
    public String setMapValue() { //使用JDK序列化策略设置键
        Map<String, String> map = new HashMap<>();
        map.put("aaa", "bbb");
        map.put("ccc", "ddd");
        redisTemplate.opsForValue().set("map1", map); //直接存储Map对象
        String out = redisTemplate.opsForValue().get("map1").toString();
        return out;
    }

    @ResponseBody
    @RequestMapping("/setvalue2")
    public String setValue2() { //使用String序列化策略设置键
        stringRedisTemplate.opsForValue().set("测试2", "测试1234");
        String out = stringRedisTemplate.opsForValue().get("测试2");
        return out;
    }
    /*
     * RedisTemplate和StringRedisTemplate的区别：
     * 两者的关系是StringRedisTemplate继承RedisTemplate。
     * 两者的数据是不共通的；也就是说StringRedisTemplate只能管理StringRedisTemplate里面的数据，RedisTemplate只能管理RedisTemplate中的数据，包括删除操作。
     * SDR默认采用的序列化策略有两种，一种是String的序列化策略，一种是JDK的序列化策略。
     * 使用场景：
     * StringRedisTemplate：当你的redis数据库里面本来存的是字符串数据或者你要存取的数据就是字符串类型数据的时候。
     * RedisTemplate：但是如果你的数据是复杂的对象类型，而取出的时候又不想做任何的数据转换，直接从Redis里面取出一个对象。
     */

    @ResponseBody
    @RequestMapping("/setvalue3")
    public String setValue3() { //使用String序列化策略设置键，并设置过期时间
        stringRedisTemplate.opsForValue().set("测试3", "测试12345", 3600, TimeUnit.SECONDS);//设置过期时间为3600秒
        String out = stringRedisTemplate.opsForValue().get("测试3");
        return out;
    }

    @ResponseBody
    @RequestMapping("/setexpire")
    public boolean setExpire() { //设置过期时间
        return stringRedisTemplate.expire("测试2", 3600, TimeUnit.SECONDS);//设置过期时间为3600秒
        /*
         * expire(String key, long timeout, TimeUnit unit)
         * 该方法用于设置过期时间
         * 当该键存在并且没有设置过期时间时，将设置过期时间并返回true
         * 当该键存在并且有过期时间时，将覆盖原来的过期时间并返回true
         * 当该键不存在时，返回false
         */
    }

    @ResponseBody
    @RequestMapping("/persist")
    public boolean persist() {// 移除过期时间
        return stringRedisTemplate.boundValueOps("测试3").persist();
        /*
         * persist()
         * 当存在过期时间并且已清除时，返回true
         * 当键不存在过期时间或找不到该键时，返回false
         */
    }


    @ResponseBody
    @RequestMapping("/haskey")
    public boolean hasKey() { //查看键是否存在
        return stringRedisTemplate.hasKey("测试2");
    }

    @ResponseBody
    @RequestMapping("/del")
    public String del() { //删除值
        String out = stringRedisTemplate.delete("测试2").toString();
        return out;
        /*
         * delete(String key)
         * 该方法用来删除值
         * 当值存在，删除并返回true
         * 当值不存在，返回false
         */
    }

    @RequestMapping("/addset")
    @ResponseBody
    public String addSet() { //添加Set集合
        SetOperations<String, String> set = stringRedisTemplate.opsForSet();
        set.add("myset", "22");
        set.add("myset", "33");
        set.add("myset", "44");
        Set<String> resultSet = stringRedisTemplate.opsForSet().members("myset");
        return resultSet.toString();
    }

    @RequestMapping("/addset2")
    @ResponseBody
    public String addSet2() { //批量添加Set集合
        stringRedisTemplate.opsForSet().add("myset", "1", "2", "3");//向指定key中存放set集合
        Set<String> resultSet1 = stringRedisTemplate.opsForSet().members("myset");
        return resultSet1.toString();
    }

    /*
     * 当插入的Set元素重复时，会自动跳过重复的元素。
     */


    @RequestMapping("/addvalue")
    @ResponseBody
    public String addValue() {
        Long mycounter = stringRedisTemplate.boundValueOps("counter").increment(1);//先将counter累加1并更新到Redis，然后把累加后的值返回给mycounter
        return mycounter.toString();
    }

    @RequestMapping("/getexpire")
    @ResponseBody
    public String getExpire() {
        Long time = stringRedisTemplate.getExpire("测试3"); //返回当前key所对应的剩余过期时间，单位为秒
        return time.toString();
        /*
         * getExpire(String key)
         * 返回当前key所对应的剩余过期时间
         * 当返回值为-1，表示永不过期
         * 当返回值为-2，表示不存在该键
         */
    }


    @ResponseBody
    @RequestMapping("/listpush")
    public String listPush() { //将一些值插入列表中。
        // leftPush依次向右边添加
        stringRedisTemplate.opsForList().rightPush("myList", "1");
        stringRedisTemplate.opsForList().rightPush("myList", "2");
        stringRedisTemplate.opsForList().rightPush("myList", "A");
        stringRedisTemplate.opsForList().rightPush("myList", "B");
        stringRedisTemplate.opsForList().rightPush("myList", "C");
        // leftPush依次向左边添加
        stringRedisTemplate.opsForList().leftPush("myList", "0");
        return "ok";
    }


    @RequestMapping("/getlist")
    @ResponseBody
    public String GetList() { // 查询列表中的元素
        // 查询类别所有元素
        List<String> listAll = stringRedisTemplate.opsForList().range("myList", 0, -1);
        // 查询前3个元素
        List<String> list = stringRedisTemplate.opsForList().range("myList", 0, 3);
        return "listAll=" + listAll.toString() + "  list=" + list.toString();
    }


    @RequestMapping("/listremove")
    @ResponseBody
    public String listRemove() { // 删除列表中的元素
        // 删除从右到左前2个值为'B'的元素；
        stringRedisTemplate.opsForList().remove("myList", -2, "B");
        return "ok";
        /*
         * remove(String key, long count,Object value)
         * 从存储在键中的列表中删除等于值的元素的第一个计数事件。
         * count > 0：删除从左到右前count个符合条件的元素；
         * count < 0：删除从右到左前|count|个符合条件的元素；
         * count = 0：删除等于value的所有元素。
         */
    }


    /*
     *下面将讲解Redis中的哈希表，哈希表其实就是Java里面的Map。
     */

    @RequestMapping("/hashput")
    @ResponseBody
    public String hashPut() { //添加哈希键值对
        stringRedisTemplate.opsForHash().put("mytest:test1", "a", "b");
        stringRedisTemplate.opsForHash().put("mytest:test1", "c", "d");
        stringRedisTemplate.opsForHash().put("mytest:test1", "e", "f");
        return "ok";
        /*
         * put(String key, Object hashKey, Object value)
         * key 是哈希表名
         * hashKey 就是Map里的key，value 就是Map里的value
         * 当 hashKey 相同，后添加的将覆盖原有的。
         */
    }


    @RequestMapping("/hashget")
    @ResponseBody
    public String hashGet() { //获取哈希键值对
        Map<Object, Object> map = stringRedisTemplate.opsForHash().entries("mytest:test1");
        return map.toString();
    }


    @RequestMapping("/hashdel")
    @ResponseBody
    public String hashDelete() { //删除哈希表里的元素
        stringRedisTemplate.opsForHash().delete("mytest:test1", "a", "e");
        return "ok";
        /*
         * delete(String key, Object... hashKeys)
         * 根据key 和 hashKeys 删除元素
         * key 是哈希表名
         * hashKey 就是Map里的key
         */
    }


    @RequestMapping("/hashgetkeys")
    @ResponseBody
    public String hashGetKeys() { //获取哈希表里的key集合
        Set<Object> objects = stringRedisTemplate.opsForHash().keys("mytest:test1");
        return objects.toString();
    }

    @RequestMapping("/hashgetvaluelist")
    @ResponseBody
    public String hashGetValueList() { //获取哈希表里的value列表
        List<Object> objects = stringRedisTemplate.opsForHash().values("mytest:test1");
        return objects.toString();
    }

    @RequestMapping("/hashsize")
    @ResponseBody
    public String hashSize() {// 获取哈希表大小
        // 获取map对象大小
        long size = stringRedisTemplate.opsForHash().size("mytest:test1");
        return String.valueOf(size);
    }
}

项目源代码下载：https://pan.baidu.com/s/1sxrkiyjnCiUPEgCaRCsgtA?pwd=9z5e

上一篇：SpringBoot使用MongoDB：https://laisc7301.github.io/blog/2024/01/12/202401120000SpringBoot%E4%BD%BF%E7%94%A8MongoDB/