Redis入门

概述

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

        Redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。

        是当下最热门的NoSQL技术之一！也被人们称之为结构化数据库！

官网：Redis

特性

        - 免费且开源

        - 支持多种数据类型

        - 支持持久化

        - 提供多种语言API

下载与安装

        通过官网下载即可。

        Windows安装

                1、Windows版压缩包：Redis下载及安装(windows版) - show-code - 博客园

                2、解压到自己电脑上的目录下就可以了

                3、运行Redis，双击redis-server.exe即可。

                4、连接Redis，双击redis-cli.exe即可。输入ping命令，返回PONG即连接成功。

       

        Linux安装

                1、安装宝塔面板，通过宝塔面板安装Redis。

                2、找到Redis文件夹，输入make install

                3、查看是否成功

                4、在当前目录下创建一个目录，用于复制原生的redis.conf文件

                5、启动Redis服务（注：6.24版本启动后并没有任何返回值，只需要查看启动的6379端口即可）

                6、使用redis-cli进行连接测试

                7、关闭Redis服务  

Redis是单线程

        Redis是基于内存操作的，CPU不是Redis的瓶颈，Redis的瓶颈是根据机器的内存和网络带宽的。既然可以使用单线程来实现，所以Redis就使用单线程了。

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

        1、误区1：高性能的服务器一定是多线程的？

        2、误区2：多线程一定比单线程效率高？

        3、速度：CPU>内存>硬盘

        Redis是将所有的数据存放在内存中的，所以说使用单线程去操作效率就是最高的。（多线程会有耗时的操作：CPU上下文切换），对于内存系统来说，如果没有上下文切换效率就是最高的！

基本数据类型

redis默认有16个数据库。默认进入第0个数据库

select int：切换数据库

dbsize：查看当前数据库大小

flushdb：清空当前数据库

flushall：清空所有数据库

        Redis-Key：键值对

                1、keys *：查看当前数据库所有的key

                2、set key val：设置一个键以及对应的值

                3、get key：获取这个键下的值

                4、exists key：判断指定的键是否存在（1/0）

                5、move key：移除指定的键（1/0）

                6、expire key time：设置当前键的过期时间（s）

                7、ttl key：查看当前键的剩余时间（s）

                8、type key：查看当前键的类型

        String：字符串

                1、string key：查看当前键的长度

                2、append key val：追加当前键的值，如果当前key不存在，就相当于set key val

                3、incr key：使当前键自增1

                4、incrby key int：使当前键自增int

                5、decr key：使当前键自减1

                6、decrby key int：使当前键自减int

                7、getrange key int1 int2：截取当前键从int1到int2的值

                8、setrange key int val：替换当前键从int位置开始的值

                9、setex key int：设置当前键int秒后过期

                10、setnx key val：设置当前键与值，若不存在则创建，若已存在则不创建

                11、mset key  val ...：批量设置键与值

                12、mget key ...：批量获取键与值

                13、getset key val：如果不存在值，则返回null，如果存在值，则先返回原来的值，后更新值

        List：列表

                1、lpush list val：将一个值或者多个值，插入到列表的头部

                2、rpush list val：将一个值或者多个值，插入到列表的尾部

                3、lrange list int1 int2：获取list中从int1到int2的值

                4、lpop list：移除list中头部的第一个值

                5、rpop list：移除list中尾部的第一个值

                6、lindex list int：获取list中第int个的值

                7、llen list：返回list的长度

                8、ltrim list int1 int2：截取list中从int1到int2的值

                9、rpoplpush list1 list2：将list1尾部的值移动到list2中的头部

                10、lset list int val：将list中指定int的值替换为val

        Set：无序不重复集合

                1、sadd mySet val：添加一个值到mySet中

                2、smembers mySet：查看meSet的所有值

                3、sismemeber mySet val：判断val是否属于mySet（0/1）

                4、scard mySet：获取mySet中的元素个数

                5、srem mySet val：移除mySet中的指定val值

                6、srandmember mySet int：随机获取mySet中的int个值

                7、spop mySet：随机移除mySet中的一个值

                8、smove mySet mySet2 val：将指定的val从mySet移动到mySet2中

                9、sdiff key1 key2：获取key1与key2的差集

                10、sinter key1 key2：获取key1与key2的交集

                11、sunion key1 key2：获取key1与key2的并集

        Hash：哈希

                1、hset myHash key val：添加val值到myHash的key中

                2、hget myHash key：获取myHash的key的值

                3、hgetall myHash：获取myHash所有的值

                4、hdel myHash key：移除myHash中的key的值

                5、hexists myHash key：判断myHash中的key是否存在（0/1）

                6、hkeys myHash：获取myHash中所有的key

                7、hvals myHash：获取myHash中所有的val

        Zset：有序集合

                1、zadd mySet int val：添加一个val值至mySet中，优先级为int（越小越前）

                2、zrange mySet：获取mySet中所有的值

                3、zrangebyscore mySet -inf +inf：将mySet排序，范围为负无穷~正无穷

                4、zcard mySet：获取mySet中的元素个数

                5、zcount mySet int1 int2：获取mySet中int1至int2区间的值

