SpringBoot整合redis

最新推荐文章于 2024-03-20 19:27:34 发布
最新推荐文章于 2024-03-20 19:27:34 发布
阅读量98 收藏
点赞数
分类专栏： java框架整合 文章标签： java redis spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21998021/article/details/118786453
版权

一、介绍

  • SpringBoot提供了Spring-data-redis的整合方法，整合了redisTemplate等调用方法和jedis连接池的实现，无须像SpringMVC进行繁琐的xml配置，配置全部在application.properties中完成。同时，Spring-Session-redis的整合也可以使用相同的配置项。

二、框架搭建

  • redis环境，自行搭建，参考

    https://redis.io/

  • 引入pom

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

  • application.properties配置项中添加如下配置：

      ########################################################
  ###Redis连接配置
  ########################################################
  ##Redis数据库索引（默认为0）
  spring.redis.database=2
  spring.redis.host=127.0.0.1
  spring.redis.port=6380
  spring.redis.password=test2016
  ## 连接池中的最大空闲连接
  spring.redis.pool.max-idle=2000
  ## 连接池中的最小空闲连接
  spring.redis.pool.min-idle=1
  ## 连接池最大连接数（使用负值表示没有限制）
  spring.redis.pool.max-active=1000
  ## 连接池最大阻塞等待时间（使用负值表示没有限制）
  spring.redis.pool.max-wait=-1
  ## 连接超时时间（毫秒）
  spring.redis.timeout=100000

三、 基础配置

  • 创建配置类，@EnableCaching注解启用缓存；这里务必对key和value的序列化方式进行定义，否则存储redis时会处理乱码情况。

      import org.springframework.cache.CacheManager;
  import org.springframework.cache.annotation.CachingConfigurerSupport;
  import org.springframework.cache.annotation.EnableCaching;
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;
  import org.springframework.data.redis.cache.RedisCacheManager;
  import org.springframework.data.redis.connection.RedisConnectionFactory;
  import org.springframework.data.redis.core.RedisTemplate;
  import org.springframework.data.redis.core.StringRedisTemplate;
  import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
  
  import com.fasterxml.jackson.databind.ObjectMapper;
  
  /**
   * @author xiaojin_wu
   * @email wuxiaojin258@126.com
   * @date 2018年3月13日
   * @description redis缓存管理
   */
  @Configuration
  @EnableCaching//启用缓存
  public class RedisConfig extends CachingConfigurerSupport{
      
      /**	springboot注入连接池	*/
  	@Autowired  
      private JedisConnectionFactory jedisConnectionFactory;
      
      @SuppressWarnings("rawtypes")
  	@Bean
      public CacheManager cacheManager(RedisTemplate redisTemplate) {
          RedisCacheManager rcm = new RedisCacheManager(redisTemplate);
          return rcm;
      }
      /**
       * RedisTemplate配置
       * @param factory
       * @return
       */
      @SuppressWarnings({ "rawtypes", "unchecked" })
  	@Bean
      public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory factory) {
          RedisTemplate template = new StringRedisTemplate(factory);
          //定义value的序列化方式
          Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
          ObjectMapper om = new ObjectMapper();
          om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
          jackson2JsonRedisSerializer.setObjectMapper(om);
          
         // template.setKeySerializer(redisSerializer);
          template.setValueSerializer(jackson2JsonRedisSerializer);
          template.setHashValueSerializer(jackson2JsonRedisSerializer);
          //设置连接池
          template.setConnectionFactory(jedisConnectionFactory);
          template.afterPropertiesSet();
          return template;
      }
      
  
  }

