Redis学习和笔记

下载redis 
docker pull redis

创建实例并启动
mkdir -p /mydata/redis/conf      

touch redis.conf

docker run -p 6379:6379 --name redis -v /mydata/redis/data:/data \
   -v /mydata/redis/conf/redis.conf:/etc/redis/redis.conf \
   -d redis redis-server /etc/redis/redis.conf

 ls   查看当前文件夹下的文件
 cat redis.conf

 测试redis 
  
 docker exec -it redis redis-cli
 
 ---
 由于以前的数据全存在内存中，从而我们重复读取get a的时候会导致失败
[root@localhost conf]# cat redis.conf
[root@localhost conf]# docker exec -it redis redis-cli
127.0.0.1:6379> set a b
OK
127.0.0.1:6379> get a
"b"   //从而在一次上来的时候这块是null
127.0.0.1:6379> exit

--让redis 持久化  ---> pwd
127.0.0.1:6379> exit
[root@localhost conf]# pwd
/mydata/redis/conf
[root@localhost conf]# ls
redis.conf
[root@localhost conf]# vi redis.conf 
i
appendonly yes  #开启持久化
esc  :wq

docker restart redis  //重启redis
--设置开机自启动docker 里边容器
sudo docker update <容器名> --restart=always

select 选择数据库

keys *  查看所有的key

exists key  查看key是否存在

move  key  id 根据id和key值移除

flushdb 清除当前数据库

flushAll 清除全部数据库中所有数据

set  key value 设置Key和value

get key  获得key的值

expire key 时间 设置过期时间单位秒

ttl key 查看过期时间

type key 查看当前key存到value的数据类型

select 选择数据库

keys *  查看所有的key

exists key  查看key是否存在

move  key  id 根据id和key值移除

flushdb 清除当前数据库

flushAll 清除全部数据库中所有数据

set  key value 设置Key和value

get key  获得key的值

expire key 时间 设置过期时间单位秒

ttl key 查看过期时间

type key 查看当前key存到value的数据类型

incr  key每次执行都进行加一操作

desc key 每次执行都进行减一操作

getRange key 0 3 截取字符串【0,3】

getRange key 0 -1 截取全部的字符串和get key 是一样的

setrange key 1 xx  替换指定位置开始的字符串

settex (set with expire)  key 过期时间 value 设置过期时间且值为value

setnx (set if not expire)  key   不存在的时候设置（在分布式中会经常使用）也就是说，不存在的时候会自动创建一个key,如果他存在的话，那么就会创建失败

mset key1 value1   key2 value2  ... 可以创建多对key和value

mget  key1 key2 key3 ...可以同时获取多个值

msetnx k1 v1 k2 v2 ...是一个原子性操作，要么一起成功，要么一起失败。

127.0.0.1:6379> select 2  选择数据库
OK
127.0.0.1:6379[2]> set money 100  
OK
127.0.0.1:6379[2]> set out 0
OK
127.0.0.1:6379[2]> watch money #监视money对象
OK
127.0.0.1:6379[2]> multi # 事务正常结束，数据没有发生变动，那么就可以正常执行成功
OK
127.0.0.1:6379[2](TX)> decrby money 20
QUEUED
127.0.0.1:6379[2](TX)> incrby out 20
QUEUED

<!--导入jedis的包-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>4.2.1</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.41</version>
        </dependency>

public class Test {
    public static void main(String[] args) {
        //创建一个new Jedis对象
        Jedis jedis = new Jedis("192.168.1.100",6379);
        //jedis所有的指令就是我们学的所有的指令
        System.out.println(jedis.ping());
    }

/*
redis的事务处理
 */
public class Redis事务 {

