springboot整合redis

已于 2022-04-10 15:34:32 修改
阅读量1.7k 收藏 5
点赞数 1
分类专栏： redis springboot学习 文章标签： redis spring boot 缓存
于 2022-03-11 17:41:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51705526/article/details/123430388
版权

springboot整合redis

前言:

Redis是目前使用最多的缓存，包括Spring Boot 中我们也是会用Redis做很多事情。那么今天就来说一说Spring Boot如何整合Redis。Spring Boot整合Redis 需要那些步骤呢？

整合redis:

一 pom.xml增加依赖如下:

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!-- redis 连接池 -->
        <!--新版本连接池lettuce-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

二 资源文件application.yaml中增加Redis相关配置

spring:
  cache:
    type: redis
  redis:
    host: 127.0.0.1 //这里用的是本地的redis
    port: 6379
    password:
    database: 0
    lettuce:
      pool:
        max-active: 100
        max-wait: -1ms # 连接池最大阻塞等待时间，负值表示没有限制
        max-idle: 8

三 封装redis工具类

这个工具类就是封装操作redisTemplate的实现类,基本涵盖了redis常用的基本类型

redis工具类接口

package org.cuit.epoch.util;

import java.util.List;
import java.util.Map;
import java.util.Set;

public interface RedisService {

    /**
     * 保存属性
     * @param key
     * @param value
     * @param time
     */
    void set(String key, Object value, long time);


    /**
     * 保存存属性
     * @param key
     * @param value
     *
     */
    void set(String key, Object value);


    /**
     * 获取属性
     * @param key
     * @return object
     */
    Object get(String key);

    /**
     * 删除属性
     */
    Boolean del(String key);

    /**
     * 批量删除属性
     */
    Long del(List<String> keys);

    /**
     * 设置过期时间
     */
    Boolean expire(String key, long time);

    /**
     * 获取过期时间
     */
    Long getExpire(String key);

    /**
     * 判断是否有该属性
     */
    Boolean hasKey(String key);

    /**
     * 按delta递增
     */
    Long incr(String key, long delta);

    /**
     * 按delta递减
     */
    Long decr(String key, long delta);

    /**
     * 获取Hash结构中的属性
     */
    Object hGet(String key, String hashKey);

    /**
     * 向Hash结构中放入一个属性
     */
    Boolean hSet(String key, String hashKey, Object value, long time);

    /**
     * 向Hash结构中放入一个属性
     */
    void hSet(String key, String hashKey, Object value);

    /**
     * 直接获取整个Hash结构
     */
    Map<Object, Object> hGetAll(String key);

    /**
     * 直接设置整个Hash结构
     */
    Boolean hSetAll(String key, Map<String, Object> map, long time);

    /**
     * 直接设置整个Hash结构
     */
    void hSetAll(String key, Map<String, Object> map);

    /**
     * 删除Hash结构中的属性
     */
    void hDel(String key, Object... hashKey);

    /**
     * 判断Hash结构中是否有该属性
     */
    Boolean hHasKey(String key, String hashKey);

    /**
     * Hash结构中属性递增
     */
    Long hIncr(String key, String hashKey, Long delta);

    /**
     * Hash结构中属性递减
     */
    Long hDecr(String key, String hashKey, Long delta);

    /**
     * 获取Set结构
     */
    Set<Object> sMembers(String key);

    /**
     * 向Set结构中添加属性
     */
    Long sAdd(String key, Object... values);

    /**
     * 向Set结构中添加属性
     */
    Long sAdd(String key, long time, Object... values);

    /**
     * 是否为Set中的属性
     */
    Boolean sIsMember(String key, Object value);

    /**
     * 获取Set结构的长度
     */
    Long sSize(String key);

    /**
     * 删除Set结构中的属性
     */
    Long sRemove(String key, Object... values);

    /**
     * 获取List结构中的属性
     */
    List<Object> lRange(String key, long start, long end);

    /**
     * 获取List结构的长度
     */
    Long lSize(String key);

