Redis

Redis学习笔记

1、NoSQL数据库

NoSQL数据库：非关系型数据库，

特点：

• 方便拓展（数据之间不存在关系）

• 数据量大，高性能（读写操作性能强）

• 数据类型多样（不需要事先设计数据库）

2、NoSQL数据库的四大分类

KV键值存储数据库

• redis...

列存储数据库

• HBase

文档型数据量

• MongoDB...

图形数据量

• Neo4J、InfoGrid

3、Redis概述

Redis是什么？

Redis（Remote Dictionary Server )，即远程字典服务，是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。

4、Redis安装

Windows下安装

• 1、下载地址：https://github.com/tporadowski/redis/releases
• 2、启动服务：通过redis安装目录下的redis-server.exe启动
• 3、Redis命令行程序：redis-cli.exe

Linux下安装

5、Redis基础知识

redis有十六个数据库。默认使用的是第0个。

常用命令

• select index：切换数据库，index-第几个数据库
• dbsize：查看当前数据库使用的大小
• **keys **：查看当前数据库的所有key
• flushdb：清空当前数据库
• flushall：清空所有数据库

Redis是单线程的

为什么Redis是单线程还这么快？

Redis是将所有数据存在内存中的，所以使用单线程，除去多线程的cpu切换上下文，效率才是最高的。

6、Redis-Key操作

• exists key名称：存在返回1，不存在返回0
• move key名称 1 : 移除指定的键值对
• expire key名称 秒数 ： 设置指定key多久后过期
• ttl key名称 ：查看该key还有多久过期，返回-2则已经过期
• type key名称 ：查看该key的类型

7、五大数据类型

String(字符串)

• set key value 设置值

• get key 获取值

• exists key 判断当前值是否存在，存在为返回1，不存在返回0

• append key"字符串" 给当前key的值追加字符串，如果key不存在，则新建

• strlen key 获取当前key值的长度

• incr key 当前key的值自增1(针对于整型)

• decr key 当前key的值自减1(针对于整型)

• incrby key20 当前key的值自增20(针对于整型)

• decrby key10 当前key的值自减10(针对于整型)

• getrange key 0 3 获取当前key的值的第0位到第3位的字符串（截取字符串）

• getrange key 0 -1 获取当前key的值的全部字符串

• **setrange key1 ***** 替换指定位置的字符串

• setex key1 10 "hello222" 设置key1的值10秒后过期

• ttl key1 查询key1多少秒过期，返回-2则已经过期

• setnx key value 如果key不存在则创建，如果存在则创建失败

• mset k1 v1 k2 v2 k3 v3 批量设置值

• mget k1 k2 k3 批量获取

• msetnx k2 v2 k4 v4 不存在才创建，一个创建失败所有失败

• set user:1001:name zhangsan 设置对象（key的设计，对象名：编号：属性名）

• getset key value 先获取值返回，再设置新值

List

• 所有的list命令都是用l开头，先插入的在右侧
• lpush city chongqing，beijing：向list集合左侧添加一个或者多个值
• lrange city 0 -1：遍历集合（倒序）
• rpush city hunan：向city集合右侧侧添加一个或者多个值
• lpop city：移除city集合左侧第一个值
• rpop city：移除city集合右侧第一个值
• lindex city 0：获取city集合中指定位置角标的元素
• llen city：获取city集合的长度
• lrem city 3 chongqing：移除city集合中的指定个数的value
• ltrim city 0 1：截取city集合中的指定范围的值
• rpoplpush city city2：将city集合中的最右侧的值移动到city2集合的最左侧
• lset city 0 aaa：替换city集合中指定下标的值为新值，该下标位置不存在值，则报错
• linsert city before aaa aaabefore：在集合指定元素前，插入指定元素
• linsert city after aaa aaaafter：在集合元素指定元素后，插入指定元素
• 总结
  • redis的List集合本质是一个链表。
  • 操作两侧元素效率高，操作中间元素效率低。

set

