Springboot使用Redis缓存

最新推荐文章于 2024-09-27 20:21:25 发布
最新推荐文章于 2024-09-27 20:21:25 发布
阅读量284 收藏
点赞数
分类专栏： Redis 文章标签： redis缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/U2133048/article/details/83177917
版权

在pom.xml引入jar包

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

application-redis.properties中配置Redis连接信息

 

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

在application.properties中加redis的配置信息

spring.profiles.active=redis

新建Redis缓存配置了RedisConfig

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
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 redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * 
 * redis配置类
 *
 */
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

    @Value("${spring.redis.host}")
    private String host;

    @Value("${spring.redis.port}")
    private int port;

    @Value("${spring.redis.timeout}")
    private int timeout;

    @Value("${spring.redis.password}")
    private String password;

    @Value("${spring.redis.database}")
    private int database;

    @Value("${spring.redis.pool.max-idle}")
    private int maxIdle;

    @Value("${spring.redis.pool.min-idle}")
    private int minIdle;

    // @Value("${spring.redis.pool.max-active}")
    // private int maxActive;

    // @Value("${spring.redis.pool.max-wait}")
    // private int maxWait;

  

 @Bean
    public JedisClient jedisClient() {
        return new JedisClient();
    }

    @Autowired
    @Qualifier("jedis.pool.config")
    JedisPoolConfig config;

    @Bean
    public JedisPool jedisPool() {
        String pw = "".equals(password) ? null : password;// 如果密码为空，需传null
        return new JedisPool(config, host, port, timeout, pw, database);
    }

    /**
     * 连接池配置
     * 
     * @Description:
     * @return
     */
    @Bean(name = "jedis.pool.config")
    public JedisPoolConfig jedisPoolConfig() {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxIdle(maxIdle);
        jedisPoolConfig.setMinIdle(minIdle);
        // jedisPoolConfig.setMaxWaitMillis(maxWait);
        // jedisPoolConfig.set ...
        return jedisPoolConfig;
    }
}

新建JedisClient缓存客户端类

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

public class JedisClient {

    @Autowired
    private JedisPool jedisPool;

    public Jedis getResource() {
        return jedisPool.getResource();
    }

    public void delete(String key) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            jedis.del(key);
        } finally {
            if (null != jedis) {
                jedis.close();
            }
        }
    }

    public String get(String key) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.get(key);
        } finally {
            if (null != jedis) {
                jedis.close();
            }
        }
    }

    public void set(String key, String value) {
        this.set(key, value, 0);
    }

    public void set(String key, String value, long seconds) {
        this.set(key, value, (int) seconds);
    }

    public void set(String key, String value, int seconds) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            jedis.set(key, value);
            if (seconds > 0) {
                jedis.expire(key, seconds);
            }
        } finally {
            if (null != jedis) {
                jedis.close();
            }
        }
    }

    /**
     * 设置List集合
     * 
     * @param key
     * @param list
     */

    public void setList(String key, List<?> list, long seconds) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            if (list == null || list.size() == 0) {
                jedis.set(key.getBytes(), "".getBytes());
            } else {
                jedis.set(key.getBytes(), SerializeUtil.serializeList(list));
                if (seconds > 0) {
                    jedis.expire(key, (int) seconds);
                }
            }
        } finally {
            if (null != jedis) {
                jedis.close();
            }
        }
    }

    /**
     * 获取List集合
     * 
     * @param key
     * @return
     */

    public List<?> getList(String key) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            byte[] data = jedis.get(key.getBytes());
            return SerializeUtil.deserializeList(data);
        } finally {
            if (null != jedis) {
                jedis.close();
            }
        }
    }

    public boolean exists(String key) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.exists(key);
        } finally {
            if (null != jedis) {
                jedis.close();
            }
        }
    }

    public void expire(String key, int seconds) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            jedis.expire(key, seconds);
        } finally {
            if (null != jedis) {
                jedis.close();
            }
        }
    }
    
    public Long incr(String key, long number) {
        return incr(key, number, 0);
    }
    
    public Long incr(String key, long number, int seconds) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            Long result = jedis.incrBy(key, number);
            if (seconds > 0) {
                jedis.expire(key, seconds);
            }
            return result;
        } finally {
            if (null != jedis) {
                jedis.close();
            }
        }
    }
}
 

