springboot 整合redis的使用

最新推荐文章于 2025-02-26 10:08:13 发布

原创最新推荐文章于 2025-02-26 10:08:13 发布 · 163 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Redis #Springboot

redis 专栏收录该内容

3 篇文章

订阅专栏

本文详细介绍了如何在Spring Boot项目中整合Redis，包括Maven依赖配置、application.properties配置、自定义Redis配置类、Redis工具类的实现及测试方法。通过本文，读者可以学会如何在项目中高效地使用Redis进行数据缓存。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一：Maven依赖

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

二：application.properties

##redis
#默认是0号数据库
spring.redis.database=0
spring.redis.host=localhost
#连接端口
spring.redis.port=6379
#连接密码默认空
spring.redis.password=
#连接池最大连接数(使用负值表示没有限制)
spring.redis.pool.max-active=200
#连接池最大阻塞等待时间 (使用负值表示没有限制)
spring.redis.pool.max-wait=-1
#连接池中的最大空闲连接
spring.redis.pool.max-idle=10
#连接池中的最小空闲连接
spring.redis.pool.min-idle=0
#连接超时时间(毫秒)
spring.redis.timeout=1000

三：一个redis的配置类

@Configuration
public class RedisConfig {

   @Bean
   @SuppressWarnings("all")
   public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
       RedisTemplate<String, Object> template = new RedisTemplate<>();
       template.setConnectionFactory(factory);
       Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);

       ObjectMapper om = new ObjectMapper();
       om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);

       om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

       jackson2JsonRedisSerializer.setObjectMapper(om);

       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;
   }

}

四：Redis工具类

@Component
public class RedisUtil {

   @Autowired
   private RedisTemplate<String, Object> redisTemplate;

   /**
   * 指定缓存失效时间
   */
   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 获取过期时间
   *
   */
   public long getExpire(String key) {
       return redisTemplate.getExpire(key, TimeUnit.SECONDS);
   }

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

   /**
   * 删除缓存
   */
   @SuppressWarnings("unchecked")
   public void del(String... key) {
       if (key != null && key.length > 0) {
           redisTemplate.delete(key[0]);
       } else {
           redisTemplate.delete(CollectionUtils.arrayToList(key));
       }
   }

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

   /**
   * 普通缓存放入
   */
   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);

   }
}

五：测试

public class RedisTest {

   private Logger logger = LoggerFactory.getLogger(RedisTest.class);

   @Autowired
   RedisUtil redisUtil;

   @Test
   public void test() {
       boolean isok = redisUtil.set("spRedis", "增加一条信息");
       if (isok) {
           logger.info("插入redis成功 ");
       } else {
           logger.info("插入redis失败");
       }
   }

}