Redis 相关操作

背景

晚上学习了下redis，有很多特定语法，特地记录

redis官网地址：www.redis.net.cn

分类

redis存储的是key，value格式的数据，其中key都是字符串，value有5种不同的数据结构

字符串类型

String

存储：set key value

获取： get key

删除： del key

存储并设置过期时间：setex key seconds value

key不存在时才能存储： setnx key value

# 设置张三姓名
127.0.0.1:6379> set name zhangsan 
OK 

# 获取名字
127.0.0.1:6379> get name
"zhangsan" 

# 删除名字
127.0.0.1:6379> del name 
(integer) 1 

# 删除成功
127.0.0.1:6379> get name
(nil)

哈希类型

hash : map格式

存储 ：hset key field value

获取： hget key field

获取所有的 key 和 value：hgetall key

删除： hdel key field

获取哈希表中所有字段： hkeys key

获取哈希表所有值： hvals key

# 在 myhash 组中设置性别为男
127.0.0.1:6379> hset myhash sex nan 
(integer) 1 

# 在 myhash 组中设置名字为tom
127.0.0.1:6379> hset myhash name tom
(integer) 1

# 在 myhash 组中修改性别为男=女
127.0.0.1:6379> hset myhash sex nv
(integer) 0

# 性别修改成功
127.0.0.1:6379> hget myhash sex
"nv"

# 在myhash组中获取姓名
127.0.0.1:6379> hget myhash name
"tom"

# 获取myhash组中的键值对
127.0.0.1:6379> hgetall myhash
1) "sex" 
2) "nv" 
3) "name" 
4) "tom"

列表类型

list : linkedlist格式，支持重复元素，可以添加一个元素到列表的头部或者尾部

添加：

从列表左边加入：lpush key value1 [value2]

右边：rpush key value

获取：lrange key start end:范围获取

删除：lpop key:删除列表最左边的元素，并将元素返回

rpop key: 删除列表最右边的元素，并将元素返回

获取列表长度： llen key

# 在mylist列表中，左侧添加a ----> a
127.0.0.1:6379> lpush mylist a 
(integer) 1 

# 在mylist列表中，左侧添加b ----> b a
127.0.0.1:6379> lpush mylist b 
(integer) 2 

# 在mylist列表中，右侧添加c ----> b a c
127.0.0.1:6379> rpush mylist c 
(integer) 3 

# 在mylist列表中，右侧添加d ----> b a c d
127.0.0.1:6379> rpush mylist d 
(integer) 4 

# 显示mylist列表中所有内容
127.0.0.1:6379> lrange mylist 0 -1 
1) "b" 
2) "a" 
3) "c" 
4) "d" 

127.0.0.1:6379> lpop mylist 
"b" 

127.0.0.1:6379> rpop mylist 
"d" 

集合类型

set : 不允许重复元素

存储：sadd key value

获取：smembers key:获取set集合中所有元素

删除：srem key value:删除set集合中的某个元素

获取成员数： scard key

返回所有集合的交集： sinter key1 [key2]

返回所有集合的并集： sunion key1 [key2]

删除集合中的一个或者多个成员： srem key menber1 [menber2]

# 在myset集合中，添加b
127.0.0.1:6379> sadd myset b 
(integer) 1 

# 在myset集合中，添加c
127.0.0.1:6379> sadd myset c 
(integer) 1 

# 在myset集合中，添加a
127.0.0.1:6379> sadd myset a 
(integer) 1 

 # 在myset集合中，再次添加b
127.0.0.1:6379> sadd myset b 
(integer) 0

# 显示myset集合内容
127.0.0.1:6379> SMEMBERS myset 
1) "b" 
2) "c" 
3) "a" 

 # 在myset集合中，删除内容b
127.0.0.1:6379> srem myset b 
(integer) 1 

# 显示myset集合内容
127.0.0.1:6379> SMEMBERS myset 
1) "c" 
2) "a"

有序集合类型

sorterdset :不允许重复元素，且元素有顺序

存储：zadd score key value

