Redis

  • Redis 是一个基于内存的key-value结构数据库

  • 基于内存存储，读写性能高

  • 适合存储热点数据

  • 企业应用广泛

  • Redis是C语言开发的一个开源的高性能键值对（key-velue）数据库，官方提供的数据是可以达到100000+的QPS（每秒查询次数），它存储的value类型比较丰富，也称为结构化的NOSQL数据库。

  • NoSql （not Only SQL），不仅仅是SQL，泛指非关系型数据库。NoSql数据库并不是要取代关系型数据库，而是关系型数据库的补充

  • 关系型数据库

    • Mysql

    • Oracle

    • DB2

    • SQLServer

  • 非关系型数据库

    • Redis

    • Mongo db

    • MemCached

  • Redis应用场景

    • 缓存

    • 任务队列

    • 消息队列

    • 分布式锁

  • 下载地址：https://github.com/microsoftarchive/redis/releases

Redis数据类型

Redis存储的是Key-value结构的数据，其中key是字符串类型，value有5种常用的数据类型：

  • 字符串 String

  • 哈希 hash ：适合存储对象

  • 列表 list ：按照插入顺序排序，可以有重复元素

  • 集合 set ：无序集合，没有重复元素

  • 有序集合 sorted set ：有序集合，没有重复元素

字符串String操作命令：

  • SER key value ：设置指定key的值

  • SET key ：获取指定key的值

  • SETEX key seconds value ：设置指定key的值，并将key的过期时间设置为seconds秒

  • SETNX key value 只有key 不存在时设置key的值

哈希 hash 操作命令

Redis hash 是一个string类型的field 和value 的映射表，hash特别适合用于存储对象，常用命令：

  • HSET key field value

  • HGET key field

  • HDEL key field

  • HKEYS key ：获取所有字段 ‘field’

  • HVALS key ：获取所有值 ， 即 field 对应的 ‘value’

  • HGETALL key ：指定key的所有字段和值 field 和 value

列表 list 操作命令

Redis 列表是简单的字符串列表，按照插入顺序排序，常用命令：L ：left /R: right

是一个队列，从 左边 进 右边 出

  • LPUSH key value1 [value2] ;可以插入一个或者多个数据到列表头部

  • LRANGE(Lrange) key startNum stopNum ：获取范围内的数据 stopNum=-1表示最后一个数了

  • RPOP key ：从右边移除第一个数据，即删除最后一个数据

  • LLEN key : 获取list长度 LEN :lenth缩写

  • BRPOP : key1 [key2] timeout : 移除最后一个数据，还可以设置时间

集合 set 操作命令

Redis set 集合是String类型的无序集合。集合成员是唯一的。

  • SADD key member1 [member2] //添加元素

  • SMEMBERS key //返回集合中所有成员

  • SCARD key //获取集合的成员数total

  • SINTER key1 key2 [key i] //获取给定集合的交集

  • SUNION key1 key2 [key i] //获取给定集合的并集

  • SDIFF key1 key2 [key i] //获取给定集合的差集 注：例：key1- key2 所得的差集 ；集合的位置顺序 ，在前或者在后values是不一样的。差集只会是在面的集合中。

  • SREM key member1 [member2] //删除集合中的元素或者多个

有序集合 sorted set 操作命令

Redis sorted set 有序集合是string 类型元素的集合，不能重复。每个元素会关联一个double分数score，按照score从小到大排序，分数可以重复。

  • ZADD key score1 member1 [score2 member2] //向集合添加元素，或者更新已存在元素的分数。

  • ZRANGE key startNum stopNum [withscore] // （Zrange 范围） 指定范围返回数据，加上withscore 可以返回score

  • ZINCRBY key increment member //对指定成员的分数增加增量increment ，排序顺序挥发生变化。修改score

  • ZREM key member1 [member2] //删除元素

通用命令 key

  • KEYS pattern //查找所有符合给定模式（pattern）的key ：例 key *

  • EXISTS key //检查给定的key是否存在

  • TYPE key //返回key 所储存的值得类型

  • TTL key 返回给定key得所剩生存时间（TTL ：time to live） 以秒为单位

  • DEL key 该命令用于在 key 存在是删除key

代码

  • pom

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

 

  • Redisconfig

package com.itheima.config;
​
import org.springframework.cache.annotation.CachingConfigurerSupport;
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.StringRedisSerializer;
​
/**
 * Redis配置类
 */
​
//@Configuration
public class RedisConfig extends CachingConfigurerSupport {
​
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
​
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
​
        //默认的Key序列化器为：JdkSerializationRedisSerializer
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
​
        redisTemplate.setConnectionFactory(connectionFactory);
​
        return redisTemplate;
    }
​
}
​

 

  • test