• set集合中所有命令s开头，存入的值不重复
• sadd myset 111 222：向myset集合中添加一个或多个值，逗号隔开
• smembers myset：取出myset集合中的所有值
• sismember myset 111：判断该值在myset集合中是否存在，存在返回1，不存在返回0
• scard myset：返回myset集合中的元素个数
• srem myset 444 555：移除myset集合中的一个或多个值，逗号隔开
• srandmember myset 2：随机取出myset集合中的指定个数元素，默认取出一个
• spop myset 2：随机删除myset集合中的指定个数元素，默认删除一个
• smove myset myset2 111：将指定元素从myset集合移动到myset2集合中去
• sdiff key1 key2：返回key1，key2集合的元素差集，key1中存在，但key2中不存在的元素
• sinter key1 key2：返回key1，key2集合的元素交集，相同元素
• sunion key1 key2：返回key1，key2集合的元素并集，所有元素，去重。

hash(哈希)

• hash仍然是key-value的形式存储元素，但value变为存放map集合

• hset person name zhangsan：设置值

• hget person name：取出person中，name为key的value

• hgetall person：取出person中的所有键值对，结果如下：

  1) "name"
  2) "zhangsan"
  3) "age"
  4) "18"
  5) "address"
  6) "chongqing"
  

• hmset person name zhangshan age 18 address beijing：设置多个键值对的值

• hmget person name age address：取出多个键的值

• hdel person age：删除指定key的键值对

• hlen person：获取person中有多少个键值对

• hexists person name：判断person中指定key是否存在，存在返回1，不存在返回0

• hkeys person：获取person中的所有key

• hvals person：获取person中的所有value

• hincrby person age 2：给person中指定key的值增加指定增量

• hsetnx person sex 1：person中设置的key存在则设置失败，不存在则可以设置

zset

在set的基础上，中间为添加一个值，用于排序

• zadd myzset 2 two 3 three 4 four：添加一个或者多个值，key和值中间为排序位
• zrange myzset 0 -1：遍历所有元素,从小到大排序元素
• ZRANGEBYSCORE myzset -inf +inf：从小到大排序元素
• zrevrange myzset 0 -1：从大到小排序元素
• ZRANGEBYSCORE myzset 2 3 withscores：查询排序字段在2到3之间的元素，并且带上排序位的值
• zrem myzset zero：移除具体元素
• zcard myzset：返回有序集合中的元素个数
• zcount myzset 0 10：获得指定区间的成员数量

8、三大特殊数据类型

GEO

地理位置，通过经纬度确定位置。

• geoadd：添加一个或多个地理位置坐标

  规则：两级无法添加，实际通过程序导入地理位置信息

  	 有效经度范围：-180到180度
  																																										
     有效纬度范围：-85.05112878至85.05112878度
  

  超过此范围，redis会返回错误信息。

  GEOADD key longitude latitude member [longitude latitude member ...]
  
  longitude:地理位置的经度
  latitude：地理位置的纬度
  member：地理位置名称
  

• geopos：根据名称查询一个或多个地理位置信息

  GEOPOS key member [member ...]
  

• geodist：获取两个地理位置的之间的距离

  GEODIST key member1 member2 [m|km|ft|mi]
  
  单位
  m：米（默认）
  km：千米
  ft：英尺
  mi：英里
  

• georadius：获取指定经纬度坐标的指定范围内的地理位置集合

  GEORADIUS key longitude latitude radius [m|km|ft|mi] [WITHCOORD] [WITHDIST] [ASC|DESC] [WITHHASH] [COUNT count]
  

  longitude latitude标识了地理位置的坐标，radius表示范围距离(多大半径距离)，距离单位可以为m|km|ft|mi，还有一些可选参数：

  • WITHCOORD：传入WITHCOORD参数，则返回结果会带上匹配位置的经纬度。
  • WITHDIST：传入WITHDIST参数，则返回结果会带上匹配位置与给定地理位置的距离。
  • ASC|DESC：默认结果是未排序的，传入ASC为从近到远排序，传入DESC为从远到近排序。
  • WITHHASH：传入WITHHASH参数，则返回结果会带上匹配位置的hash值。
  • COUNT count：传入COUNT参数，可以返回指定数量的结果。

• georadiusbymember：获取指定地理位置的指定范围内的地理位置集合

  GEORADIUSBYMEMBER key member radius [m|km|ft|mi] [WITHCOORD] [WITHDIST] [ASC|DESC] [WITHHASH] [COUNT count]
  

• geohash：返回一个或多个地理位置的hash值

Hyperloglog

用于做基数（不重复元素）统计的算法。所占用的内存很小。

