springboot中redis的基本用法

前言：springboot和redis一起使用特别方便！

maven配置

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

添加配置文件：

# Redis数据库索引（默认为0）
spring.redis.database=0  
# Redis服务器地址
spring.redis.host=localhost
# Redis服务器连接端口
spring.redis.port=6379  
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制） 默认 8
spring.redis.lettuce.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
spring.redis.lettuce.pool.max-wait=-1
# 连接池中的最大空闲连接 默认 8
spring.redis.lettuce.pool.max-idle=8
# 连接池中的最小空闲连接 默认 0
spring.redis.lettuce.pool.min-idle=0

操作redis:

使用springboot对redis的默认实现：

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

springboot------------redis   -----
         ---设置key 过期时间----过期即被删除消失
-----StringRedisTemplate  -----正常的形式------可读
---RedisTemplate ----------key和value都会被序列化，不可读
 string类型可以直接存储对象--序列化字节数组，存入redis数据库-不可读
-----以上两个是对redis数据的操作---序列化方式不同

redisTemplate.opsForValue();//操作字符串
redisTemplate.opsForHash();//操作hash
redisTemplate.opsForList();//操作list
redisTemplate.opsForSet();//操作set
redisTemplate.opsForZSet();//操作有序set
            ----------session共享



            -------redis数据结构
            字符串  （String）
            哈希    （Hash）
            列表    （List）
            集合    （Set）
            有序集合（sorted set）

结构类型	结构存储的值	结构的读写能力
String	可以是字符串、整数或者浮点数	对整个字符串或者字符串的其中一部分执行操作；对象和浮点数执行自增(increment)或者自减(decrement)
List	一个链表，链表上的每个节点都包含了一个字符串	从链表的两端推入或者弹出元素；根据偏移量对链表进行修剪(trim)；读取单个或者多个元素；根据值来查找或者移除元素
Set	包含字符串的无序收集器(unorderedcollection)，并且被包含的每个字符串都是独一无二的、各不相同	添加、获取、移除单个元素；检查一个元素是否存在于某个集合中；计算交集、并集、差集；从集合里卖弄随机获取元素
Hash	包含键值对的无序散列表	添加、获取、移除单个键值对；获取所有键值对
Zset	字符串成员(member)与浮点数分值(score)之间的有序映射，元素的排列顺序由分值的大小决定	添加、获取、删除单个元素；根据分值范围(range)或者成员来获取元素

set(K key, V value)

  新增一个字符串类型的值，key是键，value是值。

get(Object key)

  获取key键对应的值。

    @Test
    public void redis_string(){
        stringRedisTemplate.opsForValue().set("hello_redis_string","hello_redis_string");
        String s = stringRedisTemplate.opsForValue().get("hello_redis_string");
        System.out.println(s);
    }

 输出结果为：hello_redis_string  string类型的存储。一个key,一个value，适合做验证码之类的业务需求

可视化工具可以看出：

set(K key, V value, long timeout, TimeUnit unit)      设置变量值的过期时间。

下面例子将code的过期时间设置为2秒

 stringRedisTemplate.opsForValue().set("code","hello",2, TimeUnit.SECONDS);

 append(K key, String value)

在原有的值基础上新增字符串到末尾。

  @Test
    public void redis_str001(){
        Integer hello_redis_string = stringRedisTemplate.opsForValue().append("hello_redis_string", "appdend......");
        System.out.println(hello_redis_string);
    }

以上事例便是string字符串的常用用法

stringRedisTemplate.opsForList();

leftPush(K var1, V var2)  从左边添加

rightPush(K var1, V var2) 从右边添加

leftPop(K var1)           从左边弹出

rightPop(K var1)          从右边弹出

还有一些pushAll的操作不再赘述

  @Test
    public void redis_list(){
        for (int i=0;i<10;i++){
            stringRedisTemplate.opsForList().leftPush("list_string","list_"+Integer.toString(i));
        }
    }

上面的效果就是一个列表，可以用作消息队列，生产者消费者模式；

index(K key, long index)

  获取集合指定位置的值。

range(K key, long start, long end)

获取指定区间的值。

size(K key)

获取集合长度。

trim(K key, long start, long end)

  截取集合元素长度，保留长度内的数据。

  @Test
    public void testwwerwlist(){
        Long size = stringRedisTemplate.opsForList().size("list_string");
        System.out.println("size="+size);

        String s = stringRedisTemplate.opsForList().index("list_string", 0);
        System.out.println("index="+s);

        List<String> all = stringRedisTemplate.opsForList().range("list_string", 0, size);
        System.out.println("all="+all);

        List<String> list_string = stringRedisTemplate.opsForList().range("list_string", 2, 4);
        System.out.println("range="+list_string);

        stringRedisTemplate.opsForList().trim("list_string",2,4);

        List<String> trime_list = stringRedisTemplate.opsForList().range("list_string", 0, size);
        System.out.println("trime_list="+trime_list);
    }

