Redis与SpringBoot整合

于 2022-10-27 16:51:01 发布
阅读量423 收藏 1
点赞数
文章标签： redis spring boot java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61812971/article/details/127539396
版权

相关依赖 

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

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


        <!-- commons-pool2 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.13.4.2</version>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.13.4.2</version>
        </dependency>

        <!--commons-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

配置文件

#Redis服务器地址
spring.redis.host=192.168.238.80
#Redis服务器连接端口
spring.redis.port=6379
#Redis数据库索引（默认为0）
spring.redis.database=0
#连接超时时间
spring.redis.timeout=1800000
#连接池最大连接数（使用负值表示没有限制）
spring.redis.lettuce.pool.max-active=20
#最大阻塞等待时间（复制表示没有限制）
spring.redis.lettuce.pool.max-wait=1
#连接池中的最大空间连接
spring.redis.lettuce.pool.max-idle=5
#连接池中的最小空间连接
spring.redis.lettuce.pool.min-idle=0

RedisConfig配置类

@AutoConfigureAfter(RedisAutoConfiguration.class)
@Configuration
@EnableCaching // 启用缓存，使用 Lettuce，自动注入配置的方式
public class RedisConfig extends CachingConfigurerSupport {
    
    /**
     * config RedisTemplate<Object, Object>
     */
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate (RedisConnectionFactory factory){
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
        redisTemplate.setConnectionFactory(factory);

        // String 序列化方式
        StringRedisSerializer stringSerializer = new StringRedisSerializer();
        // Jackson 序列化方式
        Jackson2JsonRedisSerializer jacksonSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jacksonSerializer.setObjectMapper(objectMapper);

        // key 采用 stringSerializer，value 采用 jacksonSerializer
        redisTemplate.setKeySerializer(stringSerializer);
        redisTemplate.setHashKeySerializer(stringSerializer);
        redisTemplate.setValueSerializer(jacksonSerializer);
        redisTemplate.setHashValueSerializer(jacksonSerializer);

        return redisTemplate;
    }

    /**
     * config CacheManager
     */
    @Bean
    @SuppressWarnings("all")
    public CacheManager cacheManager(LettuceConnectionFactory factory) {
        RedisCacheWriter writer = RedisCacheWriter.lockingRedisCacheWriter(factory);
        RedisSerializationContext.SerializationPair pair =
                RedisSerializationContext.SerializationPair.fromSerializer(
                        new Jackson2JsonRedisSerializer(Object.class));
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig().serializeValuesWith(pair);
        // default set
//		RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();

        return new RedisCacheManager(writer, config);
    }

    // 重新定义缓存 key 的生成策略
    @Bean
    @Override
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                Arrays.asList(params).stream().forEach(item -> {
                    sb.append(item.toString());
                });
                return sb.toString();
            }
        };
    }
}

RedisUtil工具类

@Component
public class RedisUtils {
	private static final Logger LOGGER = LoggerFactory.getLogger(RedisUtils.class);

	@Autowired
	private RedisTemplate<String, Object> redisTemplate;
	
	/**
	 * count > 0：从左到右删除等于value的第一个元素
	 * count = 0：删除等于value的所有元素
	 * count < 0：从右到左删除等于value的第一个元素
	 */
	public long removeListItem(String key, long count, Object value) {
		try {
			return redisTemplate.opsForList().remove(key, count, value);
		} catch (Exception e) {
			LOGGER.debug(e.getMessage());
			return 0;
		}
	}
	
	public boolean updateListItem(String key, long index, Object value) {
		try {
			redisTemplate.opsForList().set(key, index, value);
			return true;
		} catch (Exception e) {
			LOGGER.debug(e.getMessage());
			return false;
		}
	}
	
	public boolean setList(String key, List<Object> list) {
		try {
			redisTemplate.opsForList().rightPushAll(key, list);
			return true;
		} catch (Exception e) {
			LOGGER.debug(e.getMessage());
			return false;
		}
	}
	
	public boolean setListItem(String key, Object value) {
		try {
			redisTemplate.opsForList().rightPush(key, value);
			return true;
		} catch (Exception e) {
			LOGGER.debug(e.getMessage());
			return false;
		}
	}
	
	public Object getListItem(String key, long index) {
		try {
			return redisTemplate.opsForList().index(key, index);
		} catch (Exception e) {
			LOGGER.debug(e.getMessage());
			return null;
		}
	}
	