• PFADD key element [element ...]：添加指定元素到 HyperLogLog 集合中
• PFCOUNT key [key ...]：返回给定 HyperLogLog 集合的基数估算值
• PFMERGE destkey sourcekey [sourcekey ...]：将多个 HyperLogLog 合并为一个 HyperLogLog，
  • destkey：合并后的新HyperLogLog集合的名称

Bitmap

位图，按顺序储存0和1两种状态。

• SETBIT key offset value：设置指定下标的状态（0或1）

  • 顺序必须按照0开始，每次设置+1的规则

• GETBIT key offset：查看指定下标的状态值

• bitcount key [start end]：统计key集合中，状态为1的数量，不指定开始和结束下标，默认统计全部

9、事务

• redis事务的本质：是一组命令的集合！将redis命令按顺序执行
• redis事务的特性：
  • 一次性
  • 顺序性
  • 排他性

redis的事务没有事务隔离的概念，redis单条命令保证原子性，但事务不保证原子性。

redis开启事务后，命令只进行入队操作，只有发起执行事务命令时，才会执行。

• redis事务的使用：

  • 开启事务：multi

  • 命令入队：需要执行的redis命令集合

  • 执行事务：exec

    在开启事务后，可以使用 discard 命令放弃事务。即所有的命令失效，返回到开启事务前。

    127.0.0.1:6379> multi #开启事务
    OK
    127.0.0.1:6379> set k1 v1 #redis命令
    QUEUED
    127.0.0.1:6379> set k2 v2
    QUEUED
    127.0.0.1:6379> set k3 v3
    QUEUED
    127.0.0.1:6379> exec #执行事务
    1) OK	# 执行结果
    2) OK
    3) OK
    

    127.0.0.1:6379> multi #开启事务
    OK
    127.0.0.1:6379> set q1 v1
    QUEUED
    127.0.0.1:6379> set q2 v2
    QUEUED
    127.0.0.1:6379> discard #放弃事务
    OK
    

• redis事务出现异常：

  • 编译型异常，即redis命令格式出错

    事务队列中的所有命令都不会执行。出现事务错误异常

  127.0.0.1:6379> multi 
  OK
  127.0.0.1:6379> set k1 #命令出错
  (error) ERR wrong number of arguments for 'set' command
  127.0.0.1:6379> set k1 k2
  QUEUED
  127.0.0.1:6379> exec #返回错误提示
  (error) EXECABORT Transaction discarded because of previous errors.
  

  • 运行时异常，redis命令在执行时，才会出现的错误

    事务队列中，出错的命令不会执行，正确的命令会执行

  127.0.0.1:6379> multi
  OK
  127.0.0.1:6379> set k1 "aaa" 
  QUEUED
  127.0.0.1:6379> incr k1 #错误语法：对字符串进行+1操作
  QUEUED
  127.0.0.1:6379> set k2 v2
  QUEUED
  127.0.0.1:6379> set k3 v3
  QUEUED
  127.0.0.1:6379> exec
  1) OK
  2) (error) ERR value is not an integer or out of range #错误命令执行出错。其余执行成功
  3) OK
  4) OK
  

• redis监视：

  redis中可以通过watch命令对key进行监视，如果在开启事务过程中，该key的值发生变化，则执行事务失败。

  127.0.0.1:6379> set money 100
  OK
  127.0.0.1:6379> watch money #监听money的值
  OK
  127.0.0.1:6379> multi
  OK
  127.0.0.1:6379> decrby money 10
  QUEUED
  127.0.0.1:6379> set k1 v1
  QUEUED
  127.0.0.1:6379> exec
  (nil)  # 由于开启事务后，money的值发生变化，所以执行事务失败，返回null
  

10、Jedis

jedis是redis官方推荐的java连接工具，使用Java操作redis的中间件。

Jedis的使用

• 导入依赖

  
  
      redis.clients
      jedis
      3.3.0
  
  

• 创建对象

  //创建jedis对象，参数:地址+端口
  Jedis jedis = new Jedis("127.0.0.1",6379);
  //jedis类的方法和redis命令一致
  //测试连接
  System.out.println(jedis.ping());
  jedis.set("name","zhangsan");
  String name = jedis.get("name");
  System.out.println(name);
  

Jedis整合redis事务