package com.itheima.test;
​
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.*;
import org.springframework.test.context.junit4.SpringRunner;
​
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;
​
@Slf4j
@SpringBootTest
@RunWith(SpringRunner.class)
public class SpringDataRedisTest {
​
    @Autowired
    private RedisTemplate redisTemplate;
​
    /**
     * 操作String类型数据
     */
    @Test
    public void testString(){
        //普通String类型的封装
        ValueOperations valueOperations = redisTemplate.opsForValue();
        //1.SER key value
        valueOperations.set("city123","beijing");
        //SET key
        String value = (String) valueOperations.get("city123");
        log.info(value);
​
        //2. SETEX key seconds value
        valueOperations.set("key1","value1",10l, TimeUnit.SECONDS);//设置TimeUnit单位
​
        //3.SETNX key value   只有key不存在时设置key的值
        Boolean aBoolean = valueOperations.setIfAbsent("city1234", "nanjing");
        log.info("aBoolean:{}",aBoolean);//false
    }
​
    /**
     * 操作Hash类型数据
     */
    @Test
    public void testHash(){
        //对Hash类型封装
        HashOperations hashOperations = redisTemplate.opsForHash();
​
        //存值： HSET key field value
        hashOperations.put("002","name","xiaoming");
        hashOperations.put("002","age","20");
        hashOperations.put("002","address","bj");
​
        //取值 ：HSET key field
        String age = (String) hashOperations.get("002", "age");
        log.info(age);
​
        //获得hash结构中的所有字段 ： HKEYS key
        Set keys = hashOperations.keys("002");
        for (Object key : keys) {
            System.out.println(key);
        }
​
        //获得hash结构中的所有值 ：HVALS key
        List values = hashOperations.values("002");
        for (Object value : values) {
            System.out.println(value);
        }
    }
​
    /**
     * 操作List类型的数据
     */
    @Test
    public void testList(){
        //对list类型封装
        ListOperations listOperations = redisTemplate.opsForList();
​
        //存值 ：LPUSH key value1 [value2]
        listOperations.leftPush("mylist","a");
        listOperations.leftPushAll("mylist","b","c","d");
​
        //取值：LRANGE(Lrange) key startNum stopNum
        List<String> mylist = listOperations.range("mylist", 0, -1);
        for (String value : mylist) {
            System.out.println(value);
        }
        System.out.println("---------");
​
        //获得列表长度: LLEN key
        Long size = listOperations.size("mylist");
        System.out.println(size);
        System.out.println("---------");
​
        //转成int
        int lSize = size.intValue();
        //遍历
        for (int i = 0; i < lSize; i++) {
            //出队列: RPOP key  返回删除的成员
            String element = (String) listOperations.rightPop("mylist");
            System.out.println(element);
        }
    }
​
    /**
     * 操作Set类型的数据
     */
    @Test
    public void testSet(){
        //对set类型封装
        SetOperations setOperations = redisTemplate.opsForSet();
​
        //存值：SADD key member1 [member2]
        setOperations.add("myset","a","b","c","a");
​
        //取值：SMEMBERS key
        Set<String> myset = setOperations.members("myset");
        for (String o : myset) {
            System.out.println(o);
        }
​
        //删除成员：SREM key member1 [member2]
        setOperations.remove("myset","a","b");
​
        //取值
        myset = setOperations.members("myset");
        for (String o : myset) {
            System.out.println(o);
        }
​
    }
​
    /**
     * 操作ZSet类型的数据
     */
    @Test
    public void testZset(){
        ZSetOperations zSetOperations = redisTemplate.opsForZSet();
​
        //存值：ZADD key score1 member1  [score2 member2]
        zSetOperations.add("myZset","a",10.0);
        zSetOperations.add("myZset","b",11.0);
        zSetOperations.add("myZset","c",12.0);
        zSetOperations.add("myZset","a",13.0);
​
        //取值：ZRANGE key startNum stopNum  [withscore]
        Set<String> myZset = zSetOperations.range("myZset", 0, -1);
        for (String s : myZset) {
            System.out.println(s);
        }
​
        //修改分数：ZINCRBY key increment member
        zSetOperations.incrementScore("myZset","b",20.0);
​
        //取值
        myZset = zSetOperations.range("myZset", 0, -1);
        for (String s : myZset) {
            System.out.println(s);
        }
​
        //删除成员：ZREM key member1 [member2]
        zSetOperations.remove("myZset","a","b");
        System.out.println("---------");
        //取值
        myZset = zSetOperations.range("myZset", 0, -1);
        for (String s : myZset) {
            System.out.println(s);
        }
    }
​
    /**
     * 通用操作，针对不同的数据类型都可以操作
     */
    @Test
    public void testCommon(){
        //获取Redis中所有的key: KEYS pattern
        Set<String> keys = redisTemplate.keys("*");
        for (String key : keys) {
            System.out.println(key);
        }
​
        //判断某个key是否存在: EXISTS key
        Boolean itcast = redisTemplate.hasKey("itcast");
        System.out.println(itcast);
​
        //删除指定key: DEL key
        redisTemplate.delete("myZset");
​
        //获取指定key对应的value的数据类型: TYPE key
        DataType dataType = redisTemplate.type("myset");
        System.out.println(dataType.name());
​
    }
}
​