序列化工具类

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;

public class SerializeUtil {
    
    /**
     * 单个序列化
     * @param object
     */

    public  static byte[] serialize(Object object){
        if (object==null) {
            return null;
        }
        ObjectOutputStream oos=null;
        ByteArrayOutputStream baos=null;
        byte[] bytes=null;
        try {
            baos=new ByteArrayOutputStream();
            oos=new ObjectOutputStream(baos);
            oos.writeObject(object);
            bytes=baos.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
        }
        finally {
            close(oos);
            close(baos);
        }
        return bytes;
        
    }
    
    /**
     * 
     * 单个反序列化
     * @param bytes
     */

    public static Object deserialize(byte[] bytes){
        if (bytes==null) {
            return null;
        }
        ByteArrayInputStream bais=null;
        ObjectInputStream ois=null;
        try {
            bais=new ByteArrayInputStream(bytes);
            ois=new ObjectInputStream(bais);
            return ois.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            close(ois);
            close(bais);
        }
        return null;
    }
    
    /**
     * 序列号list集合
     * @param list
     */
    
    public static byte[] serializeList(List<?> list){
        if (list==null || list.size()==0) {
            return null;
        }
        ObjectOutputStream oos=null;
        ByteArrayOutputStream baos=null;
        byte[] bytes=null;
        try {
            baos=new ByteArrayOutputStream();
            oos =new ObjectOutputStream(baos);
            for (Object obj : list) {
                oos.writeObject(obj);
            }
            bytes=baos.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
        }
        finally {
            close(oos);
            close(baos);
        }
        return bytes;
    }
    
    /**
     * 反序列化list集合
     * @param bytes
     */
    