    public static void main(String[] args) {
        //开启链接
        Jedis jedis = new Jedis("192.168.1.100",6379);
        //清空当前数据库
        jedis.flushDB();
        //将数据转换为json格式，目前公司大部分使用的均是json
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("u1","我喜欢");
        jsonObject.put("u2","你");
        //开启事务
        Transaction multi = jedis.multi();
        String result = jsonObject.toJSONString();
        //  System.out.println(jedis.ping());
        //如果我需要监控，那么我就需要加一个乐观锁
        jedis.watch(result);//加一个锁
        try {
            multi.set("u1",result);
            multi.set("u2",result);
            int t = 1/0;
            multi.exec();//如果成功执行事务
        } catch (Exception e) {
            multi.discard(); //如果失败了，那么就事务回滚，或者事务放弃
            throw new RuntimeException(e);
        } finally {
            System.out.println(jedis.get("u1"));
            System.out.println(jedis.get("u2"));
            jedis.close();
        }
        //multi.set("u1","老胡");
       /*
        HashMap map = new HashMap();
        String ke = "k1";
        map.put(ke,"小黑");
        map.put(ke,"你好");
        System.out.println(map);
        System.out.println(map.size());
        {k1=你好}
            1
*/
        //连接关闭
    }
}

<!--导入jedis的包-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>4.2.1</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.41</version>
        </dependency>

#配置redis
   spring:
     redis:
       host: 192.168.1.100
       port: 6379

@Configuration(
       proxyBeanMethods = false
   )
   @ConditionalOnClass({RedisOperations.class})
   @EnableConfigurationProperties({RedisProperties.class})
   @Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})
   public class RedisAutoConfiguration {
       public RedisAutoConfiguration() {
       }
       
       
           @Bean
           @ConditionalOnMissingBean( //只有在没有的时候使用，故而，我们可以自定义一个RedisTemplate
               name = {"redisTemplate"}
           )
               //默认的，redisTemplate ，没有过多的设置，redis对象都是需要序列化
           //两个泛型读书Object,Object的类型，我们使用需要强制转换为<String,Obeject>
           public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
               RedisTemplate<Object, Object> template = new RedisTemplate();
               template.setConnectionFactory(redisConnectionFactory);
               return template;
           }
       
           @Bean
           @ConditionalOnMissingBean
           //由于String是Redis的最常使用的类型，所以但对提出来了一个bean
           public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
               StringRedisTemplate template = new StringRedisTemplate();
               template.setConnectionFactory(redisConnectionFactory);
               return template;
           }
       }

@SpringBootTest
   class RedisSpringBootApplicationTests {
   
       @Autowired
       private RedisTemplate redisTemplate ;
   
       @Test
       void contextLoads() {
          /*
           redisTemplate 操作不同的数据类型。api和我们的指令是一样的
           opsForValue  操作字符串，类似String
           opsForList 操作list 相当于list
           opsForSet
           opsForHash
           opsForZSet
           opsForGeo
           opsForHyperLogLogLog
   
   
           除了基本的操作，我们常用方法都可以使用redisTemplate操作
           比如事务和基本的操作
           */
           /*
           获取redis的链接对象
           RedisConnection redisConnection = redisTemplate.getConnectionFactory().getConnection();
           redisConnection.flushDb();
           redisConnection.flushAll();
   */
   
           redisTemplate.opsForValue().set("k",123);
           redisTemplate.opsForValue().set("k1","罗小黑");
           System.out.println(redisTemplate.opsForValue().get("k"));
           System.out.println(redisTemplate.opsForValue().get("k1"));
   
       }
       
   }

