整合redis

最新推荐文章于 2024-11-21 17:20:36 发布
原创 最新推荐文章于 2024-11-21 17:20:36 发布 · 215 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文档展示了如何在Spring Boot项目中集成Redis，包括添加依赖、配置类的编写、YAML配置信息以及Redis工具类的实现，详细说明了缓存操作如设置、获取、过期时间处理等。

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

添加依赖
<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
添加配置类
/**
 * @Description: redis 配置类
 * @Param:
 * @return:
 * @Author: dongwei_qi
 * @Date: 2020/6/30
 */
@Configuration
class RedisConfig
{
  @Bean("redisTemplate")
  public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory)
  {
    RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
    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;
  }
}
application.yml 增加配置信息
# Redis数据库索引（默认为0）
  redis:
    database: 0
    # Redis服务器地址
    host: 127.0.0.1
    # Redis服务器连接端口
    port: 6379
    # Redis服务器连接密码（默认为空）
    password:
    # 连接池最大连接数（使用负值表示没有限制）
    pool.max-active: 200
    # 连接池最大阻塞等待时间（使用负值表示没有限制）
    pool.max-wait: -1
    # 连接池中的最大空闲连接
    pool.max-idle: 10
    # 连接池中的最小空闲连接
    pool.min-idle: 0
    # 连接超时时间（毫秒）
    timeout: 1000
redis 工具类

**
 * Redis工具类
 *
 * @author QI DONG WEI
 * @date 2018年6月7日
 */
