• docker系列6：docker安装redis

    传送门

    docker系列1：docker安装

    docker系列2：阿里云镜像加速器

     docker系列3：docker镜像基本命令

    docker系列4：docker容器基本命令

    docker系列5：docker安装nginx

    Docker安装redis

    通过前面4节，对docker有了一个基本了解，包括环境安装及镜像与容器的相关操作命令。

    在上一节通过docker安装nginx来体验了一下docker安装的便捷之处，现在通过docker来试试安装redis吧！

    之前通过手工的方式安装过单机版本的redis，步骤还是比较烦琐，那么通过docker安装呢？还是参考nginx安装的流程，首先确定redis的版本！

    确定版本

    之前在linux服务器上面安装了的linux版本较高，后来ECS服务器到期释放了。最后都是直接用的windows上面的，版本较低：

    这次就直接上最新的，通过docker在docker hub上面查找： 

    拉取镜像

    确定了redis版本，就可以进行镜像的下载了。

    执行拉取redis镜像

    如上讨论，选择redis最新版本来安装，执行命令docker pull redis：

     docker pull redis

    然后下载成功会显示类似如下信息： 

    查看nginx镜像

    然后再执行镜像查看命令docker images： 

    运行redis

    现在到了第3步了，那就是通过docker来运行redis！

    执行启动redis命令

    这里注意的是，因为选择是最新版本了，所以运行的时候：

    docker run -it -d --name test_redis redis /bin/bash

    查看运行结果

    执行之后，可以docker ps来查看一下：

    验证redis

    经过了上面的三步曲，现在来验证一下redis是否安装成功！可以通过访问服务来验证：

    因为是阿里云服务器， redis默认的端口是6379，直接用客户端工具连接会发现失败了！

    这个原因在就在于容器的端口没有跟服务器端口进行映射！

    端口映射

    把上面的命令稍作修改，并重新启动成功！

    docker run -it -d --name test_redis redis -p 6379:6379 /bin/bash

    端口开放

    注意服务器的端口需要开放，如果是云服务器还在安全组设置一下

    配置文件redis.conf

    在使用Docker容器时，有时候需要对Redis进行配置，但是Docker镜像中并没有默认的redis.conf，如何设置该文件参考docker没有redis.conf，及redis的下载地址，最终命令：

    docker run --name test_redis -p 6379:6379 -v /root/redis/redis.conf:/usr/local/etc/redis/redis.conf -d redis

    再次验证连接信息，显示成功！

    JAVA集成redis

    当redis搭建好之后，可以通过java连接！还是用原来的tsm工程来测试，因为是springboot框架，所以使用spring-boot-starter-data-redis组件。

    pom坐标

    1. <dependency>
    2.             <groupId>org.springframework.bootgroupId>
    3.             <artifactId>spring-boot-starter-data-redisartifactId>
    4.             <version>3.1.3version>
    5.         dependency>
    6.  
    7.         
    8.         <dependency>
    9.             <groupId>org.apache.commonsgroupId>
    10.             <artifactId>commons-pool2artifactId>
    11.         dependency>

    配置文件

    这里使用上面docker搭建的redis，在application.properties文件里面配置如下：

    1. # ====================================================================================
    2. # spring-redis
    3. # ====================================================================================
    4. # 若没有密码，则需要注释这个配置项
    5. # spring.redis.password=
    6. spring.redis.timeout=10000
    7.  
    8. # 单机，替换成实际的连接地址
    9. spring.redis.host=127.0.0.1
    10. spring.redis.port=6379
    11.  
    12.  
    13. spring.redis.lettuce.pool.max-active=8
    14. spring.redis.lettuce.pool.max-wait=-1
    15. spring.redis.lettuce.pool.min-idle=0
    16. spring.redis.lettuce.pool.max-idle=8

    配置类

     这个组件主要是使用RedisTemplate，主要配置文件如下：

    1. import org.springframework.context.annotation.Bean;
    2. import org.springframework.context.annotation.Configuration;
    3. import org.springframework.data.redis.connection.RedisConnectionFactory;
    4. import org.springframework.data.redis.core.RedisTemplate;
    5. import org.springframework.data.redis.core.StringRedisTemplate;
    6. import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
    7. import org.springframework.data.redis.serializer.StringRedisSerializer;
    8.  
    9. @Configuration
    10. public class RedisConfiguration
    11. {
    12.     
    13.     /**
    14.      * spring-boot-autoconfigure的RedisAutoConfiguration自动注册的RedisTemplate，使用的序列化器为默人的JdkSerializationRedisSerializer，序列化后生成的是不利于阅读的编码字符串。
    15.      * 所以我们手动注册一个RedisTemplate，设置RedisConnectionFactory属性为spring-boot-autoconfigure的JedisConnectionConfiguration/LettuceConnectionConfiguration自动注册的RedisConnectionFactory，并设置序列化器为StringRedisSerializer。
    16.      * 其实也可以直接在主启动类中使用@Autowired注入SpringBoot自动注册的RedisTemplate，并添加一个@PostConstruct的方法来修改它的序列化器为StringRedisSerializer。
    17.      */
    18.     @Bean
    19.     public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory)
    20.     {
    21.         final RedisTemplate template = new RedisTemplate<>();
    22.         // 设置ConnectionFactory，SpringBoot会自动注册ConnectionFactory-Bean
    23.         template.setConnectionFactory(redisConnectionFactory);
    24.         
    25.         // 设置序列化器为StringRedisSerializer（默认是 JdkSerializationRedisSerializer , java操作时会产生乱码）
    26.         StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
    27.         template.setKeySerializer(stringRedisSerializer);
    28.         template.setHashKeySerializer(stringRedisSerializer);
    29.         template.setHashValueSerializer(stringRedisSerializer);
    30.         
    31.         template.setValueSerializer(new JdkSerializationRedisSerializer());
    32.         template.afterPropertiesSet();
    33.         return template;
    34.     }
    35.  
    36.     /**
    37.      * 配置StringRedisTemplate
    38.      * @param factory
    39.      * @return
    40.      */
    41.     @Bean
    42.     public StringRedisTemplate stringRedisTemplate(
    43.             RedisConnectionFactory factory) {
    44.         StringRedisTemplate redisTemplate = new StringRedisTemplate();
    45.         redisTemplate.setConnectionFactory(factory);
    46.         redisTemplate.setKeySerializer(new StringRedisSerializer());
    47.         redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    48.         return redisTemplate;
    49.     }
    50. }

    操作工具类

    针对redis支持的数据类型，可以定制成工具类：

    1. import java.util.List;
    2. import java.util.Map;
    3. import java.util.Set;
    4. import java.util.concurrent.TimeUnit;
    5.  
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.data.redis.core.RedisTemplate;
    8. import org.springframework.stereotype.Component;
    9. import org.springframework.util.CollectionUtils;
    10.  
    11. @Component
    12. public class RedisUtil
    13. {
    14.     
    15.     @Autowired
    16.     private RedisTemplate redisTemplate;
    17.  
    18.     // =============================common============================
    19.     /**
    20.      * 指定缓存失效时间
    21.      * @param key 键
    22.      * @param time 时间(秒)
    23.      * @return
    24.      */
    25.     public boolean expire(String key, long time) {
    26.         try {
    27.             if (time > 0) {
    28.                 redisTemplate.expire(key, time, TimeUnit.SECONDS);
    29.             }
    30.             return true;
    31.         } catch (Exception e) {
    32.             e.printStackTrace();
    33.             return false;
    34.         }
    35.     }
    36.     /**
    37.      * 根据key 获取过期时间
    38.      * @param key 键 不能为null
    39.      * @return 时间(秒) 返回0代表为永久有效
    40.      */
    41.     public long getExpire(String key) {
    42.         return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    43.     }
    44.     /**
    45.      * 判断key是否存在
    46.      * @param key 键
    47.      * @return true 存在 false不存在
    48.      */
    49.     public boolean hasKey(String key) {
    50.         try {
    51.             return redisTemplate.hasKey(key);
    52.         } catch (Exception e) {
    53.             e.printStackTrace();
    54.             return false;
    55.         }
    56.     }
    57.     /**
    58.      * 删除缓存
    59.      * @param key 可以传一个值 或多个
    60.      */
    61.     @SuppressWarnings("unchecked")
    62.     public void del(String... key) {
    63.         if (key != null && key.length > 0) {
    64.             if (key.length == 1) {
    65.                 redisTemplate.delete(key[0]);
    66.             } else {
    67.                 redisTemplate.delete(CollectionUtils.arrayToList(key));
    68.             }
    69.         }
    70.     }
    71.     // ============================String=============================
    72.     /**
    73.      * 普通缓存获取
    74.      * @param key 键
    75.      * @return 值
    76.      */
    77.     public Object get(String key) {
    78.         return key == null ? null : redisTemplate.opsForValue().get(key);
    79.     }
    80.     /**
    81.      * 普通缓存放入
    82.      * @param key 键
    83.      * @param value 值
    84.      * @return true成功 false失败
    85.      */
    86.     public boolean set(String key, Object value) {
    87.         try {
    88.             redisTemplate.opsForValue().set(key, value);
    89.             return true;
    90.         } catch (Exception e) {
    91.             e.printStackTrace();
    92.             return false;
    93.         }
    94.     }
    95.     /**
    96.      * 普通缓存放入并设置时间
    97.      * @param key 键
    98.      * @param value 值
    99.      * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
    100.      * @return true成功 false 失败
    101.      */
    102.     public boolean set(String key, Object value, long time) {
    103.         try {
    104.             if (time > 0) {
    105.                 redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
    106.             } else {
    107.                 set(key, value);
    108.             }
    109.             return true;
    110.         } catch (Exception e) {
    111.             e.printStackTrace();
    112.             return false;
    113.         }
    114.     }
    115.     /**
    116.      * 递增
    117.      * @param key 键
    118.      * @param delta 要增加几(大于0)
    119.      * @return
    120.      */
    121.     public long incr(String key, long delta) {
    122.         if (delta < 0) {
    123.             throw new RuntimeException("递增因子必须大于0");
    124.         }
    125.         return redisTemplate.opsForValue().increment(key, delta);
    126.     }
    127.     /**
    128.      * 递减
    129.      * @param key 键
    130.      * @param delta 要减少几(小于0)
    131.      * @return
    132.      */
    133.     public long decr(String key, long delta) {
    134.         if (delta < 0) {
    135.             throw new RuntimeException("递减因子必须大于0");
    136.         }
    137.         return redisTemplate.opsForValue().increment(key, -delta);
    138.     }
    139.     // ================================Map=================================
    140.     /**
    141.      * HashGet
    142.      * @param key 键 不能为null
    143.      * @param item 项 不能为null
    144.      * @return 值
    145.      */
    146.     public Object hget(String key, String item) {
    147.         return redisTemplate.opsForHash().get(key, item);
    148.     }
    149.     /**
    150.      * 获取hashKey对应的所有键值
    151.      * @param key 键
    152.      * @return 对应的多个键值
    153.      */
    154.     public Map hmget(String key) {
    155.         return redisTemplate.opsForHash().entries(key);
    156.     }
    157.     /**
    158.      * HashSet
    159.      * @param key 键
    160.      * @param map 对应多个键值
    161.      * @return true 成功 false 失败
    162.      */
    163.     public boolean hmset(String key, Map map) {
    164.         try {
    165.             redisTemplate.opsForHash().putAll(key, map);
    166.             return true;
    167.         } catch (Exception e) {
    168.             e.printStackTrace();
    169.             return false;
    170.         }
    171.     }
    172.     /**
    173.      * HashSet 并设置时间
    174.      * @param key 键
    175.      * @param map 对应多个键值
    176.      * @param time 时间(秒)
    177.      * @return true成功 false失败
    178.      */
    179.     public boolean hmset(String key, Map map, long time) {
    180.         try {
    181.             redisTemplate.opsForHash().putAll(key, map);
    182.             if (time > 0) {
    183.                 expire(key, time);
    184.             }
    185.             return true;
    186.         } catch (Exception e) {
    187.             e.printStackTrace();
    188.             return false;
    189.         }
    190.     }
    191.     /**
    192.      * 向一张hash表中放入数据,如果不存在将创建
    193.      * @param key 键
    194.      * @param item 项
    195.      * @param value 值
    196.      * @return true 成功 false失败
    197.      */
    198.     public boolean hset(String key, String item, Object value) {
    199.         try {
    200.             redisTemplate.opsForHash().put(key, item, value);
    201.             return true;
    202.         } catch (Exception e) {
    203.             e.printStackTrace();
    204.             return false;
    205.         }
    206.     }
    207.     /**
    208.      * 向一张hash表中放入数据,如果不存在将创建
    209.      * @param key 键
    210.      * @param item 项
    211.      * @param value 值
    212.      * @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
    213.      * @return true 成功 false失败
    214.      */
    215.     public boolean hset(String key, String item, Object value, long time) {
    216.         try {
    217.             redisTemplate.opsForHash().put(key, item, value);
    218.             if (time > 0) {
    219.                 expire(key, time);
    220.             }
    221.             return true;
    222.         } catch (Exception e) {
    223.             e.printStackTrace();
    224.             return false;
    225.         }
    226.     }
    227.     /**
    228.      * 删除hash表中的值
    229.      * @param key 键 不能为null
    230.      * @param item 项 可以使多个 不能为null
    231.      */
    232.     public void hdel(String key, Object... item) {
    233.         redisTemplate.opsForHash().delete(key, item);
    234.     }
    235.     /**
    236.      * 判断hash表中是否有该项的值
    237.      * @param key 键 不能为null
    238.      * @param item 项 不能为null
    239.      * @return true 存在 false不存在
    240.      */
    241.     public boolean hHasKey(String key, String item) {
    242.         return redisTemplate.opsForHash().hasKey(key, item);
    243.     }
    244.     /**
    245.      * hash递增 如果不存在,就会创建一个 并把新增后的值返回
    246.      * @param key 键
    247.      * @param item 项
    248.      * @param by 要增加几(大于0)
    249.      * @return
    250.      */
    251.     public double hincr(String key, String item, double by) {
    252.         return redisTemplate.opsForHash().increment(key, item, by);
    253.     }
    254.     /**
    255.      * hash递减
    256.      * @param key 键
    257.      * @param item 项
    258.      * @param by 要减少记(小于0)
    259.      * @return
    260.      */
    261.     public double hdecr(String key, String item, double by) {
    262.         return redisTemplate.opsForHash().increment(key, item, -by);
    263.     }
    264.     // ============================set=============================
    265.     /**
    266.      * 根据key获取Set中的所有值
    267.      * @param key 键
    268.      * @return
    269.      */
    270.     public Set sGet(String key) {
    271.         try {
    272.             return redisTemplate.opsForSet().members(key);
    273.         } catch (Exception e) {
    274.             e.printStackTrace();
    275.             return null;
    276.         }
    277.     }
    278.     /**
    279.      * 根据value从一个set中查询,是否存在
    280.      * @param key 键
    281.      * @param value 值
    282.      * @return true 存在 false不存在
    283.      */
    284.     public boolean sHasKey(String key, Object value) {
    285.         try {
    286.             return redisTemplate.opsForSet().isMember(key, value);
    287.         } catch (Exception e) {
    288.             e.printStackTrace();
    289.             return false;
    290.         }
    291.     }
    292.     /**
    293.      * 将数据放入set缓存
    294.      * @param key 键
    295.      * @param values 值 可以是多个
    296.      * @return 成功个数
    297.      */
    298.     public long sSet(String key, Object... values) {
    299.         try {
    300.             return redisTemplate.opsForSet().add(key, values);
    301.         } catch (Exception e) {
    302.             e.printStackTrace();
    303.             return 0;
    304.         }
    305.     }
    306.     /**
    307.      * 将set数据放入缓存
    308.      * @param key 键
    309.      * @param time 时间(秒)
    310.      * @param values 值 可以是多个
    311.      * @return 成功个数
    312.      */
    313.     public long sSetAndTime(String key, long time, Object... values) {
    314.         try {
    315.             Long count = redisTemplate.opsForSet().add(key, values);
    316.             if (time > 0)
    317.                 expire(key, time);
    318.             return count;
    319.         } catch (Exception e) {
    320.             e.printStackTrace();
    321.             return 0;
    322.         }
    323.     }
    324.     /**
    325.      * 获取set缓存的长度
    326.      * @param key 键
    327.      * @return
    328.      */
    329.     public long sGetSetSize(String key) {
    330.         try {
    331.             return redisTemplate.opsForSet().size(key);
    332.         } catch (Exception e) {
    333.             e.printStackTrace();
    334.             return 0;
    335.         }
    336.     }
    337.     /**
    338.      * 移除值为value的
    339.      * @param key 键
    340.      * @param values 值 可以是多个
    341.      * @return 移除的个数
    342.      */
    343.     public long setRemove(String key, Object... values) {
    344.         try {
    345.             Long count = redisTemplate.opsForSet().remove(key, values);
    346.             return count;
    347.         } catch (Exception e) {
    348.             e.printStackTrace();
    349.             return 0;
    350.         }
    351.     }
    352.     // ===============================list=================================
    353.     /**
    354.      * 获取list缓存的内容
    355.      * @param key 键
    356.      * @param start 开始
    357.      * @param end 结束 0 到 -1代表所有值
    358.      * @return
    359.      */
    360.     public List lGet(String key, long start, long end) {
    361.         try {
    362.             return redisTemplate.opsForList().range(key, start, end);
    363.         } catch (Exception e) {
    364.             e.printStackTrace();
    365.             return null;
    366.         }
    367.     }
    368.     /**
    369.      * 获取list缓存的长度
    370.      * @param key 键
    371.      * @return
    372.      */
    373.     public long lGetListSize(String key) {
    374.         try {
    375.             return redisTemplate.opsForList().size(key);
    376.         } catch (Exception e) {
    377.             e.printStackTrace();
    378.             return 0;
    379.         }
    380.     }
    381.     /**
    382.      * 通过索引 获取list中的值
    383.      * @param key 键
    384.      * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
    385.      * @return
    386.      */
    387.     public Object lGetIndex(String key, long index) {
    388.         try {
    389.             return redisTemplate.opsForList().index(key, index);
    390.         } catch (Exception e) {
    391.             e.printStackTrace();
    392.             return null;
    393.         }
    394.     }
    395.     /**
    396.      * 将list放入缓存
    397.      * @param key 键
    398.      * @param value 值
    399.      * @param time 时间(秒)
    400.      * @return
    401.      */
    402.     public boolean lSet(String key, Object value) {
    403.         try {
    404.             redisTemplate.opsForList().rightPush(key, value);
    405.             return true;
    406.         } catch (Exception e) {
    407.             e.printStackTrace();
    408.             return false;
    409.         }
    410.     }
    411.     /**
    412.      * 将list放入缓存
    413.      * @param key 键
    414.      * @param value 值
    415.      * @param time 时间(秒)
    416.      * @return
    417.      */
    418.     public boolean lSet(String key, Object value, long time) {
    419.         try {
    420.             redisTemplate.opsForList().rightPush(key, value);
    421.             if (time > 0)
    422.                 expire(key, time);
    423.             return true;
    424.         } catch (Exception e) {
    425.             e.printStackTrace();
    426.             return false;
    427.         }
    428.     }
    429.     /**
    430.      * 将list放入缓存
    431.      * @param key 键
    432.      * @param value 值
    433.      * @param time 时间(秒)
    434.      * @return
    435.      */
    436.     public boolean lSet(String key, List value) {
    437.         try {
    438.             redisTemplate.opsForList().rightPushAll(key, value);
    439.             return true;
    440.         } catch (Exception e) {
    441.             e.printStackTrace();
    442.             return false;
    443.         }
    444.     }
    445.     /**
    446.      * 将list放入缓存
    447.      *
    448.      * @param key 键
    449.      * @param value 值
    450.      * @param time 时间(秒)
    451.      * @return
    452.      */
    453.     public boolean lSet(String key, List value, long time) {
    454.         try {
    455.             redisTemplate.opsForList().rightPushAll(key, value);
    456.             if (time > 0)
    457.                 expire(key, time);
    458.             return true;
    459.         } catch (Exception e) {
    460.             e.printStackTrace();
    461.             return false;
    462.         }
    463.     }
    464.     /**
    465.      * 根据索引修改list中的某条数据
    466.      * @param key 键
    467.      * @param index 索引
    468.      * @param value 值
    469.      * @return
    470.      */
    471.     public boolean lUpdateIndex(String key, long index, Object value) {
    472.         try {
    473.             redisTemplate.opsForList().set(key, index, value);
    474.             return true;
    475.         } catch (Exception e) {
    476.             e.printStackTrace();
    477.             return false;
    478.         }
    479.     }
    480.     /**
    481.      * 移除N个值为value
    482.      * @param key 键
    483.      * @param count 移除多少个
    484.      * @param value 值
    485.      * @return 移除的个数
    486.      */
    487.     public long lRemove(String key, long count, Object value) {
    488.         try {
    489.             Long remove = redisTemplate.opsForList().remove(key, count, value);
    490.             return remove;
    491.         } catch (Exception e) {
    492.             e.printStackTrace();
    493.             return 0;
    494.         }
    495.     }
    496. }
      497.  

      代码测试
       

      写一个测试类，如下：
       

      1. import com.tw.tsm.base.util.RedisUtil;
      2. import lombok.extern.slf4j.Slf4j;
      3. import org.springframework.beans.factory.annotation.Autowired;
      4. import org.springframework.web.bind.annotation.GetMapping;
      5. import org.springframework.web.bind.annotation.RequestMapping;
      6. import org.springframework.web.bind.annotation.RequestParam;
      7. import org.springframework.web.bind.annotation.RestController;
      8.  
      9. @RestController
      10. @Slf4j
      11. @RequestMapping("/redis")
      12. public class RedisTestController
      13. {
      14.     
      15.     @Autowired
      16.     private RedisUtil redisUtil;
      17.     
      18.     @GetMapping("/set")
      19.     public void testSet(@RequestParam("key") String key, @RequestParam("val") String val)
      20.     {
      21.         redisUtil.set(key, val);
      22.     }
      23.     
      24.     @GetMapping("/get")
      25.     public String testGet(@RequestParam("key") String key)
      26.     {
      27.         return (String)redisUtil.get(key);
      28.     }
      29. }
       

      
                
                    
                

                
    497. 

                    相关阅读:
      
                    
多层感知机与DNN算法                            
      
2022-中医基础-《阴阳 20问与答》                            
      
vue3相关内容                            
      
centos 7.7之后,无法远程ssh执行 java -jar 指令                            
      
C语言 memset                            
      
操作符详解                            
      
【剑指Offer】47. 礼物的最大价值                            
      
ES6-04-模块化的暴露：export关键字                            
      
机械硬盘HDD                            
      
多媒体展厅总包制作会面临的问题分析                            
      
                          
                
      498. 
                
    498. 
                    原文地址：https://blog.csdn.net/weigeshikebi/article/details/133575938
                
      499.