<?xml version="1.0" encoding="UTF-8"?>
   <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
       <modelVersion>4.0.0</modelVersion>
       <groupId>com.xh</groupId>
       <artifactId>Redis_SpringBoot</artifactId>
       <version>0.0.1-SNAPSHOT</version>
       <name>Redis_SpringBoot</name>
       <description>Redis_SpringBoot</description>
   
       <properties>
           <java.version>1.8</java.version>
           <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
           <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
           <spring-boot.version>2.3.7.RELEASE</spring-boot.version>
       </properties>
   
       <dependencies>
   
   <!--   重点jackson，是我们将redis的格式转换为redis格式，方便我们最直观的查看     -->
           <dependency>
               <groupId>com.fasterxml.jackson.core</groupId>
               <artifactId>jackson-core</artifactId>
               <version>2.9.6</version>
           </dependency>
   
           <dependency>
               <groupId>com.fasterxml.jackson.core</groupId>
               <artifactId>jackson-annotations</artifactId>
               <version>2.9.6</version>
           </dependency>
   
           <dependency>
               <groupId>com.fasterxml.jackson.core</groupId>
               <artifactId>jackson-databind</artifactId>
               <version>2.9.6</version>
           </dependency>
   
   
   
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-data-redis</artifactId>
           </dependency>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
           </dependency>
   
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-devtools</artifactId>
               <scope>runtime</scope>
               <optional>true</optional>
           </dependency>
           <dependency>
               <groupId>com.taobao.arthas</groupId>
               <artifactId>arthas-spring-boot-starter</artifactId>
               <version>3.4.8</version>
               <scope>runtime</scope>
           </dependency>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-configuration-processor</artifactId>
               <optional>true</optional>
           </dependency>
           <dependency>
               <groupId>org.projectlombok</groupId>
               <artifactId>lombok</artifactId>
               <optional>true</optional>
           </dependency>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-test</artifactId>
               <scope>test</scope>
               <exclusions>
                   <exclusion>
                       <groupId>org.junit.vintage</groupId>
                       <artifactId>junit-vintage-engine</artifactId>
                   </exclusion>
               </exclusions>
           </dependency>
           <dependency>
               <groupId>io.projectreactor</groupId>
               <artifactId>reactor-test</artifactId>
               <scope>test</scope>
           </dependency>
       </dependencies>
   
       <dependencyManagement>
           <dependencies>
               <dependency>
                   <groupId>org.springframework.boot</groupId>
                   <artifactId>spring-boot-dependencies</artifactId>
                   <version>${spring-boot.version}</version>
                   <type>pom</type>
                   <scope>import</scope>
               </dependency>
           </dependencies>
       </dependencyManagement>
   
       <build>
           <plugins>
               <plugin>
                   <groupId>org.apache.maven.plugins</groupId>
                   <artifactId>maven-compiler-plugin</artifactId>
                   <version>3.8.1</version>
                   <configuration>
                       <source>1.8</source>
                       <target>1.8</target>
                       <encoding>UTF-8</encoding>
                   </configuration>
               </plugin>
               <plugin>
                   <groupId>org.springframework.boot</groupId>
                   <artifactId>spring-boot-maven-plugin</artifactId>
                   <version>2.3.7.RELEASE</version>
                   <configuration>
                       <mainClass>com.xh.redis_springboot.RedisSpringBootApplication</mainClass>
                   </configuration>
                   <executions>
                       <execution>
                           <id>repackage</id>
                           <goals>
                               <goal>repackage</goal>
                           </goals>
                       </execution>
                   </executions>
               </plugin>
           </plugins>
       </build>
   
   </project>

/*
        * @Title 自定义一个Template
        * @Description 
        * @author  罗小黑
        * @param null
        * @return 
        * @date 2022/10/12 19:34
        * @email 
        */
       @Configuration
       public class Redis_self_RedisTemplate {
       
           @Bean
           @SuppressWarnings("all")
           public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory)
                   throws UnknownHostException {
               RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
               template.setConnectionFactory(factory);
       
               // 序列化配置
               // json序列化配置
               Jackson2JsonRedisSerializer objectJackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
               ObjectMapper objectMapper = new ObjectMapper();
               objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
               objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
               // String序列化配置
               StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
       
               template.setHashValueSerializer(objectJackson2JsonRedisSerializer);
               template.setValueSerializer(objectJackson2JsonRedisSerializer);
       
               template.setHashKeySerializer(stringRedisSerializer);
               template.setKeySerializer(stringRedisSerializer);
               template.afterPropertiesSet();
       
               return template;
           }
       }