@Component
public final class RedisUtil
{
  @Autowired
  private RedisTemplate<String, Object> 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 可以传一个值 或多个
   */
  @SuppressWarnings("unchecked")
  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 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);
  }

  /**
   * 根据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 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缓存的内容
   *
   * @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 0;
    }
  }

  /**
   * 通过索引 获取list中的值
   *
   * @param key   键
   * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
   */
  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 值
   */
  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 值
   */
  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 值
   */
  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;
    }
  }
}
【SpringBoot】17、SpringBoot中整合Redis实现热点数据缓存
Asurplus
08-03 20万+
本次，我们以IDEA + SpringBoot作为 Java中整合Redis的使用 的测试环境，如果对创建SpringBoot项目有不清楚的地方，可以参考我的博客！！！ 首先，我们需要导入Redis的maven依赖 <!-- Redis的maven依赖包 --> <dependency> <groupId>org.springframework.b...
mybatis二级缓存扩展-与redis集成
05-01
NULL 博文链接：https://zw7534313.iteye.com/blog/2404288
Mybatis-plus基于redis实现二级缓存过程解析
08-18
主要介绍了Mybatis-plus基于redis实现二级缓存过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
mybatis plus开启二级缓存
weixin_44643439的博客
02-18 8013
这mybatis plus开启二级缓存里写自定义目录标题新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 mybatis plus开启二级缓存 583 收藏 3 文章标签： 数据库 mybatis 版权 开启二级缓存 myb
【MybatisPlus】MybatisPlus开启二级缓存
杜小舟的博客
08-02 2210
MybatisPlus开启二级缓存
MybatisPlus二级缓存
Java知识图谱的博客
01-18 2187
一、序言 本文承接Mybatis缓存体系探究，提供基于MybatisPlus技术可用于生产环境下的二级缓存解决方案。 1、前置条件 掌握MyBatis二级缓存的原理 有关MyBatis缓存原理内容，参考Mybatis缓存体系探究 选择符合条件的MybatisPlus版本 本方案对MybatisPlus版本有严格的限制，使用版本不低于3.4.3.4，如果低于此版本，则无法满足生产环境条件下的闭环需求。 正确处理连接（多表）查询 正确的多表连接查询，请参考Mybatis..
springboot-mybatisplus-redis二级缓存
无bug无江湖
11-30 3037
springboot mybatisplus redis二级缓存
golang(gin)整合mysql,整合redis通用脚手架
04-06
再来看看如何整合Redis。Redis是一个内存数据结构存储系统，可以作为数据库、缓存和消息代理使用。在Go中，我们可以使用`go-redis`库来操作Redis。首先，通过`NewClient`创建客户端实例，然后就可以调用各种方法如`...
微服务SpringBoot整合Redis基于Redis的Stream消息队列实现异步秒杀下单
11-10
【微服务SpringBoot整合Redis基于Redis的Stream消息队列实现异步秒杀下单】这篇文章主要讲解了如何在微服务环境中，使用SpringBoot框架与Redis相结合，通过Redis的Stream功能来构建一个高效的消息队列，以实现异步...
ssm框架整合redis源码
05-15
在本项目中，"ssm框架整合redis源码"意味着开发者将SSM框架与Redis缓存系统进行了集成，主要目的是实现session共享。Session共享是Web应用中解决用户会话跨服务器问题的关键技术，尤其是在分布式环境下，确保用户...
Mybatis-plus 开启二级缓存
热门推荐
Csea的博客
12-04 1万+
Mybatis-plus 开启二级缓存 一、Ehcache、Redis比较 ​ ehcache是直接在jvm虚拟机中缓存，速度快，效率高；但是共享缓存麻烦，在分布式下显得功能弱； ​ redis是通过socket访问到缓存服务，效率比ehcache低，但是比访问数据库快；在处理分布式下共享缓存很方便，并且机制成熟。 ​ 单体应用可以采用ehcache，在大型应用场景下，分布式要求就采用redis。...
【缓存】MyBatis-Plus 通用接口添加二级缓存
我是Superman丶的博客
03-08 384
【缓存】MyBatis-Plus 通用接口添加二级缓存 重写对应的接口进行添加 供参考 可用注解方式
【Mybatis】Mybatis 二级缓存全详解教程
小电玩
04-08 4053
MyBatis-Plus（简称MP）是一个基于 MyBatis 的增强工具，它简化了 MyBatis 的开发，并且提供了许多便利的功能，帮助开发者更高效地进行持久层的开发。
MybatisPlus二级缓存配置redis(gradle)
jinxlzc的博客
10-20 444
MybatisPlus二级缓存配置redis 版本环境 IntelliJ IDEA:2020.1.2 java:jdk-14.0.1 springboot:v2.3.4.RELEASE gradle:gradle-6.7-rc-4 Redis server v=6.0.5 springfox(swagger):version: '3.0.0' swagger-bootstrap-ui:version: '1.9.6' mysql-connector-java:version: '8.0.16' mybati
MyBatis-Plus一级缓存和二级缓存-redis解决缓存的脏数据
tiger_Angle
06-16 4688
一级缓存：也称为本地缓存，基于 PerpetualCache 的 HashMap 本地缓存，其存储作用域为SqlSession，用于保存用户在一次会话过程中查询的结果，用户一次会话中只能使用一个sqlSession，各个SqlSession之间的缓存相互隔离，当 Session flush 或 close 之后，该 SqlSession 中的所有 Cache 就将清空，MyBatis默认打开一级缓存、不允许关闭。MyBatis包含一个非常强大的查询缓存特性，它可以非常方便地定制和配置缓存。
Mybatis-Plus用Redis做二级缓存
weixin_43740023的博客
06-29 1128
一,在properties或者yml文件开启二级缓存 #开启mybatis-plus二级缓存 mybatis-plus.configuration.cache-enabled=true 二,在Mapper类上添加CacheNamespace注解 @CacheNamespace(implementation= MybatisPlusRedisCache.class,eviction=MybatisPlusRedisCache.class) public interface StaffMapper..
Mybatis缓存的二级缓存
weixin_44560796的博客
05-01 323
像大多数的持久化框架一样，Mybatis 也提供了缓存策略，通过缓存策略来减少数据库的查询次数，从而提高性能。但是只适用于以下这两种数据：1、经常查询并且不经常改变的数据。2、数据的正确与否对最终结果影响不大的。例如：商品的库存，银行的汇率，股市的牌价等就不能使用Mybatis缓存。 Mybatis 中缓存分为一级缓存，二级缓存。上次说的是一级缓存，这次就来说一下二级缓存。 2.Mybatis 二级缓存 二级缓存是 mapper 映射级别的缓存，多个 SqlSession 去操作同一个 Mapper 映射
MyBatis一级缓存和二级缓存
最新发布
dragonhu的博客
11-21 463
MyBatis 缓存是 MyBatis 中非常重要的一个特性，它的作用是减少数据库的查询次数，提高系统性能。
【Mybatis扩展】Mybatis-Plus整合Redis实现二级缓存
秋装什么的博客
05-06 589
【Mybatis扩展】Mybatis-Plus整合Redis实现二级缓存
SpringMVC与Mybatis整合Redis实践教程
本文将详细阐述Spring MVC与MyBatis整合Redis的关键知识点。 ### 知识点一：Spring MVC框架简介 Spring MVC是Spring的一个模块，它是一个构建Web应用程序的全功能的MVC框架。Spring MVC通过将Web层进行分离，并将...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值