	public long getListSize(String key) {
		try {
			return redisTemplate.opsForList().size(key);
		} catch (Exception e) {
			LOGGER.debug(e.getMessage());
			return 0;
		}
	}
	
	public List<Object> getListRang(String key, long start, long end) {
		try {
			return redisTemplate.opsForList().range(key, start, end);
		} catch (Exception e) {
			LOGGER.debug(e.getMessage());
			return null;
		}
	}
	
	public long removeSetMembers(String key, Object... setValues) {
		try {
			return redisTemplate.opsForSet().remove(key, setValues);
		} catch (Exception e) {
			LOGGER.debug(e.getMessage());
			return 0;
		}
	}
	
	public long setSetMembers(String key, long timeOut, Object... values) {
		try {
			long count = redisTemplate.opsForSet().add(key, values);
			if (timeOut > 0) {
				expire(key, timeOut);
			}
			return count;
		} catch (Exception e) {
			LOGGER.debug(e.getMessage());
			return 0;
		}
	}
	
	public long setSetMembers(String key, Object... values) {
		try {
			return redisTemplate.opsForSet().add(key, values);
		} catch (Exception e) {
			LOGGER.debug(e.getMessage());
			return 0;
		}
	}
	
	public long getSetSize(String key) {
		try {
			return redisTemplate.opsForSet().size(key);
		} catch (Exception e) {
			LOGGER.debug(e.getMessage());
			return 0;
		}
	}
	
	public boolean isSetMember(String key, Object setValue) {
		return redisTemplate.opsForSet().isMember(key, setValue);
	}
	
	public Set<Object> getSet(String key) {
		try {
			return redisTemplate.opsForSet().members(key);
		} catch (Exception e) {
			LOGGER.debug(e.getMessage());
			return null;
		}
	}
	
	public boolean putHash(String key, Map<String, Object> hashObject,
			long timeOut) {
		try {
			redisTemplate.opsForHash().putAll(key, hashObject);
			if (timeOut > 0) {
				expire(key, timeOut);
			}
			return true;
		} catch (Exception e) {
			LOGGER.debug(e.getMessage());
			return false;
		}
	}
	
	public boolean putHash(String key, Map<String, Object> hashObject) {
		try {
			redisTemplate.opsForHash().putAll(key, hashObject);
			return true;
		} catch (Exception e) {
			LOGGER.debug(e.getMessage());
			return false;
		}
	}
	
	public Map<Object, Object> getHash(String key) {
		return redisTemplate.opsForHash().entries(key);
	}
	
	@SuppressWarnings("all")
	public void deleteHashItems(String key, String... hashKeys) {
		redisTemplate.opsForHash().delete(key, hashKeys);
	}
	
	public boolean haveHahsKey(String key, String hashKey) {
		return redisTemplate.opsForHash().hasKey(key, hashKey);
	}
	
	public double decrementHash(String key, String hashKey, double delta) {
		return redisTemplate.opsForHash().increment(key, hashKey, -delta);
	}
	
	public double incrementHash(String key, String hashKey, double delta) {
		return redisTemplate.opsForHash().increment(key, hashKey, delta);
	}
	
	public boolean putHashValue(String key, String hashKey, Object hashValue, long timeOut) {
		try {
			redisTemplate.opsForHash().put(key, hashKey, hashValue);
			if (timeOut > 0) {
				expire(key, timeOut);
			}
			return true;
		} catch (Exception e) {
			LOGGER.debug(e.getMessage());
			return false;
		}
	}
	
	public boolean putHashValue(String key, String hashKey, Object hashValue) {
		try {
			redisTemplate.opsForHash().put(key, hashKey, hashValue);
			return true;
		} catch (Exception e) {
			LOGGER.debug(e.getMessage());
			return false;
		}
	}
	
	public Object getHashValue(String key, String hashKey) {
		return redisTemplate.opsForHash().get(key, hashKey);
	}
	
	// 设置value递减
	public long decrement(String key, long delta) {
		if (delta < 1) {
			throw new RuntimeException("Increment delta must great than 0.");
		}
		return redisTemplate.opsForValue().decrement(key, delta);
	}
	
	// 设置value递增
	public long increment(String key, long delta) {
		if (delta < 1) {
			throw new RuntimeException("Increment delta must great than 0.");
		}
		return redisTemplate.opsForValue().increment(key, delta);
	}
	