四、基础封装

  • 创建redis服务

     import java.util.Set;
 import java.util.concurrent.TimeUnit;
 
 /**
  * @author 
  * 		xiaojin_wu
  * @email 
  * 		wuxiaojin258@126.com
  * @date 
  * 		2018年1月31日
  * @description 
  * 		redis服务
  */
 public interface IRedisService {
 	
 	/**
      * 根据指定key获取String
      * @param key
      * @return
      */
     public String get(String key);
     
     /**
      * 设置Str缓存
      * @param key
      * @param val
      */
     public void set(String key, String val);
     
     /**
      * 设置Str缓存
      * @param key
      * @param val
      * @param 有效时间,单位：秒
      */
     public void set(String key, String val,long validTime);
     
     /**
      * 设置Str缓存
      * @param key
      * @param val
      * @param validTime 
      * 			有效时间,单位：秒
      * @param unit 
      * 			缓存生效时间单位，java.util.concurrent.TimeUnit定义有静态时间单位常量
      */
     public void set(String key, String val,long validTime,TimeUnit unit);
     
     /**
      * 删除指定key
      * @param key
      */
     public void del(String key);
     
     /**
      * 根据指定o获取Object
      * @param o
      * @return
      */
     public Object getObject(Object o);
     
     /**
      * 设置obj缓存
      * @param o1
      * @param o2
      */
     public void setObject(Object o1, Object o2);
     
     /**
      * 删除Obj缓存
      * @param o
      */
     public void delObject(Object o);
     
     /**
      * 根据规则查询集合，通过keys命令查询
      * @deprecated 线上环境性能差，废弃
      * @param pattern
      */
     @Deprecated
     public Set<String> getStringByPattern(String pattern);	
     
     /**
      * 根据规则查询集合，通过keys命令查询
      * @deprecated 线上环境性能差，废弃
      * @param pattern
      */
     @Deprecated
     public Set<Object> getObjectByPattern(String pattern);
     
     /**
      * 存储obj缓存并设置生效时间
      * @param o1
      * @param o2
      */
     public void setObject(Object key, Object val,long validTime,TimeUnit unit);
     
     /**
      * 操作列表进行rightpush
      * @param key
      * @param value
      */
     public void rightPush(Object key,Object value);
     
     /**
      * 操作列表进行leftPush
      * @param key
      * @param value
      */
     public void leftPush(Object key,Object value);
     
     /**
      * 操作列表进行leftPop
      * @param key
      */
     public void leftPop(Object key);
     
     /**
      * 操作列表进行rightPop
      * @param key
      */
     public void rightPop(Object key);
     
     /**
      * 操作列表，分页读取数据
      * @param key
      * @param start
      * @param end
      * @return
      */
     public List<?> range(Object key,long start,long end);
     
     /**
      * 操作列表，读取所有数据
      * @param key
      * @return
      */
     public List<?> rangeAll(Object key);
     
     /**
      * leftPushAll存储数组
      */
     public long leftPushAll(Object key,Object list);
     
     /**
      * rightPushAll存储数组
      */
     public long rightPushAll(Object key,Object list);
     
     /**
      * leftpush存储数组
      * @param key
      * @param list
      */
     public void pushAllToList(Object key,List<?> list,long validtime,TimeUnit unit);
     
     /**
      * 获取有效时间
      * @param key
      * @return
      */
     public long getValidTime(Object key,TimeUnit unit);
     
     /**
      * 使用redis的scan命令迭代进行模糊查询key集合，用于替换keys命令
      * @param pattern
      * 			模糊匹配的字符串
      * @author xiaojin_wu
      * @return
      * 			模糊匹配的key集合
      */
     public Set<String> getListByScan(String pattern);
 }

  • 创建redis服务实现类，通过注解自动注入redisTemplate和StringRedisTemplate;此处封装了部分hash操作和list操作。

     import java.util.NoSuchElementException;
 import java.util.Set;
 import java.util.concurrent.TimeUnit;
 
 import javax.annotation.Resource;
 
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.dao.DataAccessException;
 import org.springframework.data.redis.connection.RedisConnection;
 import org.springframework.data.redis.core.Cursor;
 import org.springframework.data.redis.core.RedisCallback;
 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.data.redis.core.ScanOptions;
 import org.springframework.data.redis.core.StringRedisTemplate;
 import org.springframework.data.redis.core.ValueOperations;
 
 import com.akucun.applets.common.redis.IRedisService;
 
 /**
  * @author xiaojin_wu
  * @email wuxiaojin258@126.com
  * @date 2018年1月31日
  * @description redis公用方法实现类
  */
 // @Service(version = "1.0.0")
 @org.springframework.stereotype.Service
 public class RedisServiceImpl implements IRedisService {
 
 	@Autowired
 	StringRedisTemplate stringRedisTemplate;
 
 	@Resource(name = "stringRedisTemplate")
 	ValueOperations<String, String> valOpsStr;
 
 	@Autowired
 	RedisTemplate<Object, Object> redisTemplate;
 
 	@Resource(name = "redisTemplate")
 	ValueOperations<Object, Object> valOpsObj;
 
 	/**
 	 * 根据指定key获取String
 	 *
 	 * @param key
 	 * @return
 	 */
 	public String get(String key) {
 		return valOpsStr.get(key);
 	}
 
 	/**
 	 * 设置Str缓存
 	 *
 	 * @param key
 	 * @param val
 	 */
 	public void set(String key, String val) {
 		valOpsStr.set(key, val);
 	}
 
 	/**
 	 * 设置Str缓存
 	 *
 	 * @param key
 	 * @param val
 	 * @param 有效时间,单位：秒
 	 * @description void set(K key, V value, long offset); 这个api是设置从头开始 偏移多少位 void
 	 *              set(K key, V value, long timeout, TimeUnit unit); 这个api才是过期时间
 	 */
 	public void set(String key, String val, long validTime) {
 		valOpsStr.set(key, val, validTime, TimeUnit.SECONDS);
 	}
 
 	/**
 	 * 设置Str缓存
 	 *
 	 * @param key
 	 * @param val
 	 * @param validTime
 	 *            有效时间
 	 * @param unit
 	 *            缓存生效时间单位，java.util.concurrent.TimeUnit定义有静态时间单位常量
 	 */
 	public void set(String key, String val, long validTime, TimeUnit unit) {
 		valOpsStr.set(key, val, validTime, unit);
 	}
 
 	/**
 	 * 删除指定key
 	 *
 	 * @param key
 	 */
 	public void del(String key) {
 		stringRedisTemplate.delete(key);
 	}
 
 	/**
 	 * 根据指定o获取Object
 	 *
 	 * @param o
 	 * @return
 	 */
 	public Object getObject(Object o) {
 		return valOpsObj.get(o);
 	}
 
 	/**
 	 * 设置obj缓存
 	 *
 	 * @param o1
 	 * @param o2
 	 */
 	public void setObject(Object o1, Object o2) {
 		valOpsObj.set(o1, o2);
 	}
 
 	/**
 	 * 删除Obj缓存
 	 *
 	 * @param o
 	 */
 	public void delObject(Object o) {
 		redisTemplate.delete(o);
 	}
 
 	@Override
 	@Deprecated
 	public Set<String> getStringByPattern(String pattern) {
 		return stringRedisTemplate.keys("*" + pattern + "*");
 	}
 
 	@Override
 	public void setObject(Object key, Object val, long validTime, TimeUnit unit) {
 		valOpsObj.set(key, val, validTime, unit);
 	}
 
 	@Override
 	@Deprecated
 	public Set<Object> getObjectByPattern(String pattern) {
 		return redisTemplate.keys("*" + pattern + "*");
 	}
 
 	@Override
 	public void rightPush(Object key, Object value) {
 		redisTemplate.opsForList().leftPush(key, value);
 	}
 
 	@Override
 	public void leftPush(Object key, Object value) {
 		redisTemplate.opsForList().leftPush(key, value);
 	}
 
 	@Override
 	public void leftPop(Object key) {
 		redisTemplate.opsForList().leftPop(key);
 	}
 
 	@Override
 	public void rightPop(Object key) {
 		redisTemplate.opsForList().rightPop(key);
 	}
 
 	@Override
 	public List<?> range(Object key, long start, long end) {
 		return redisTemplate.opsForList().range(key, start, end);
 	}
 
 	@Override
 	public List<?> rangeAll(Object key) {
 		return redisTemplate.opsForList().range(key, 0, -1);
 	}
 
 	@Override
 	public long leftPushAll(Object key, Object list) {
 		return redisTemplate.opsForList().leftPushAll(key, list);
 	}
 
 	@Override
 	public long rightPushAll(Object key, Object list) {
 		return redisTemplate.opsForList().rightPushAll(key, list);
 	}
 
 	@Override
 	public void pushAllToList(Object key, List<?> list, long validtime, TimeUnit unit) {
 		for (Object object : list) {
 			leftPush(key, object);
 		}
 		redisTemplate.expire(key, validtime, unit);
 	}
 
 	@Override
 	public long getValidTime(Object key, TimeUnit unit) {
 		return redisTemplate.getExpire(key, unit);
 	}
 
 	@Override
 	public Set<String> getListByScan(String pattern) {
 		
 		
 
 		Set<String> set = new HashSet<>();
 		long count = 100;//初始化迭代增量
 		redisTemplate.execute(new RedisCallback<Iterable<byte[]>>() {
 
 			@Override
 			public Iterable<byte[]> doInRedis(RedisConnection connection) throws DataAccessException {
 
 				ScanOptions options = ScanOptions.scanOptions().match(pattern+"*").count(count).build();
 				boolean done = false;
 				// while循环确保能够获取到有效的cursor
 				while (!done) {
 					Cursor<byte[]> cursor = connection.scan(options);
 					try {
 						while (cursor.hasNext()) {
 							String key = new String(cursor.next());
 							set.add(key);
 						}
 						done = true; // we've made it here, lets go away
 					} catch (NoSuchElementException nse) {
 						System.out.println("使用"+count+"条进行迭代增量不足，加倍进行迭代");
 						options = ScanOptions.scanOptions().match(pattern).count(count * 2).build();
 					} finally {
 						connection.close();
 					}
 				}
 
 				return null;
 			}
 		});
 		return set;
 
 	}
 
 }