    /**
     * 根据索引获取List中的属性
     */
    Object lIndex(String key, long index);

    /**
     * 向List结构中添加属性
     */
    Long lPush(String key, Object value);

    /**
     * 向List结构中添加属性
     */
    Long lPush(String key, Object value, long time);

    /**
     * 向List结构中批量添加属性
     */
    Long lPushAll(String key, Object... values);

    /**
     * 向List结构中批量添加属性
     */
    Long lPushAll(String key, Long time, Object... values);

    /**
     * 从List结构中移除属性
     */
    Long lRemove(String key, long count, Object value);

}

redis工具类实现类

package org.cuit.epoch.util;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Service
public class RedisServiceImpl implements RedisService{

    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    @Override
    public void set(String key, Object value, long time) {
        redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
    }

    @Override
    public void set(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }

    @Override
    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    @Override
    public Boolean del(String key) {
        return redisTemplate.delete(key);
    }

    @Override
    public Long del(List<String> keys) {
        return redisTemplate.delete(keys);
    }

    @Override
    public Boolean expire(String key, long time) {
        return redisTemplate.expire(key, time, TimeUnit.SECONDS);
    }

    @Override
    public Long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    @Override
    public Boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }

    @Override
    public Long incr(String key, long delta) {
        return redisTemplate.opsForValue().increment(key, delta);
    }

    @Override
    public Long decr(String key, long delta) {
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    @Override
    public Object hGet(String key, String hashKey) {
        return redisTemplate.opsForHash().get(key, hashKey);
    }

    @Override
    public Boolean hSet(String key, String hashKey, Object value, long time) {
        redisTemplate.opsForHash().put(key, hashKey, value);
        return expire(key, time);
    }

    @Override
    public void hSet(String key, String hashKey, Object value) {
        redisTemplate.opsForHash().put(key, hashKey, value);
    }

    @Override
    public Map<Object, Object> hGetAll(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    @Override
    public Boolean hSetAll(String key, Map<String, Object> map, long time) {
        redisTemplate.opsForHash().putAll(key, map);
        return expire(key, time);
    }

    @Override
    public void hSetAll(String key, Map<String, Object> map) {
        redisTemplate.opsForHash().putAll(key, map);
    }

    @Override
    public void hDel(String key, Object... hashKey) {
        redisTemplate.opsForHash().delete(key, hashKey);
    }

    @Override
    public Boolean hHasKey(String key, String hashKey) {
        return redisTemplate.opsForHash().hasKey(key, hashKey);
    }

    @Override
    public Long hIncr(String key, String hashKey, Long delta) {
        return redisTemplate.opsForHash().increment(key, hashKey, delta);
    }

    @Override
    public Long hDecr(String key, String hashKey, Long delta) {
        return redisTemplate.opsForHash().increment(key, hashKey, -delta);
    }

    @Override
    public Set<Object> sMembers(String key) {
        return redisTemplate.opsForSet().members(key);
    }

    @Override
    public Long sAdd(String key, Object... values) {
        return redisTemplate.opsForSet().add(key, values);
    }

    @Override
    public Long sAdd(String key, long time, Object... values) {
        Long count = redisTemplate.opsForSet().add(key, values);
        expire(key, time);
        return count;
    }

    @Override
    public Boolean sIsMember(String key, Object value) {
        return redisTemplate.opsForSet().isMember(key, value);
    }

    @Override
    public Long sSize(String key) {
        return redisTemplate.opsForSet().size(key);
    }

    @Override
    public Long sRemove(String key, Object... values) {
        return redisTemplate.opsForSet().remove(key, values);
    }

    @Override
    public List<Object> lRange(String key, long start, long end) {
        return redisTemplate.opsForList().range(key, start, end);
    }

    @Override
    public Long lSize(String key) {
        return redisTemplate.opsForList().size(key);
    }

    @Override
    public Object lIndex(String key, long index) {
        return redisTemplate.opsForList().index(key, index);
    }

    @Override
    public Long lPush(String key, Object value) {
        return redisTemplate.opsForList().rightPush(key, value);
    }

    @Override
    public Long lPush(String key, Object value, long time) {
        Long index = redisTemplate.opsForList().rightPush(key, value);
        expire(key, time);
        return index;
    }

    @Override
    public Long lPushAll(String key, Object... values) {
        return redisTemplate.opsForList().rightPushAll(key, values);
    }

    @Override
    public Long lPushAll(String key, Long time, Object... values) {
        Long count = redisTemplate.opsForList().rightPushAll(key, values);
        expire(key, time);
        return count;
    }

    @Override
    public Long lRemove(String key, long count, Object value) {
        return redisTemplate.opsForList().remove(key, count, value);
    }
}

四 创建RedisController控制器

package com.feng.controller;

import java.util.*;

import com.feng.domain.User;
import com.feng.utils.RedisService;
import com.feng.utils.result.CommonResult;
import com.feng.utils.result.ResultUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


@RestController
@RequestMapping("/redis")
public class RedisController {


    @Autowired
    private RedisService redis;

    @GetMapping("/nihao")
    public String niHao() {
        return "这里是nihao方法!";
    }


    @GetMapping("/test")
    public CommonResult<User> test() {
        User user = new User();
        user.setId(111L);
        user.setName("ladidol");
        user.setCreateTime(new Date());

        redis.set("json:user", user);

        return ResultUtil.success(user);
    }

    @GetMapping("/getUsers")
    public CommonResult<Map<Object, Object>> getJsonList() {


        User user1 = new User();
        user1.setId(111L);
        user1.setName("ladidol1");
        user1.setCreateTime(new Date());

        User user2 = new User();
        user2.setId(111L);
        user2.setName("ladidol2");
        user2.setCreateTime(new Date());

        User user3 = new User();
        user3.setId(111L);
        user3.setName("ladidol3");
        user3.setCreateTime(new Date());

        Map<String, Object> map = new HashMap<>();
        map.put("ladidol1", user1);
        map.put("ladidol2", user2);
        map.put("ladidol3", user3);


        redis.hSetAll("json:userMaps", map, 2000);
        Map<Object, Object> userMaps = redis.hGetAll("json:userMaps");
        return ResultUtil.success(userMaps);
    }
}

结果截图:

单个用户查询:

在这里插入图片描述

查询全部用户:
在这里插入图片描述

在idea中项目的最终结构是这样:

在这里插入图片描述

tips:这里面导入了一些工具类,可以去我其他博客看一下;

一些小小瑕疵:

用这个redis工具类的时候会出现,key值在redis中存储有多余的前缀	
类似这种:
\xac\xed\x00\x05t\x00\x0djson:userMaps
\xac\xed\x00\x05t\x00\x08ladidol2
但是不影响使用;

key值有前缀乱码解决方法:(好像并没有全部解决寄)

package com.feng.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
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.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;



@Configuration
@EnableCaching
public class RedisConfig {

    /**
     * redis数据库自定义key
     */
    public static final String REDIS_KEY_DATABASE = "community";


    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setConnectionFactory(factory);
        //key序列化方式
        template.setKeySerializer(redisSerializer);
        //value序列化
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //value hashmap序列化
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        return template;
    }



    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        //解决查询缓存转换异常的问题
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // 配置序列化（解决乱码的问题）,过期时间600秒
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(600))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
                .disableCachingNullValues();
        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
        return cacheManager;
    }

}

