devbox
Monodyee
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

SpringBoot maven环境下整合redis_springboot maven redis

作者：Monodyee | 2024-04-20 14:02:38

赞

踩

springboot maven redis

一 前期准备

1.SpringBoot项目+maven环境
2.安装好redis服务，并启动(本教程适合 单机，集群，哨兵模式的redis服务)

二 配置依赖

  1.                 <!--redis依赖-->
  2. 		<dependency>
  3. 			<groupId>org.springframework.boot</groupId>
  4. 			<artifactId>spring-boot-starter-data-redis</artifactId>
  5. 		</dependency>
  6. 		<!--web开发支持-->
  7. 		<dependency>
  8. 			<groupId>org.springframework.boot</groupId>
  9. 			<artifactId>spring-boot-starter-web</artifactId>
  10. 		</dependency>
  11.                 <!--测试支持-->
  12. 		<dependency>
  13. 			<groupId>org.springframework.boot</groupId>
  14. 			<artifactId>spring-boot-starter-test</artifactId>
  15. 			<scope>test</scope>
  16. 		</dependency>

备注：eclipse通过sts SpringBoot 构建工具添加 web 与 nosql-redis  此依赖可以自动生成

          idea 通过 Spring Initializr 也可以选定 web 与 nosql-redis 此依赖可以自动生成


三 redis配置

1.项目目录结构


2.SpringBoot 配置文件 配置redis 信息

  1. #========== 服务器 配置信息===========#
  2. #服务器端口映射
  3. server.port=8099
  4. #服务项目名
  5. server.servlet.path=/SpringBoot-redis
  6.  
  7. #==========redis 配置信息===========#
  8.  
  9. #（单机redis）数据库ip
  10. #spring.redis.host=127.0.0.1
  11. #（单机redis）数据库端口
  12. #spring.redis.port= 6379
  13.  
  14. #（cluster集群，不使用则不用开启）在群集中执行命令时要遵循的最大重定向数目。
  15. spring.redis.cluster.max-redirects=3
  16. #（cluster集群，不使用则不用开启）以逗号分隔的“主机：端口”对列表进行引导。
  17. spring.redis.cluster.nodes=127.0.0.1:7000,127.0.0.1:7001,127.0.0.1:7002,127.0.0.1:7003,127.0.0.1:7004,127.0.0.1:7005
  18.  
  19. #（哨兵模式，不使用则不用开启）Redis服务器的名称。
  20. # spring.redis.sentinel.master=
  21. #（哨兵模式，不使用则不用开启）主机：端口对的逗号分隔列表。
  22. # spring.redis.sentinel.nodes=
  23.  
  24. #数据库指定索引
  25. spring.redis.database= 1
  26. #数据库密码
  27. spring.redis.password=
  28. #超时时间
  29. spring.redis.timeout= 5000
  30. #连接池最大连接数，负值表示不限制
  31. spring.redis.jedis.pool.max-active= 1000
  32. #连接池中最大空闲连接
  33. spring.redis.jedis.pool.max-idle= 10
  34. #连接池中最小空闲连接
  35. spring.redis.jedis.pool.min-idle= 2
  36. #连接池最大阻塞等待时间，负值表示不限制
  37. spring.redis.jedis.pool.max-wait= -1
  38.

3.redis配置集

RedisUtil.java

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

备注：此工具类包含大部分操作。


RedisConfig.java

  1. package com.zyj.redis;
  2.  
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.data.redis.connection.RedisConnectionFactory;
  6. import org.springframework.data.redis.core.RedisTemplate;
  7. import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
  8. import org.springframework.data.redis.serializer.StringRedisSerializer;
  9.  
  10. /**
  11. *@Description: redis配置文件
  12. *@Author: zyj 2018/5/26 8:06
  13. */
  14. @Configuration
  15. public class RedisConfig {
  16.  
  17.     /**
  18.      * 实例化 RedisTemplate 对象
  19.      * 提供给 RedisUtil 使用
  20.      * @param redisConnectionFactory springboot配置好的连接工厂
  21.      * @return RedisTemplate
  22.      * @autor zyj
  23.      * @date 2018年5月26日 08:47:27
  24.      */
  25.     @Bean
  26.     public RedisTemplate<String, Object> RedisTemplate(RedisConnectionFactory redisConnectionFactory) {
  27.         RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
  28.         initRedisTemplate(redisTemplate, redisConnectionFactory);
  29.         return redisTemplate;
  30.     }
  31.     /**
  32.      * 设置数据存入 redis 的序列化方式,并开启事务
  33.      *
  34.      * @param redisTemplate
  35.      * @param factory
  36.      * @autor zyj
  37.      * @date 2018年5月26日 08:47:27
  38.      */
  39.     private void initRedisTemplate(RedisTemplate<String, Object> redisTemplate, RedisConnectionFactory factory) {
  40.         //如果不配置Serializer，那么存储的时候缺省使用String，如果用User类型存储，那么会提示错误User can't cast to String！
  41.         redisTemplate.setKeySerializer(new StringRedisSerializer());
  42.         redisTemplate.setHashKeySerializer(new StringRedisSerializer());
  43.         redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
  44.         redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
  45.         // 开启事务
  46.         redisTemplate.setEnableTransactionSupport(true);
  47.         redisTemplate.setConnectionFactory(factory);
  48.     }
  49.  
  50.     /**
  51.      * 注入封装RedisTemplate 给RedisUtil提供操作类
  52.      * @param redisTemplate
  53.      * @return RedisUtil
  54.      * @autor zyj
  55.      * @date 2018年5月26日 08:47:27
  56.      */
  57.     @Bean(name = "redisUtil")
  58.     public RedisUtil redisUtil(RedisTemplate<String, Object> redisTemplate) {
  59.         RedisUtil redisUtil = new RedisUtil();
  60.         redisUtil.setRedisTemplate(redisTemplate);
  61.         return redisUtil;
  62.     }
  63. }

备注：此类配置了redis的操作对象 RedisTemplate并将RedisUtil实例化到容器中

四 redis测试

1.建立测试类

  1. package com.zyj.redis;
  2.  
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.stereotype.Controller;
  5. import org.springframework.web.bind.annotation.RequestMapping;
  6. import org.springframework.web.bind.annotation.ResponseBody;
  7.  
  8.  
  9. /**
  10. *@Description: redis 测试
  11. *@Author: zyj 2018/5/26 8:12
  12. */
  13. @Controller
  14. @RequestMapping("/redisTest")
  15. public class RedisTestController {
  16.  
  17.     @Autowired
  18.     RedisUtil redisUtil;
  19.  
  20.     /**
  21.     *@Description: 测试redis
  22.     *@param key, value
  23.     *@return Object
  24.     *@Author: zyj 2018/5/26 8:46
  25.     */
  26.     @RequestMapping("/testRedisAdd")
  27.     @ResponseBody
  28.     Object testRedisAdd(String key,String value){
  29.         redisUtil.set(key,value);
  30.         return redisUtil.get(key);
  31.     }
  32.  
  33. }

2.测试

启动springBoot项目SpringbootRedisApplication，网址中输入

http://localhost:8099/SpringBoot-redis/redisTest/testRedisAdd?key=1&value=244


备注：http：//服务器ip：端口/服务器跟路径/测试类控制器/测试方法？参数1= &参数2= 


3.验证

使用redis客户端连接redis服务


依次验证数据



祝你成功！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/457674
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号