获取：zrange key start end

删除：zren key value

指定对象加上增量inc : zincrby key increment menber

# 在mysort集合中，添加键值对（66，xy）
127.0.0.1:6379> zadd mysort 66 xy 
(integer) 1 

# 在mysort集合中，添加键值对（88，xxxy）
127.0.0.1:6379> zadd mysort 88 xxxy 
(integer) 1 

# 按照key从递增的顺序，依次mysort集合对应的value
127.0.0.1:6379> zrange mysort 0 -1 
1) "xy" 
2) "xxxy" 

# 同时显示key和value
127.0.0.1:6379> zrange mysort 0 -1 withscores 
1) "xy"
2) "66" 
3) "xxxy" 
4) "88"

通用指令

keys * :查询所有的键

exist key: 检查给定key是否存在

type key:获取键对应的value的类型

del key:删除指定的key value

springboot 整合redis

导入依赖

 
    org.springframework.boot
    spring-boot-starter-data-redis 

配置 application.properities

#配置redis
spring.redis.host=127.0.0.1 
spring.redis.port=6379

测试

测试一：String 类操作

package com.example.demo;

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.connection.RedisConnection;
import org.springframework.data.redis.core.RedisTemplate;

import javax.annotation.Resource;

@SpringBootTest
class DemoApplicationTests {

    @Resource
    private RedisTemplate redisTemplate;

    @Test
    void contextLoads() {
        /*
        * 操作不同的数据类型
        * opsForValue 操作字符串 类似String
        * opsForList  操作List 类似List
        * opsForSet
        * opsForHash
        * opsForGeo
        * opsForZSet
        * opsForHyperLogLog
        * */

      
        //除了基本的操作，常用的方法都可以直接通过redisTemplate操作
       /* RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
        connection.flushDb();
        connection.flushAll();*/
        redisTemplate.opsForValue().set("name","xy");
        Object name = redisTemplate.opsForValue().get("name");
        System.out.println(name);
    }

}

测试二：序列化

package com.example.demo.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;