	public boolean set(String key, Object value, long timeOut) {
		try {
			if (timeOut > 0) {
				redisTemplate.opsForValue().set(key, value, timeOut, TimeUnit.SECONDS);
			} else {
				redisTemplate.opsForValue().set(key, value);
			}
			return true;
		} catch (Exception e) {
			LOGGER.debug(e.getMessage());
			return false;
		}
	}
	
	public boolean set(String key, Object value) {
		try {
			redisTemplate.opsForValue().set(key, value);
			return true;
		} catch (Exception e) {
			LOGGER.debug(e.getMessage());
			return false;
		}
	}
	
	public Object get(String key) {
		return StringUtils.isBlank(key) ? null : redisTemplate.opsForValue().get(key);
	}
	
	public void delete(String... key) {
		if (null != key && key.length > 0) {
			redisTemplate.delete(Stream.of(key).collect(Collectors.toList()));
		}
	}
	
	public boolean hasKey(String key) {
		try {
			return redisTemplate.hasKey(key);
		} catch (Exception e) {
			LOGGER.debug(e.getMessage());
			return false;
		}
	}
	
	public long getExpire(String key) {
		return redisTemplate.getExpire(key, TimeUnit.SECONDS);
	}
	
	// 设置过期时间
	public boolean expire(String key, long timeOut) {
		try {
			if (timeOut > 0) {
				redisTemplate.expire(key, timeOut, TimeUnit.SECONDS);
			}
			return true;
		} catch (Exception e) {
			LOGGER.debug(e.getMessage());
			return false;
		}
	}
}

RedisController

@RestController
@RequestMapping("/redisTest")
public class RedisTestController {


    @Autowired
    private RedisTemplate redisTemplate;

    @GetMapping
    public String testRedis(){
        //设置值到redis
        redisTemplate.opsForValue().set("name","lucy");
        //获取值
        String name =(String) redisTemplate.opsForValue().get("name");
        return name;
    }
}

结果

 