五、使用注意

  • hash操作使用stringRedisTemplate

  • list、set等redis提供的数据结构操作使用redisTemplate

  • redis的key值命名推荐使用‘：’区分业务，在RedisDesktopManager远程连接redis的工具上会对redis存储的值进行分包分类，便于维护

  • 对redis的key值进行模糊查询是，禁止使用keys命令，此处封装了scan的方式通过迭代进行模糊匹配

  • redis的scan命令会查询出重复记录，因此使用set存储查询结果集，参考：

    http://www.redis.cn/commands/scan.html

qq_21998021
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring boot整合redis
qq_41743601的博客
12-28 592
spring boot整合redis 文章目录spring boot整合redis安装启动redis服务连接redis服务基于注解整合redis常用的几个注解注意点：基于api的Redis缓存实现 安装 redis下载地址 启动redis服务 可以双击redis-server.exe文件，也可以进入改目录，使用命令启动服务 连接redis服务 进入redis安装目录，使用以下命令连接： redis-cli.exe -h 127.0.0.1 -p 6379 基于注解整合redis 1.添加red
redis入门系列（四）
jaychouandkobe的专栏
05-19 494
常见面试问题 ①reids如何从海量数据查询某些特定的key？ ②redis如何批量删除key？ keys命令 今天我们来看看redis的keys常见相关命令，我们可以看下面的表格： 命令 描述 DEL key 该命令用于在 key 存在时删除 key。 EXISTS key 检查给定 key 是否存在。 EXPIRE key seconds 为给定 key 设置过期时间，以秒计。 EXPIREAT key timestamp EXPIREAT 的作用和 EXPIRE 类
redis scan命令详解
只为成功找方法 不为失败找借口
08-21 2028
翻译自：https://redis.io/commands/scan 使用SCAN命令和与之密切相关的命令SSCAN，HSCAN和ZSCAN以便逐步迭代元素集合。 SCAN迭代当前选择的Redis数据库中的密钥集。 SSCAN迭代Sets类型的元素。 HSCAN迭代Hash类型的字段及其关联的值。 ZSCAN迭代“排序集”类型的元素及其关联的分数。 由于这些命令允许增量迭代，每次调用仅返回少量元素，因此可以在生产中使用它们，而不会受到诸如KEYS或SMEMBERS之类的命令的不利影响，这些命令在被
【Redis】4、Scan 命令
最新发布
呆呆的猫的博客
03-20 2163
SCAN 命令
redis操作
cxm19830125的专栏
03-11 207
/data/redis/bin/redis-cli -c -h 10.1.58.13 -p 27001 05C01A2791430B7B get site_info_PF100N190710340C PF100N190710342% get terminal_PF100N190710340C get site_overview_PF100N190710340C del site_info_PF100N190310632R
Redis开发与运维读书笔记-第三章-实用功能介绍(一)
enjoycoding悦码
09-14 683
Redis提供的5种数据结构已经足够强大，但除此之外，Redis还提供了 诸如慢查询分析、功能强大的Redis Shell、Pipeline、事务与Lua脚本、 Bitmaps、HyperLogLog、发布订阅、GEO等附加功能，这些功能可以在某些场景发挥重要的作用，本章将介绍如下内容：·慢查询分析：通过慢查询分析，找到有问题的命令进行优化。·Redis Shell：功能强大的Redis Shel...
springboot整合redis代码
05-14
springboot整合redis.算是比较全面的一种整合方式了. springboot整合redis.算是比较全面的一种整合方式了.
SpringBoot整合Redis
01-17
SpringBoot整合Redis缓存，主要采用注解的方式来整合Redis，使用@Cacheable、@CacheEvit、@Caching等注解
springboot整合redis集群（三种方式）源码
04-01
springboot整合redis集群（三种方式）源码
SpringBoot 整合 Redis、mybatis 完整项目源码下载
05-26
SpringBoot整合Redis源码 mybatis实战源码 封装RedisUtils工具类源码 redis缓存mybatis数据源码
微服务SpringBoot整合Redis基于Redis的Stream消息队列实现异步秒杀下单
11-10
资源微服务SpringBoot整合Redis基于Redis的Stream消息队列实现异步秒杀下单知识分享
Redis的scan命令
zzhongcy的专栏
03-26 4007
最近研究redis大数据处理，网上查了查资料，这里记录一下。 在 redis 实际使用中，会遇到一个问题：如何从海量的 key 中找出满足特定前缀的 key 列表来？ 1. 不要使用 keys* redis 提供了一个简单暴力的指令 keys 用来列出所有满足特定正则字符串规则的 key。 keys xxx* 这个指令有致命的弊端，在实际环境中最好不要使用： 这个指令没有 ...
封装scan方法进行redis模糊查询
minihuabei的博客
12-07 656
封装scan方法进行redis模糊查询 public function redisScan($pattern, $count = 1000){ $redis = new \myredis\Datasource(); $myredis = $redis::getRedis('instance1'); $ret = []; $iterator = 0; while (true) { $result =
redis使用--pattern选项遍历查询
huangbaokang的博客
03-05 3172
bin/redis-cli --scan --pattern 'session:*7ab0'
SpringBoot集成redis出现的错误
大神，带带我的博客
11-28 2099
1.Failed opening the RDB file dump.rdb (in server root dir /usr/local/db) for saving: Permission denied 出现上述的原因是更改了redis.conf中的如下，导致了该文件夹没有权限，将db权限更改即可解决。chmoe 755 db # The working directory. ...
redis中 scan实现模糊查询
初夏0811的博客
07-17 4344
一、scan前言 从Redis v2.8开始，scan命令已经可用，它允许使用游标从keyspace中检索键。 对比keys命令，虽然scan无法一次性返回所有匹配结果，但是却规避了阻塞系统这个高风险，从而也让一些操作可以放在主节点上执行。 二.scan相关命令 scan相关命令包括sscan 命令、hscan 命令和 zscan 命令，分别用于集合、哈希键及有续集等。 scan 命令用于迭代当前数据库中的数据库键。 sscan 命令用于迭代集合键中的元素。 hscan 命令用于迭代哈希键中的键值对。 zs
使用redis的scan指令详解
Danny_idea的博客
12-24 2236
在生产环境中使用了keys指令之后容易导致出现短时间内的请求堵塞，这种情况在高并发环境中是比较致命的存在，因此需要尽可能地避免这种情况发生。 常用的查询某些key的指令： scan jedis使用方式： public List<String> scanAll(String cursor, String pattern, Integer limit) { try (Jedis jedis = iRedisFactory.getConnection()) { List&lt
redis命令_redis中scan命令的实现
weixin_39951112的博客
12-08 227
在一个天朗气清的日子，小灰登上了线上的redis打算查询数据。然而他只记得前缀而不知道整个键是多少，于是在命令行敲入了“keys xxx*”命令。瞬间服务卡死，报警邮件堆满了邮箱，而小灰，只能目瞪狗呆的等待着即将降临的case study。基本上，keys *命令都是在线上是被运维禁止的。redis的键在键值对大小大于hash-max-ziplist-value且个数小于hash-max...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值