SpringBoot整合Redis缓存

最新推荐文章于 2023-06-13 20:00:51 发布
最新推荐文章于 2023-06-13 20:00:51 发布
阅读量223 收藏 1
点赞数 1
分类专栏： Redis 文章标签： springboot整合redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rexueqingchun/article/details/97799662
版权

1.pom.xml添加redis依赖

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

2.application.properties配置redis连接属性

# Redis数据库索引（默认为0）
spring.redis.database=1
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码
spring.redis.password=123456
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=100
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=5000
# 连接池中的最大空闲连接
spring.redis.pool.max-idle=10
# 连接池中的最小空闲连接
spring.redis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=5000

3.编写redis配置类

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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.StringRedisSerializer;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String,Object>redisTemplate(RedisConnectionFactory factory){
        RedisTemplate<String,Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        //使用Jackson2JsonRedisSerialize 替换默认序列化(默认采用的是JDK序列化)
        Jackson2JsonRedisSerializer<Object> 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;
    }

}

4.编写redis操作工具类

import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

@Component
public class RedisUtil {
	
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
	
    /**
     * 普通缓存放入
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }
    
    /**
     * 普通缓存放入并设置时间(单位秒,time小于等于0,则设置无限期)
     */
    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;
        }
    }
    
    /**
     * 普通缓存获取
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }
    
    /**
     * 删除缓存(可以传一个值或多个)
     */
    @SuppressWarnings("unchecked")
    public void delete(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }
    
    /**
     * 指定缓存失效时间(单位秒,expire返回1:成功地为该键设置了超时时间,返回0:键不存在或无法设置超时时间)
     */
    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获取过期时间(单位秒,getExpire返回大于0:表示距离过期还有多少秒,返回-1:永不过期,返回-2:过期且已删除)
     */
    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;
        }
    }

    /**
     * 递增
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 递减
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }
    
    /**
     * 获取HashKey指定键值
     */
    public Object hashGet(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 获取HashKey所有键值
     */
    public Map<Object, Object> hashGet(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet放入
     */
    public boolean hashSet(String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    
    /**
     * HashSet放入并设置时间
     */
    public boolean hashSet(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;
        }
    }
    
    /**
     * 将list放入缓存
     */
    public boolean listSet(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存并设置时间
     */
    public boolean listSet(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缓存的内容(0到-1代表所有值)
     */
    public List<Object> listGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    
    /**
     * 通过索引 获取list中的值
     */
    public Object listGet(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    
    /**
     * 获取list缓存的长度
     */
    public long getListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    
}

5.测试使用

@Controller
public class Test {

    @Autowired
    private RedisUtil redisUtil;
	
    @RequestMapping("/test")
    public String test(Model model,HttpServletRequest request) throws Exception{
	    //普通类型
	    redisUtil.set("ss", "哈哈");
	    System.out.println("读取缓存普通类型："+redisUtil.get("ss"));
	    //Map集合
	    Map<String,Object> map = new HashMap<>();
	    map.put("name", "小明");
	    map.put("sex", "男");
	    redisUtil.hashSet("map", map);
	    System.out.println("读取缓存Map类型："+redisUtil.hashGet("map"));
	    System.out.println("读取缓存Map类型指定元素："+redisUtil.hashGet("map","name"));
	    //List集合
	    List<Object> list = new ArrayList<>();
	    Map<String,Object> map1 = new HashMap<>();
	    map1.put("name", "小红");
	    map1.put("sex", "女");
	    list.add(map);
	    list.add(map1);
	    redisUtil.listSet("list", list);
	    System.out.println("读取缓存List类型全部元素："+redisUtil.listGet("list",0,-1));
	    System.out.println("读取缓存List类型第一个元素："+redisUtil.listGet("list",0));
	    System.out.println("读取缓存List类型长度："+redisUtil.getListSize("list"));
	    return "";
    }
}

Redis常用操作命令：

1.启动redis服务：redis-server.exe redis.windows.conf

2.连接redis服务：redis-cli -h 127.0.0.1 -p 6379

                            auth 设置的密码

3.清空所有缓存： flushall

通过bat命令启动Redis（例如：安装目录为F:\reids）：

@echo off
title redis-server
set ENV_HOME="F:\reids"
F:
cd %ENV_HOME%
redis-server.exe redis.windows.conf
@pause

 

王绍桦
关注
专栏目录
SpringBoot集成Redis缓存
09-18 233
关于Redis缓存 为什么使用缓存？ 提升重复访问数据的访问效率。 Redis的三个用途 数据库，缓存，消息中间件 Redis的应用场景（针对被重复访问的数据） 页面缓存（图片，CSS，html等静态数据）——热点数据 最新列表 排行榜 计数器 session存储 使用建议 Redis 速度快是建立在内存数据库基础上的，但是一台服务器的内存要比磁盘金贵许多，所以在项目初期不要想...
Spring Boot携手Redis缓存实战：精通注解、配置与策略，加速你的应用至极致！
最新发布
拥有必珍惜
07-24 826
在Spring Boot项目中引入Redis作为缓存机制，并使用@Cacheable注解来简化缓存的操作，是一个常见且高效的实践。下面，我将概述如何在Spring Boot项目中引入Redis作为缓存，并展示如何使用@Cacheable注解。Spring Boot x Redis：零基础入门，性能飙升的实战秘籍！你也可以自定义缓存实现，以适应特殊需求。@Bean// 不缓存null值​.build();缓存策略被设置为不缓存 null 值。
SpringBoot - 整合Redis缓存
Eelol的博客
04-17 248
我们在日常开发中很多数据可以放在缓存中增加查询效率，提升性能，比如：商品、验证码 缓存简介 SpringBoot基本环境搭建 JSR-107 缓存规范： 交互流程：缓存管理器里面存在多个缓存，例如：存储员工等等 CacheManage是用来管理缓存的， Cache是用来操作缓存的（定义接口） 如果要使用JSR-107，需要导入cache包 Spring缓存抽象 几个缓存注解 ...
springboot整合Redis缓存源代码
07-10
SpringBoot整合Redis缓存是Java开发中常见的技术实践，它能极大地提高应用程序的性能和响应速度，通过将频繁访问的数据存储在内存中，避免了反复从数据库读取数据的开销。以下是对这一主题的详细解释： 首先，...
SpringBoot 整合 Redis、mybatis 完整项目源码下载
05-26
**SpringBoot整合Redis** 1. **配置Redis**: 在SpringBoot项目中，可以通过`application.properties`或`application.yml`文件配置Redis连接信息，包括主机地址、端口、密码等。 2. **添加依赖**: 在`pom.xml`文件...
SpringBoot整合Redis
01-17
**SpringBoot整合Redis** 在现代Web开发中，缓存机制是提高系统性能的关键技术之一，而Redis作为一款高性能的键值存储系统，被广泛应用在数据缓存领域。SpringBoot简化了与各种技术的集成，包括Redis。下面我们将...
SpringBoot2.3整合redis缓存自定义序列化的实现
08-18
"SpringBoot2.3整合redis缓存自定义序列化的实现" SpringBoot2.3整合redis缓存自定义序列化的实现是指在SpringBoot2.3项目中使用redis作为缓存中间件，并对缓存数据进行自定义序列化的实现。下面将详细介绍该实现的...
springboot整合redis缓存
qq_37170583的博客
11-02 317
使用redis作为缓存 1. 在pom.xml文件中导入依赖 &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-data-redis&lt;/artifactId&gt; &lt;/dependency&gt...
SpringBoot整合redis缓存
lzc翻身博客
06-13 1359
1.Redis是一个开源的内存数据存储系统、也是c语言编写的非关系型数据库，以键值对的形式储存数据，可以用作数据库、缓存、消息中间件等，具有高性能、可扩展性和灵活性等特点。Redis支持多种数据类型，如String、Hash、List、Set、ZSet集合等，能够满足不同场景的数据存储需求。Redis的数据存储在内存中，因此访问速度非常快，且可以配置成持久化存储到磁盘中（RDB和AOF），以便数据不丢失。Redis还支持主从复制、分布式、事务等功能，使其成为互联网企业常用的数据存储方案之一。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值