Maserati477
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
springboot整合redis代码
05-14
springboot整合redis.算是比较全面的一种整合方式了. springboot整合redis.算是比较全面的一种整合方式了.
SpringBoot_Shiro_JWT_Redis:SpringBoot整合Shiro、JWT和Redis实现token登录授权验证以及token刷新
05-14
SpringBoot整合Shiro、JWT和Redis实现token登录授权验证以及token刷新 前端代码为一个博客页面，使用了Semantic UI框架结合thymeleaf模板 SpringBoot结合JWT+Shiro+Redis实现token无状态登录授权 [TOC] 一、引言 ​ ...
SpringBoot整合Redis
夏夜凉月
02-14 219
一、引言     记录工作中springboot使用的redis配置，后面少采坑，本篇使用的是RedisTemplate来实现springboot和redis的单机版、集群版和哨兵模式。 二、步骤 1、maven依赖 &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt...
Spring Boot学习之旅：（六）springboot 整合 redis 以及 redis 通用工具类
u012957549的博客
10-08 1万+
这编文章主要介绍了springboot整合redis，以及redis配置和一些redis操作数据的工具类。
SpringBoot2.X 配置Redis
weixin_43303455的博客
04-17 320
前言: 目前java操作redis的客户端有jedis跟Lettuce。在springboot1.x系列中，其中使用的是jedis,但是到了springboot2.x其中使用的是Lettuce。 因为我们的版本是springboot2.x系列，所以今天使用的是Lettuce。 关于jedis跟lettuce的区别： Lettuce 和 Jedis 的定位都是Redis的client，所以他们当然可...
SpringBoot整合redis缓存数据Demo
海角12138的博客
11-21 291
1---项目目录： 2---configure层： package com.example.configurer; import org.springframework.boot.autoconfigure.AutoConfigureAfter; import org.springframework.boot.autoconfigure.data.redis.RedisAutoConf...
SpringBoot集成Redis | 使用注解动态在方法上和方法中切换Redis库
慌途L
04-03 2691
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Ma...
Redis和springboot整合Redis步骤.emmx
07-18
使用mindmaster打开
springboot-redis:springboot 整合 redis
05-18
springboot 整合 redisspringboot 1.5.10.RELEASE###简单的springboot 整合 redis ，有以下几个方法(基本可以满足小型后台应用)：1.保存字符串2.根据key获取字符串3.保存对象4.根据key获取对象5.从redis中删除6.从...
springboot整合redis,springboot连接redis集群
04-08
spoot工程连接redis集群
spring boot集成redis缓存
qq_31603875的博客
10-19 354
因为@Cacheable 是使用AOP 代理实现的 ，通过创建内部类来代理缓存方法，这样就会导致一个问题，类内部的方法调用类内部的缓存方法不会走代理（因为方法之间的调用直接使用的是原始对象this，而非代理对象，因而内部调用不会产生代理），不会走代理，就不能正常创建缓存，所以每次都需要去调用数据库。② 把方法A和方法B放到两个不同的类里面，例如：如果两个方法都在同一个service接口里，把方法B放到另一个service里面，这样在A方法里调B方法，就可以使用B方法的缓存。1、为什么缓存没有被正常创建？
Redis的序列化配置
calm_encode的博客
08-02 3731
一 源码概述 public class RedisTemplate<K, V> extends RedisAccessor implements RedisOperations<K, V>, BeanClassLoaderAware { private boolean enableTransactionSupport = false; private boolean exposeConnection = false; private boolean ini
知识积累：SpringBoot-data-Redis的RedisTemplate的opsForList，操作List＜Object＞集合的leftPushAll和rightAll问题；分页查询list
做技术，贵在学习与坚持！
10-15 2759
最近项目在用RedisTemplate的opsForList进行对象集合的存储并进行分页查询； 可是当使用 supportRedisTemplate.opsForList().rightPushAll(key, lists)； 默认走了Long rightPushAll(K var1, V… var2); 试了很多种方式， 将lists类型强转为Collection， 将lists转为String[]， 最后都没有成功。只会存储一个整体的对象，无法使用range(),来进行分页查询。 只能采取曲线救国的方案
springboot 排除redis的自动配置
刚好五个字的博客
07-05 3万+
因为要配置对个redis链接，所以将系统自带的配置排除，分别是 RedisAutoConfiguration.class 和 RedisRepositoriesAutoConfiguration.class 两个自动配置类 @SpringBootApplication(exclude={ RedisAutoConfiguration.class, RedisR...
SpringBoot自动配置xxxAutoConfiguration 的使用
weixin_34007879的博客
06-12 304
https://sdqali.in/blog/2016/07/16/controlling-redis-auto-configuration-for-spring-boot-session/ 常用的类： @ConditionalOnProperty(name = "use.redis.session.store", havingValue = "true") @ConditionalOn...
理解Spring Boot
热门推荐
chszs的专栏
02-16 4万+
理解Spring Boot作者：chszs，未经博主允许不得转载。经许可的转载需注明作者和博客主页：http://blog.csdn.net/chszsSpring Boot是一个偏执的开源框架，它可用于创建可执行的Spring应用程序，采用了习惯优于配置的方法。 此框架的神奇之处在于@EnableAutoConfiguration注释，此注释自动载入应用程序所需的所有Bean——这依赖于Spri
【Spring Boot】（24）、Spring Boot中使用缓存之Spring缓存
caychen的博客
05-26 1108
1、缓存依赖只要添加如下依赖，即可使用缓存功能。&lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-cache&lt;/artifactId&gt; &lt;/dependency&gt;2、缓存注解@Enab...
一起来学SpringBoot | 第九篇：整合Lettuce Redis
挖坑埋你
05-27 5524
SpringBoot 是为了简化 Spring 应用的创建、运行、调试、部署等一系列问题而诞生的产物，自动装配的特性让我们可以更好的关注业务本身而不是外部的XML配置，我们只需遵循规范，引入相关的依赖就可以轻易的搭建出一个 WEB 工程 Spring Boot 除了支持常见的ORM框架外，更是对常用的中间件提供了非常好封装，随着 Spring Boot2.x 的到来，支持的组件越来越丰富...
Redisson使用
雪落南城的博客
05-22 2017
pom： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <dependency> ...
redis与springboot简单整合
最新发布
07-27
Spring Boot与Redis整合可以通过以下步骤实现： 1. 添加Redis依赖 在pom.xml文件中添加以下依赖： ``` <groupId>org.springframework.boot <artifactId>spring-boot-starter-data-redis ``` 2. 配置Redis...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Maserati477

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值