运算效果如下：

size=10
index=list_9
all=[list_9, list_8, list_7, list_6, list_5, list_4, list_3, list_2, list_1, list_0]
range=[list_7, list_6, list_5]
trime_list=[list_7, list_6, list_5]

 set

add(K key, V... values)

  向变量中批量添加值。

members(K key)

  获取变量中的值。

size(K key)

   获取变量中值的长度。

randomMember(K key)

   随机获取变量中的元素

randomMembers(K key, long count)

  随机获取变量中指定个数的元素

isMember(K key, Object o)

  检查给定的元素是否在变量中

pop(K key)

   弹出变量中的元素（随机）

pop(K var1, long var2)

   弹出变量中的元素（随机弹出几个）

特别说明：redis中的数据结构和java数据结构类似，list可以重复，set不重复，随机添加和弹出

 @Test
    public void redis_set(){
        for (int i=0;i<10;i++){
            stringRedisTemplate.opsForSet().add("set_string","list_"+Integer.toString(i));
        }
    }

    @Test
    public void sadfaataest(){
        stringRedisTemplate.opsForSet().add("set_string","hahah哈","哈哈认为");
        Set<String> string = stringRedisTemplate.opsForSet().members("set_string");
        System.out.println("members="+string);
        Long size = stringRedisTemplate.opsForSet().size("set_string");
        System.out.println("size="+size);
        String randomMember = stringRedisTemplate.opsForSet().randomMember("set_string");
        System.out.println("randomMember="+randomMember);
        List<String> randomMembers = stringRedisTemplate.opsForSet().randomMembers("set_string",5);
        System.out.println("randomMembers="+randomMembers);

        Boolean isMember = stringRedisTemplate.opsForSet().isMember("set_string", "hahah哈");
        System.out.println("isMember="+isMember);
        String set_string = stringRedisTemplate.opsForSet().pop("set_string");
        System.out.println(set_string);

        List<String> set_string1 = stringRedisTemplate.opsForSet().pop("set_string", 4);

        System.out.println("pop_l"+set_string1);
    }

效果如下

members=[list_7, list_2, list_5, list_8, list_0, list_4, list_3, 哈哈认为, list_9, list_6, hahah哈, list_1]
size=12
randomMember=list_5
randomMembers=[list_3, list_8, list_4, list_8, list_8]
isMember=true
pop=list_4
pop_l[hahah哈, list_7, list_1, list_5]

put(H key, HK hashKey, HV value)

   新增hashMap值。

values(H key)

  获取指定变量中的hashMap值。

entries(H key)

  获取变量中的键值对

get(H key, Object hashKey)

  获取变量中的指定map键是否有值,如果存在该map键则获取值，没有则返回null 获取field的value数值

hasKey(H key, Object hashKey)

      判断变量中是否有指定的map键

keys(H key)

       获取变量中的键

size(H key)

        获取变量的长度

multiGet(H key, Collection<HK> hashKeys)

以集合的方式获取变量中的值

scan(H key, ScanOptions options)

            匹配获取键值对，ScanOptions.NONE为获取全部键对，ScanOptions.scanOptions().match("map1").build()     匹配获取键位map1的键值对,不能模糊匹配。

delete(H key, Object... hashKeys)

   删除变量中的键值对，可以传入多个参数，删除多个键值对。

  @Test
    public void fadsfasf(){
        Map<Object, Object> entries = stringRedisTemplate.opsForHash().entries("hash_string");
        System.out.println("entries="+entries);
        Set<Object> keys = stringRedisTemplate.opsForHash().keys("hash_string");
        System.out.println("keys="+keys);
        List<Object> values = stringRedisTemplate.opsForHash().values("hash_string");
        System.out.println("values="+values);
        Long size = stringRedisTemplate.opsForHash().size("hash_string");
        System.out.println("size="+size);

        Boolean hasKey = stringRedisTemplate.opsForHash().hasKey("hash_string", "6");
        System.out.println("hasKey="+hasKey);

        Object get = stringRedisTemplate.opsForHash().get("hash_string", "6");
        System.out.println("get="+get);
        
        List<Object> multiGet = stringRedisTemplate.opsForHash().multiGet("hash_string", keys);
        System.out.println("multiGet="+multiGet);

        Long delete = stringRedisTemplate.opsForHash().delete("hash_string", "3", "4");
        System.out.println("delete="+delete);

        Cursor<Map.Entry<Object, Object>> scan = stringRedisTemplate.opsForHash().scan("hash_string", ScanOptions.scanOptions().match("1").build());
        System.out.println("scan="+JSONObject.toJSONString(scan));
    }

 entries={0=i_0, 3=i_3, 4=i_4, 5=i_5, 6=i_6, 7=i_7, 8=i_8, 9=i_9, 11=232323, 111=232323, 1111=232323}