    public  static List<?> deserializeList(byte[] bytes){
        if (bytes==null) {
            return null;
        }
        List<Object> list=new ArrayList<>();
        ByteArrayInputStream bais=null;
        ObjectInputStream ois=null;
        try {
            bais=new ByteArrayInputStream(bytes);
            ois=new ObjectInputStream(bais);
            while (bais.available()>0) {
                Object obj=ois.readObject();
                if (obj==null) {
                    break;
                }
                list.add(obj);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            close(ois);
            close(bais);
        }
        return list;
    }
    private static void close(Closeable closeable) {
        if (closeable!=null) {
            try {
                closeable.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        
    }
}
 

新建EquipmentService类

@Component
public class EquipmentService {

 

@Autowired
    private EquipmentRepository equipmentRepository;

 

@Autowired
    private JedisClient client;

 

@SuppressWarnings("unchecked")
    public List<Equipment> getEquiByRedis() {

        List<Equipment> list;
        if (client.getList("equipment") == null || client.getList("equipment").size() == 0) {
            List<Equipment> listEqui = equipmentRepository.findAll();

       //将listEqui已equipment键存入redis，缓存有效期是10分钟
            client.setList("equipment", listEqui, 600);
            list = (List<Equipment>) client.getList("equipment");
        }

       //根据键从缓存中获取liatEqui
        list = (List<Equipment>) client.getList("equipment");
        return list;
    }

}

运行之后可以在Redis数据库中看到以equipment为key的数据。不过list是序列化后存储的，所以是字节形式

 

SpringBoot使用Redis缓存技术
AI天才研究院
07-29 1618
随着互联网应用的普及、网站功能越来越复杂、数据量增长速度加快，单个服务器性能不足已经成为一个无法避免的问题。为了应对这个挑战，很多公司开始采用分布式缓存方案，比如Redis。本文将详细介绍如何在Spring Boot项目中集成Redis，并使用它来作为缓存服务。Redis是一个开源的高级键值存储数据库，它支持多种类型的数据结构，如字符串、哈希、列表、集合、有序集合等。它提供内存保护机制，可以有效防止缓存击穿和雪崩效应。如果你的应用程序需要高速缓存访问且对可靠性要求较高，那么Redis就是一个很好的选择。
SpringBoot整合Redis缓存
m0_67402774的博客
08-02 1458
Redis是一个高性能的Key-Value开源数据库，是一个非关系型的数据库，是为了解决高并发、高扩展，大数据存储等一系列的问题而产生的数据库解决方案。但它不能替代关系型数据库，只能作为特定环境下的扩充。...
SpringbootRedis
06-15
springboot整合redis,并且封装好的一套api，下载配置好即可使用
springboot使用redis
热门推荐
qq_49044908的博客
12-12 4万+
springboot使用redis redis-service.exe : 服务端,启动后不要关闭 redis-cli.exe : 客户端,访问redis中的数据 redisclient-win32.x86_64.2.0.jar : redis的图形界面客户端,执行方式是在这个文件的目录执行 java -jar redisclient-win32.x86_64.2.0.jar 或者在这个jar包的目录下点击即可直接执行 点击server,点击add,设置端口号就可以访问redis了 springboot
SpringBoot集成Redis
最新发布
gghfzs1的博客
09-27 1522
作为数据库,Redis是一个非常快的非关系数据库(),它可以存储键(key)与五种不同类型的值之间的映射,可以将存储在内的键值对数据持久化到硬盘,可以使用复制特性来扩展读性能,还可以使用客户端分片来扩展写性能。1.1数据类型Redis数据类型不仅与关系数据库管理系统(RDBMS)不同,也不同于任何简单的NoSQL键值数据存储。String（字符串）Hash（哈希）List（列表）Set（集合）Zset（Sorted Set：有序集合）
Spring boot 2.0+redis做缓存使用
laohuxiaotu的博客
10-18 325
Spring boot 2.x使用redis和1.x还是有区别的，刚开始填了很多坑才搞定，这里讲完整版笔记列出来 1.添加依赖 &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-data-redis&lt;...
Springboot-redis
BNMZY的博客
05-22 191
文章目录基本配置说明源码序列化 基本 配置 pom.xml <!-- redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> 配置文件 spring: redis: host
SpringBoot使用Redis
培根芝士的专栏
08-17 173
引入jar包 <!-- redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> 配置Redis属性 在application.properties增加Redis服务的相关信息 ##########
SpringBoot使用Redis缓存的实现方法
08-28
为了进一步自定义Redis缓存的行为，我们可以创建一个名为`RedisConfig`的配置类，这里我们将配置缓存管理器和序列化方式： ```java package springboot.config; import org.springframework.beans.factory....
SpringBoot项目 MybatisPlus使用 Redis缓存.zip
02-13
本项目中，我们看到“SpringBoot项目 MybatisPlus使用 Redis缓存.zip”主要涉及了SpringBoot、MybatisPlus和Redis三个核心组件，它们在实际开发中扮演着重要角色。 首先，SpringBoot是Spring框架的一种简化版，它...
Springboot加Redis缓存实现
07-05
总的来说，"Springboot加Redis缓存实现"项目展示了如何在Spring Boot应用中集成并使用Redis作为缓存系统，提高了数据读取效率，同时也提供了数据库操作和API测试的全套方案。理解并掌握这个项目中的知识点，对于开发...
springboot_redis
04-03
spring boot 集成redis，demo 对应博客地址：http://blog.csdn.net/woniu211111/article/details/54564308
十九、SpringBoot之整合redis实现缓存
白夜行悟空
10-22 239
Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。 1、引入redis的start：spring-boot-starter-data-redis &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; ...
SpringBoot 使用redis
qq_65142821的博客
04-06 984
【代码】SpringBoot 使用redis。
SpringBoot使用redis
qq_44255146的博客
04-21 259
1、本地下载redis并且开启 2、导入maven依赖 <!-- redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency>
springboot使用redis缓存
03-28
下面是使用Spring Boot和Redis缓存的步骤： 1. 添加依赖 在`pom.xml`文件中添加以下依赖： ```xml <groupId>org.springframework.boot <artifactId>spring-boot-starter-data-redis ``` 2. 配置Redis 在`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值