三种特殊数据类型

                Geospatial：地理位置

                        1、geoadd key val（纬度、经度、名称）：添加一个地理位置

                        2、geopos key 名称：获取这个名称下的经纬度

                        3、geodist key 名称1 名称2 km：获取名称1与名称2的地理位置的距离（千米）

                        4、georadius key 纬度 经度 范围 km：查找以输入的经纬度为圆心，半径为范围km的所在key中的地理位置

                        5、georadiusbymember key val 范围 km：查找以key中的val为圆心，半径为范围km所在的地理位置

                        6、geohash key 名称1 名称2：返回11个字符的字符串的经纬度

                Hyperloglog：基数统计

                        1、pfadd key val：添加元素到key中

                        2、pfcount key：计算这个key中有多少个元素

                        3、pfmerge key key1 key2：合并key1与key2以并集至key中

                Bitmap：位图场景

                        1、setbit key val 0/1：添加一个值到key的val中，值为0/1

                        2、getbit key val：获取key中的val的值

                        3、bitcount key：统计key中所有为1的val

基本事务操作

        Redis事务本质：一组命令的集合！一个事务中的所有命令都会被序列化，在事务执行过程中，会按照顺序执行！一次性、顺序性、排他性！执行一系列的命令。

        Redis单条命令是保证原子性的，但是事务不保证原子性。

        Redis事务没有隔离级别的概念。

        Redis的事务：

                1、开启事务（multi）

                2、命令入队（.......）

                3、执行事务（exec）

                4、放弃事务（discard）

                

Jedis

        1、导入依赖

    <dependencies>
        <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.3.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.62</version>
        </dependency>
    </dependencies>

        2、连接数据库

        3、操作命令

        4、断开连接

public class TestPing {

    public static void main(String[] args) {
        //1.new Jedis对象
        Jedis jedis=new Jedis("127.0.0.1",6379);
        //jedis所有命令就是redis的命令
        String ping = jedis.ping();
        //测试连接
        System.out.println(ping);
        //断开连接
        jedis.close();
    }
}

SpringBoot整合       

        在springboot2.x之后，原来使用的jedis被替换成了lettuce

        jedis：采用的是直连，多个线程一起操作的话，是不安全的。如果想要避免不安全行为，需要使用jedis pool 连接池。更像BIO模式

        lettuce：采用的是异步（netty），实例可以在多个线程中进行共享，不存在线程不安全的情况，可以减少线程数据了。更新NIO模式

        1、导入依赖

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

        2、配置连接

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

        3、测试

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void contextLoads() {

        //opsForValue() 操作字符串，类似String
        //opsForList()  操作List，类似List
        //opsForHash()  操作Hash，类似Hash
        //其他均和redis中类似...
        //redisTemplate.opsForValue().set();

        //获取redis的连接对象
//        RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
//        connection.flushDb();
//        connection.flushAll();

        redisTemplate.opsForValue().set("keys","admin");
        System.out.println(redisTemplate.opsForValue().get("keys"));
    }

              RedisTemplate  

@Configuration
public class RedisConfig {

    //编写自己的redis模板
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        //为了开发方便，一般使用<String,Object>
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(redisConnectionFactory);