keys=[0, 3, 4, 5, 6, 7, 8, 9, 11, 111, 1111]
values=[i_0, i_3, i_4, i_5, i_6, i_7, i_8, i_9, 232323, 232323, 232323]
size=11
hasKey=true
get=i_6
multiGet=[i_0, i_3, i_4, i_5, i_6, i_7, i_8, i_9, 232323, 232323, 232323]
delete=2
scan={"closed":false,"cursorId":0,"position":0}

Boolean add(K key, V value, double score);
新增一个有序集合，存在的话为false，不存在的话为true

Long remove(K key, Object... values);
从有序集合中移除一个或者多个元素

Double incrementScore(K key, V value, double delta);
增加元素的score值，并返回增加后的值

Long rank(K key, Object o);
返回有序集中指定成员的排名，其中有序集成员按分数值递增(从小到大)顺序排列

Long reverseRank(K key, Object o);
返回有序集中指定成员的排名，其中有序集成员按分数值递减(从大到小)顺序排列 

Set<V> range(K key, long start, long end);
通过索引区间返回有序集合成指定区间内的成员，其中有序集成员按分数值递增(从小到大)顺序排

Set<V> rangeByScore(K key, double min, double max);
通过分数返回有序集合指定区间内的成员，其中有序集成员按分数值递增(从小到大)顺序排列

Long size(K key);

Long zCard(K key);
获取有序集合的成员数

Double score(K key, Object o);
获取指定成员的score值

        //索引 start end
        Set<String> zSet_string = stringRedisTemplate.opsForZSet().range("zSet_string", 3,6);
        System.out.println("zSet_string="+zSet_string);
        stringRedisTemplate.opsForZSet().count("zSet_string",3,3);
        //删除   value
        Long remove = stringRedisTemplate.opsForZSet().remove("zSet_string", "i_1");
        System.out.println("remove="+remove);

    @Test
    public void fasfdasf(){
        //索引  0  -1   查询全部
        //     0   5   从0----5  包含边界
        Set<String> range = stringRedisTemplate.opsForZSet().range("zSet_string", 0,-1);
        System.out.println("rang="+range);
        Set<String> rang5 = stringRedisTemplate.opsForZSet().range("zSet_string", 0,5);
        System.out.println("rang5="+rang5);
        Set<String> range_1 = stringRedisTemplate.opsForZSet().range("zSet_string", 1, 1);
        System.out.println("range_1="+range_1);
        Long size = stringRedisTemplate.opsForZSet().size("zSet_string");
        System.out.println("size="+size);

        Long zCard = stringRedisTemplate.opsForZSet().zCard("zSet_string");
        System.out.println("zCard="+zCard);

        //索引倒序排列指定区间元素。  先倒叙，再按照倒叙的索引进行区间查询
        Set<String> reverseRange = stringRedisTemplate.opsForZSet().reverseRange("zSet_string", 5, 10);
        System.out.println("reverseRange="+reverseRange);

        Set<String> rangeByScore = stringRedisTemplate.opsForZSet().rangeByScore("zSet_string", 5, 10);
        System.out.println("rangeByScore="+rangeByScore);

    }

运行效果如下：

rang=[i_0, i_2, i_3, i_4, i_5, i_6, i_7, i_8, i_9, i_10, i_11, i_12, i_13, i_14, i_15, i_16, i_17, i_18, i_19, i_20, i_21, i_22, i_23, i_24, i_25, i_26, i_27, i_28, i_29, i_30, i_31, i_32, i_33, i_34, i_35, i_36, i_37, i_38, i_39, i_40, i_41, i_42, i_43, i_44, i_45, i_46, i_47, i_48, i_49, i_50, i_51, i_52, i_53, i_54, i_55, i_56, i_57, i_58, i_59, i_60, i_61, i_62, i_63, i_64, i_65, i_66, i_67, i_68, i_69, i_70, i_71, i_72, i_73, i_74, i_75, i_76, i_77, i_78, i_79, i_80, i_81, i_82, i_83, i_84, i_85, i_86, i_87, i_88, i_89, i_90, i_91, i_92, i_93, i_94, i_95, i_96, i_97, i_98, i_99]
rang5=[i_0, i_2, i_3, i_4, i_5, i_6]
range_1=[i_2]
size=99
zCard=99
reverseRange=[i_94, i_93, i_92, i_91, i_90, i_89]
rangeByScore=[i_5, i_6, i_7, i_8, i_9, i_10]

如有不解，请加java爱好群大家交流：852665736；群里都是热心好客的小伙伴，大家一同进步。

无偿免费分享源码以及技术和面试文档，更多优秀精致的源码技术栈分享请关注微信公众号：gh_817962068649