import java.net.UnknownHostException;

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        RedisTemplate template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);

        //json序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer=new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om=new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

        //String的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        template.setKeySerializer(stringRedisSerializer);
        template.setHashKeySerializer(stringRedisSerializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

测试三：使用工具类

package com.example.demo.utils;

import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.io.Serializable;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * Redis 工具类
 */
@Service
public class RedisUtils {
    @Resource

    private RedisTemplate redisTemplate;

    private static double size = Math.pow(2, 32);

    /**
     * 写入缓存
     * @param key
     * @param offset
     * @param isShow
     * @return result
     */
    public boolean setBit(String key, long offset, boolean isShow) {
        boolean result = false;
        try {
            ValueOperations operations = redisTemplate.opsForValue();
            operations.setBit(key, offset, isShow);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 写入缓存
     * @param key
     * @param offset
     * @return result
     */
    public boolean getBit(String key, long offset) {
        boolean result = false;
        try {
            ValueOperations operations = redisTemplate.opsForValue();
            result = operations.getBit(key, offset);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 写入缓存
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 写入缓存设置时效时间
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value, Long expireTime) {
        boolean result = false;
        try {
            ValueOperations operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 批量删除对应的value
     * @param keys
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }

    /**
     * 删除对应的value
     * @param key
     */
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }

    /**
     * 判断缓存中是否有对应的value
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 读取缓存
     * @param key
     * @return
     */
    public Object get(final String key) {
        Object result = null;
        ValueOperations operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }

    /**
     * 哈希 添加
     * @param key
     * @param hashKey
     * @param value
     */
    public void hmSet(String key, Object hashKey, Object value) {
        HashOperations hash = redisTemplate.opsForHash();
        hash.put(key, hashKey, value);
    }

    /**
     * 哈希获取数据
     * @param key
     * @param hashKey
     * @return
     */
    public Object hmGet(String key, Object hashKey) {
        HashOperations hash = redisTemplate.opsForHash();
        return hash.get(key, hashKey);
    }

    /**
     * 列表添加
     * @param k
     * @param v
     */
    public void lPush(String k, Object v) {
        ListOperations list = redisTemplate.opsForList();
        list.rightPush(k, v);
    }

    /**
     * 列表获取
     * @param k
     * @param l
     * @param l1
     * @return
     */
    public List lRange(String k, long l, long l1) {
        ListOperations list = redisTemplate.opsForList();
        return list.range(k, l, l1);
    }

    /**
     * 集合添加
     * @param key
     * @param value
     */
    public void add(String key, Object value) {
        SetOperations set = redisTemplate.opsForSet();
        set.add(key, value);
    }

    /**
     * 集合获取
     * @param key
     * @return
     */
    public Set setMembers(String key) {
        SetOperations set = redisTemplate.opsForSet();
        return set.members(key);
    }

    /**
     * 有序集合添加
     * @param key
     * @param value
     * @param scoure
     */
    public void zAdd(String key, Object value, double scoure) {
        ZSetOperations zset = redisTemplate.opsForZSet();
        zset.add(key, value, scoure);
    }

    /**
     * 有序集合获取
     * @param key
     * @param scoure
     * @param scoure1
     * @return
     */
    public Set rangeByScore(String key, double scoure, double scoure1) {
        ZSetOperations zset = redisTemplate.opsForZSet();
        redisTemplate.opsForValue();
        return zset.rangeByScore(key, scoure, scoure1);
    }


    /**
     * 第一次加载的时候将数据加载到 redis 中
     * @param name
     */
    public void saveDataToRedis(String name) {
        double index = Math.abs(name.hashCode() % size);
        long indexLong = new Double(index).longValue();
        boolean availableUsers = setBit("availableUsers", indexLong, true);
    }

    /**
     * 第一次加载的时候将数据加载到redis中
     * @param name
     * @return
     */
    public boolean getDataToRedis(String name) {
        double index = Math.abs(name.hashCode() % size);
        long indexLong = new Double(index).longValue();
        return getBit("availableUsers", indexLong);
    }

    /**
     * 有序集合获取排名
     * @param key   集合名称
     * @param value 值
     */
    public Long zRank(String key, Object value) {
        ZSetOperations zset = redisTemplate.opsForZSet();
        return zset.rank(key, value);
    }


    /**
     * 有序集合获取排名
     * @param key
     */
    public Set zRankWithScore(String key, long start, long end) {
        ZSetOperations zset = redisTemplate.opsForZSet();
        Set ret = zset.rangeWithScores(key, start, end);
        return ret;
    }

    /**
     * 有序集合添加
     * @param key
     * @param value
     */
    public Double zSetScore(String key, Object value) {
        ZSetOperations zset = redisTemplate.opsForZSet();
        return zset.score(key, value);
    }


    /**
     * 有序集合添加分数
     * @param key
     * @param value
     * @param scoure
     */
    public void incrementScore(String key, Object value, double scoure) {
        ZSetOperations zset = redisTemplate.opsForZSet();
        zset.incrementScore(key, value, scoure);
    }


    /**
     * 有序集合获取排名
     * @param key
     */
    public Set reverseZRankWithScore(String key, long start, long end) {
        ZSetOperations zset = redisTemplate.opsForZSet();
        Set ret = zset.reverseRangeByScoreWithScores(key, start, end);
        return ret;
    }

    /**
     * 有序集合获取排名
     * @param key
     */
    public Set reverseZRankWithRank(String key, long start, long end) {
        ZSetOperations zset = redisTemplate.opsForZSet();
        Set ret = zset.reverseRangeWithScores(key, start, end);
        return ret;
    }
}

package com.example.demo;

import com.example.demo.pojo.User;
import com.example.demo.utils.RedisUtils;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisTemplate;

import javax.annotation.Resource;

@SpringBootTest
class DemoApplicationTests {

    @Autowired
    private RedisUtils redisUtils;

    @Test
    void utils(){
        redisUtils.set("name","xy");
        System.out.println(redisUtils.get("name"));
    }
}