        //配置具体的序列化方式
        //json序列化
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer =
                new Jackson2JsonRedisSerializer<Object>(Object.class);
        ObjectMapper om=new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        //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);
        template.afterPropertiesSet();

        return template;
    }

}

          RedisUtil

@Component
public class RedisUtil {

    //此写法可防止RedisTemplate 注入失败

    private static RedisTemplate redisTemplate;
    @Autowired
    @Qualifier("redisTemplate")
    public void setRedisTemplate(RedisTemplate redisTemplate) {
        RedisUtil.redisTemplate = redisTemplate;
    }

    /**

     指定缓存失效时间
     @param key 键
     @param time 时间(秒)
     @return
     */
    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 可以传一个值 或多个
     */
    public void del(String... key){
        if(key!=null&&key.length>0){
            if(key.length==1){
                redisTemplate.delete(key[0]);
            }else{
                redisTemplate.delete(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 static 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)
     @return
     */
    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)
     @return
     */
    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
     @return 值
     */
    public Object hget(String key,String item){
        return redisTemplate.opsForHash().get(key, item);
    }
    /**

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

     HashSet
     @param key 键
     @param map 对应多个键值
     @return true 成功 false 失败
     */
    public boolean hmset(String key, Map<String,Object> 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<String,Object> 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)
     @return
     */
    public double hincr(String key, String item,double by){
        return redisTemplate.opsForHash().increment(key, item, by);
    }
    /**

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

     根据key获取Set中的所有值
     @param key 键
     @return
     */
    public Set sGet(String key){
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    /**

     根据value从一个set中查询,是否存在
     @param key 键
     @param value 值
     @return true 存在 false不存在
     */
    public boolean sHasKey(String key,Object value){
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**

     将数据放入set缓存
     @param key 键
     @param values 值 可以是多个
     @return 成功个数
     */
    public long sSet(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    /**

     将set数据放入缓存
     @param key 键
     @param time 时间(秒)
     @param values 值 可以是多个
     @return 成功个数
     */
    public long sSetAndTime(String key,long time,Object...values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if(time>0) {
                expire(key, time);
            }
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    /**

     获取set缓存的长度
     @param key 键
     @return
     */
    public long sGetSetSize(String key){
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    /**

     移除值为value的
     @param key 键
     @param values 值 可以是多个
     @return 移除的个数
     */
    public long setRemove(String key, Object...values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
//=list===
    /**

     获取list缓存的内容
     @param key 键
     @param start 开始
     @param end 结束 0 到 -1代表所有值
     @return
     */
    public List lGet(String key, long start, long end){
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    /**

     获取list缓存的长度
     @param key 键
     @return
     */
    public long lGetListSize(String key){
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    /**

     通过索引 获取list中的值
     @param key 键
     @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     @return
     */
    public Object lGetIndex(String key,long index){
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    /**

     将list放入缓存
     @param key 键
     @param value 值
     @return
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**

     将list放入缓存
     @param key 键
     @param value 值
     @param time 时间(秒)
     @return
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**

     将list放入缓存
     @param key 键
     @param value 值
     @return
     */
    public boolean lSet(String key, List value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**

     将list放入缓存
     @param key 键
     @param value 值
     @param time 时间(秒)
     @return
     */
    public boolean lSet(String key, List value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**

     根据索引修改list中的某条数据
     @param key 键
     @param index 索引
     @param value 值
     @return
     */
    public boolean lUpdateIndex(String key, long index,Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**

     移除N个值为value
     @param key 键
     @param count 移除多少个
     @param value 值
     @return 移除的个数
     */
    public long lRemove(String key,long count,Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
}

Redis持久化

        Redis是内存数据库。如果不将内存中的数据库状态保存到磁盘，那么一旦服务器进程退出，服务器中的数据库状态也会消失。所以Redis提供了持久化功能！

        RDB（Redis DataBase）

        类似于快照，按照redis.conf配置文件中的设置自动保存。

        AOF（Append Only File）

        通过记录redis的命令去记录数据库的变更，然后持久化到文件中

Redis主从复制

        主从复制，是指将一台Redis服务器的数据，复制到其他的Redis服务器。前者称为主节点，后者称为从节点；数据的复制是单向的，只能从主节点到从节点，主节点写为主，从节点以读为主。读写分离，减缓服务器压力。