package com.xh.redis_springboot.Util;
       
       
       import java.util.*;
       import java.util.concurrent.TimeUnit;
       
       import org.springframework.data.redis.connection.RedisConnection;
       import org.springframework.data.redis.core.RedisTemplate;
       import org.springframework.stereotype.Component;
       
       import javax.annotation.Resource;
       
       /*
        * @Title 我们在使用Redis的时候通常使用我们自己的工具类
        * @Description 这是一种思想，一种封装重用的思想，避免我们直接去使用redis自带的指令
        * @author  罗小黑
        * @param null
        * @return
        * @date 2022/10/12 20:19
   
        */
       @Component
       public class RedisUtil {
           @Resource
           private RedisTemplate<String, Object> redisTemplate;
       
           //============================Common=============================
       
           /**
            * 关闭
            */
           public void close() {
               //获取链接然后导入
               RedisConnection redisConnection = Objects.requireNonNull(redisTemplate.getConnectionFactory()).getConnection();
               redisConnection.close();
           }
       
           /**
            * 清空
            */
           public void flushDB() {
               RedisConnection redisConnection = Objects.requireNonNull(redisTemplate.getConnectionFactory()).getConnection();
               redisConnection.flushDb();
           }
       
       
           /**
            * 指定缓存失效时间
            *
            * @param key  键
            * @param time 时间(秒)
            * @return
            */
           public void expire(String key, Long time) {
               try {
                   if (time > 0) {
                       redisTemplate.expire(key, time, TimeUnit.SECONDS);
                   }
               } catch (Exception e) {
                   e.printStackTrace();
               }
           }
       
           /**
            * 根据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(Arrays.asList(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)
            * @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<Object> 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 0L;
               }
           }
       
           /**
            * 将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 0L;
               }
           }
       
           /**
            * 获取set缓存的长度
            *
            * @param key 键
            * @return
            */
           public Long sGetSetSize(String key) {
               try {
                   return redisTemplate.opsForSet().size(key);
               } catch (Exception e) {
                   e.printStackTrace();
                   return 0L;
               }
           }
       
           /**
            * 移除值为value的
            *
            * @param key    键
            * @param values 值 可以是多个
            * @return 移除的个数
            */
           public Long setRemove(String key, Object... values) {
               try {
                   return redisTemplate.opsForSet().remove(key, values);
               } catch (Exception e) {
                   e.printStackTrace();
                   return 0L;
               }
           }
           //===============================list=================================
       
           /**
            * 获取list缓存的内容
            *
            * @param key   键
            * @param start 开始
            * @param end   结束  0 到 -1代表所有值
            * @return
            */
           public List<Object> 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 0L;
               }
           }
       
           /**
            * 通过索引 获取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<Object> 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<Object> 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 {
                   return redisTemplate.opsForList().remove(key, count, value);
               } catch (Exception e) {
                   e.printStackTrace();
                   return 0L;
               }
           }
       }

下载redis 
    docker pull redis
    
    创建实例并启动
    mkdir -p /mydata/redis/conf      
    
    touch redis.conf
    
    docker run -p 6379:6379 --name redis -v /mydata/redis/data:/data \
       -v /mydata/redis/conf/redis.conf:/etc/redis/redis.conf \
       -d redis redis-server /etc/redis/redis.conf
    
     ls   查看当前文件夹下的文件
     cat redis.conf
    
     测试redis 
      
     docker exec -it redis redis-cli
     
     ---
     由于以前的数据全存在内存中，从而我们重复读取get a的时候会导致失败
    [root@localhost conf]# cat redis.conf
    [root@localhost conf]# docker exec -it redis redis-cli
    127.0.0.1:6379> set a b
    OK
    127.0.0.1:6379> get a
    "b"   //从而在一次上来的时候这块是null
    127.0.0.1:6379> exit
    
    --让redis 持久化  ---> pwd
    127.0.0.1:6379> exit
    [root@localhost conf]# pwd
    /mydata/redis/conf
    [root@localhost conf]# ls
    redis.conf
    [root@localhost conf]# vi redis.conf 
    i
    appendonly yes
    esc  :wq
    
    docker restart redis  //重启redis
    --设置开机自启动docker 里边容器
    sudo docker update <容器名> --restart=always

[root@localhost conf]# pwd
/mydata/redis/conf
[root@localhost conf]# ls
redis.conf
[root@localhost conf]# vi redis.conf

SUBSCRIBE 名字

redis 127.0.0.1:6379> SUBSCRIBE runoobChat #订阅一个频道，名字runoobChat

Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "runoobChat"
3) (integer) 1
#等待读取推送的消息

redis 127.0.0.1:6379> PUBLISH runoobChat "Redis PUBLISH test"
(integer) 1
redis 127.0.0.1:6379> PUBLISH runoobChat "Learn redis by runoob.com"
(integer) 1
# 订阅者的客户端会显示如下消息
 1) "message" #消息
2) "runoobChat"   #那个频道的消息
3) "Redis PUBLISH test" # 消息的具体内容
 1) "message"
2) "runoobChat"
3) "Learn redis by runoob.com"

> （1）数据冗余：主从复制实现了数据的热备份，是持久化之外的一种数据冗余方式。
> 
> （2）故障恢复：如果master宕掉了，使用哨兵模式，可以提升一个 slave 作为新的 master，进而实现故障转移，实现高可用
> 
> （3）负载均衡：可以轻易地实现横向扩展，实现读写分离，一个 master 用于写，多个 slave 用于分摊读的压力，从而实现高并发；

redis-cli -p 6379   #启动redis的客户端
#注意这个是在你要指定作为从机的客户端窗口里边执行的，他选择老大，而不是老大选择他
slaveof 127.0.0.1 6379 #配置主表 简称任命老大

# Example sentinel.conf
 
# 哨兵sentinel实例运行的端口 默认26379
port 26379
 
# 哨兵sentinel的工作目录
dir /tmp
 
# 哨兵sentinel监控的redis主节点的 ip port 
# master-name  可以自己命名的主节点名字 只能由字母A-z、数字0-9 、这三个字符".-_"组成。
# quorum 配置多少个sentinel哨兵统一认为master主节点失联 那么这时客观上认为主节点失联了

# sentinel monitor <master-name> <ip> <redis-port> <quorum>
  sentinel monitor mymaster 127.0.0.1 6379 2
 
# 当在Redis实例中开启了requirepass foobared 授权密码 这样所有连接Redis实例的客户端都要提供密码
# 设置哨兵sentinel 连接主从的密码 注意必须为主从设置一样的验证密码

# sentinel auth-pass <master-name> <password>
sentinel auth-pass mymaster MySUPER--secret-0123passw0rd
 
 
# 指定多少毫秒之后 主节点没有应答哨兵sentinel 此时 哨兵主观上认为主节点下线 默认30秒

# sentinel down-after-milliseconds <master-name> <milliseconds>
sentinel down-after-milliseconds mymaster 30000
 
# 这个配置项指定了在发生failover主备切换时最多可以有多少个slave同时对新的master进行 同步，这个数字越小，完成failover所需的时间就越长，但是如果这个数字越大，就意味着越 多的slave因为replication而不可用。可以通过将这个值设为 1 来保证每次只有一个slave 处于不能处理命令请求的状态。

# sentinel parallel-syncs <master-name> <numslaves>
sentinel parallel-syncs mymaster 1
 
 
 
# 故障转移的超时时间 failover-timeout 可以用在以下这些方面： 
#1. 同一个sentinel对同一个master两次failover之间的间隔时间。
#2. 当一个slave从一个错误的master那里同步数据开始计算时间。直到slave被纠正为向正确的master那里同步数据时。
#3.当想要取消一个正在进行的failover所需要的时间。  
#4.当进行failover时，配置所有slaves指向新的master所需的最大时间。不过，即使过了这个超时，slaves依然会被正确配置为指向master，但是就不按parallel-syncs所配置的规则来了
# 默认三分钟
# sentinel failover-timeout <master-name> <milliseconds>
sentinel failover-timeout mymaster 180000
 
# SCRIPTS EXECUTION
 
#配置当某一事件发生时所需要执行的脚本，可以通过脚本来通知管理员，例如当系统运行不正常时发邮件通知相关人员。
#对于脚本的运行结果有以下规则：
#若脚本执行后返回1，那么该脚本稍后将会被再次执行，重复次数目前默认为10
#若脚本执行后返回2，或者比2更高的一个返回值，脚本将不会重复执行。
#如果脚本在执行过程中由于收到系统中断信号被终止了，则同返回值为1时的行为相同。
#一个脚本的最大执行时间为60s，如果超过这个时间，脚本将会被一个SIGKILL信号终止，之后重新执行。
 
#通知型脚本:当sentinel有任何警告级别的事件发生时（比如说redis实例的主观失效和客观失效等等），将会去调用这个脚本，这时这个脚本应该通过邮件，SMS等方式去通知系统管理员关于系统不正常运行的信息。调用该脚本时，将传给脚本两个参数，一个是事件的类型，一个是事件的描述。如果sentinel.conf配置文件中配置了这个脚本路径，那么必须保证这个脚本存在于这个路径，并且是可执行的，否则sentinel无法正常启动成功。
#通知脚本

# sentinel notification-script <master-name> <script-path>
  sentinel notification-script mymaster /var/redis/notify.sh
 
# 客户端重新配置主节点参数脚本
# 当一个master由于failover而发生改变时，这个脚本将会被调用，通知相关的客户端关于master地址已经发生改变的信息。
# 以下参数将会在调用脚本时传给脚本:
# <master-name> <role> <state> <from-ip> <from-port> <to-ip> <to-port>
# 目前<state>总是“failover”,
# <role>是“leader”或者“observer”中的一个。 
# 参数 from-ip, from-port, to-ip, to-port是用来和旧的master和新的master(即旧的slave)通信的
# 这个脚本应该是通用的，能被多次调用，不是针对性的。

#一般都是运维来配置：
# sentinel client-reconfig-script <master-name> <script-path>
 sentinel client-reconfig-script mymaster /var/redis/reconfig.sh