欢迎点赞关注哦！
也欢迎到访我的博客！小小的博客传送门!

兴趣使然的小小
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
基于IDEA搭建springboot+redis环境，深入了解相关机制
菜鸟不会飞
09-03 9672
本文主要目的在搭建基于IDEA的springboot+Redis环境时，深入了解springboot框架的相关机制，了解何时用配置文件，何时利用注解，尽可能清晰、完备的总结相关核心问题。 话不多少，进入主题。 1、搭建springboot+redis的方式有两种，它们分别如下： 方式一：基于RedisTemplate类  ，redisTemplate是springdate提供的管理redis...
idea下springboot整合redis例子
07-20
这个是我自己搭建的springboot整合redis，由于网上的部分例子，有错误，深感不解，于是动手搭建，自己测试过了，可以使用，而且简单易懂，适合新手，容易理解，可以作为自己的第一个demo
springboot yml 配置redis_spring boot 学习总结
weixin_39670246的博客
11-19 1482
1.spring boot 快速搭建1）创建一个project，选择empty project2）创建model，选择maven工程，不用勾选模板填写相关坐标：<groupId>com.ayx</groupId> <artifactId>springboot_mybatis</artifactId> ...
Redis第三话 – Springboot集成Redis以及常用API和客户端介绍
生生不息，则源源不断
06-02 488
Redis第三话 – Springboot集成Redis以及常用API和客户端介绍 本文主要记录在Springboot中集成Redis的使用。基于springboot 版本2.5.6，parent包就不贴了。 上一篇：Redis第二话 – Redis的高端操作(发布订阅、事务、LUA脚本) 下一篇：Redis第四话 – redis分布式集群(主从，哨兵)和网络模型分析(多路复用，单Reactor模型) 黑发不知勤学早，白首方悔读书迟......
SpringBoot2.0配置redis相关
weixin_34410662的博客
04-09 143
2019独角兽企业重金招聘Python工程师标准>>> ...
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消息队列实现异步秒杀下单知识分享
springboot整合redis（集群） yml配置
热门推荐
loveLifeLoveCoding的博客
08-13 1万+
一、加入maven配置 <!-- 整合redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> 二、加入yml
SpringBoot使用applicaton.yaml
Jchn lau
02-27 203
方式一: 使用配置类 @ConfigurationProperties @EnableConfigurationProperties 该注解是配合 @ConfigurateionProperties 来使用的，只需要在EnableConfigurationProperties注解的values内声明即可。 如果不用EnableConfigurationProperties注解的话，可以直接在...
springboot集成redisson
broccoli2的博客
12-29 1241
1.添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> <version>2.4.1</version> </dependency&g
SpringBoot整合Redis（基于虚拟机已装好Redis）
star_zhang_jx的博客
12-21 964
springboot整合redis,解决中间遇到的一系列问题，测试redis的使用
springboot + yml + redis + HttpClient 实现自动化测试
YXZL的博客
09-09 546
springboot + yml + redis + HttpClient 实现自动化测试
SpringBoot学习笔记（五）：配置redis
汤圆学Java
03-29 3690
转载自：http://www.jianshu.com/p/a2ab17707eff Spring Boot简介Spring Boot是为了简化Spring开发而生，从Spring 3.x开始，Spring社区的发展方向就是弱化xml配置文件而加大注解的戏份。最近召开的SpringOne2GX2015大会上显示：Spring Boot已经是Spring社区中增长最迅速的框架，前三名是：Spring
4.springboot整合redis
qq_614617158的博客
11-03 186
1.导入依赖包 <!--springboot-redis--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <!--用于测试 --
Spring+SpringMvc+MyBatis整合案例(基于xml配置文件的方式)
MeanderCloud的博客
09-29 676
一、Maven项目导入Spring、SpringMvc、MyBatis依赖的jar包(pom.xml) 二、数据库的账户信息(database.properties) 三、MyBatis的xml配置文件(mybatis-configure.xml) 四、MyBatis开始整合配置(spring-dao.xml) 五、Spring的配置文件(spring-service.xml) 六、SpringMvc开始整合配置(spring-web.xml) 七、web.xml配置文件(将`/*`的``符号去
SpringBoot框架idea开发工具中:application.yml简单配置样例
xiaoxiamiqianqian的博客
12-09 1244
1.添加路径:resources 资源文件夹下创建application.yml文件,该文件与application.properties文件作用一致,但因为是树形结构,更有层次感,便于理解,所以很多人都选择了yml文件. 2.application.yml文件内容(后续持续更新,在此做记录) server: port:8080 #端口号 #servlet: #context...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

兴趣使然的小小

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

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

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

打赏作者

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

抵扣说明：

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

余额充值