//创建jedis对象
Jedis jedis = new Jedis("127.0.0.1", 6379);
//开启事务,multi:事务对象
Transaction multi = jedis.multi();
//执行命令操作
try {
    //执行命令
    multi.set("address1","beijing");
    multi.set("address2","chongqing");
    //未出现异常，执行事务
    multi.exec();
} catch (Exception e) {
    //出现异常，放弃事务
    multi.discard();
    e.printStackTrace();
}finally {
    System.out.println(jedis.get("address1"));
    System.out.println(jedis.get("address2"));
    //关闭连接
    jedis.close();
}

11、SpringBoot整合Redis

SpringBoot在2.X版本后，连接redis的底层工具由jedis替换为lettuce

对比：

? jedis：采用直连，多线程操作不安全，如果想实现线程安全，需要使用jedis pool连接池

? lettuce：底层采用netty，实例可以在多个线程中共享，线程安全

• 1、引入坐标依赖

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

• 2、配置连接

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

• 3、通过RedisTemplate操作redis

  @Autowired
  private RedisTemplate redisTemplate;
  
  @Test
  void contextLoads() {
  
      redisTemplate.opsForValue().set("address1","chongqing");
      System.out.println(redisTemplate.opsForValue().get("address1"));
  }
  

RedisTemplate的使用

https://blog.csdn.net/ruby_one/article/details/79141940

RedisTemplate 对五种数据结构的操作

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

12、自定义RedisTemplate

redisTemplate无法存入未序列化的对象

解决方案：

• 实体类实现序列化接口

  @Data
  @AllArgsConstructor
  @NoArgsConstructor
  public class User implements Serializable {
  
      private String username;
      private Integer age;
  }
  

• 将Java对象转换为json字符串存入

  User user = new User("李四", 33);
  //对象转为json字符串
  String userJson = new ObjectMapper().writeValueAsString(user);
  
  redisTemplate.opsForValue().set("user",userJson);
  

自定义RedisTemplate

由于redis自动配置类中存在@ConditionalOnMissingBean(name = "redisTemplate")注解，所以当自定义redisTemplate时，自动配置类会失效。

/**
 * 自定义redisTemplate注解
 * @param factory
 * @return
 */
@Bean
@SuppressWarnings("all")
public RedisTemplate redisTemplate(RedisConnectionFactory factory) {
    RedisTemplate template = new RedisTemplate<>();
    template.setConnectionFactory(factory);

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

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

    //key采用string的序列化方式
    template.setKeySerializer(stringRedisSerializer);
    //hash的key也采用string的序列化方式
    template.setHashKeySerializer(stringRedisSerializer);
    //value的序列化方式采用jackson
    template.setValueSerializer(jackson2JsonRedisSerializer);
    //hash的value序列化方式采用jackson
    template.setHashValueSerializer(jackson2JsonRedisSerializer);

    return template;
}

RedisTemplate的工具类

@Component
public final class RedisUtil {

    @Autowired
    private RedisTemplate redisTemplate;

    // =============================common============================
    /**
     * 指定缓存失效时间
     * @param key  键
     * @param time 时间(秒)
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据key 获取过期时间
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }


    /**
     * 判断key是否存在
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 删除缓存
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete((Collection) CollectionUtils.arrayToList(key));
            }
        }
    }


    // ============================String=============================

    /**
     * 普通缓存获取
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */

    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 普通缓存放入并设置时间
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */

    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 递增
     * @param key   键
     * @param delta 要增加几(大于0)
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }


    /**
     * 递减
     * @param key   键
     * @param delta 要减少几(小于0)
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }


    // ================================Map=================================

    /**
     * HashGet
     * @param key  键 不能为null
     * @param item 项 不能为null
     */
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 获取hashKey对应的所有键值
     * @param key 键
     * @return 对应的多个键值
     */
    public Map hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     * @param key 键
     * @param map 对应多个键值
     */
    public boolean hmset(String key, Map map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * HashSet 并设置时间
     * @param key  键
     * @param map  对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public boolean hmset(String key, Map map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 删除hash表中的值
     *
     * @param key  键 不能为null
     * @param item 项 可以使多个 不能为null
     */
    public void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }


    /**
     * 判断hash表中是否有该项的值
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }


    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     *
     * @param key  键
     * @param item 项
     * @param by   要增加几(大于0)
     */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }


    /**
     * hash递减
     *
     * @param key  键
     * @param item 项
     * @param by   要减少记(小于0)
     */
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }


    // ============================set=============================

    /**
     * 根据key获取Set中的所有值
     * @param key 键
     */
    public Set