项目中Redis的使用

最新推荐文章于 2024-04-19 23:15:56 发布
最新推荐文章于 2024-04-19 23:15:56 发布
阅读量241 收藏
点赞数 1
分类专栏： springboot+vue项目 从0设计一个web项目 文章标签： redis 数据库 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jiaodaqiaobiluo/article/details/128823724
版权

添加依赖

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

<!-- Sa-Token 整合 Redis （使用 jackson 序列化方式） -->
<dependency>
  <groupId>cn.dev33</groupId>
  <artifactId>sa-token-dao-redis-jackson</artifactId>
  <version>1.33.0</version>
</dependency>
<!-- 提供Redis连接池 -->
<dependency>
  <groupId>org.apache.commons</groupId>
  <artifactId>commons-pool2</artifactId>
</dependency>

application.yml配置

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

Redis三部曲

使用StringRedisTemplate

//如果redis里面的key和value都是字符串可以用这个操作
@Autowired
StringRedisTemplate stringRedisTemplate;
private static final long TIME_IN_MS5 = 5 * 60 * 1000;  // 表示5分钟的毫秒数
String key = Constants.EMAIL_CODE + emailPrefix + email;
Integer code = Integer.valueOf(RandomUtil.randomNumbers(6));
stringRedisTemplate.opsForValue().set(key, code, TIME_IN_MS5, TimeUnit.MICROSECONDS);
// 如果这样设置过期时间，是存不进去的
//TimeUnit.MILLISECONDS 是微秒，会导致过期时间过快，很快就没了

String code = stringRedisTemplate.opsForValue().get(key);
stringRedisTemplate.opsForValue().set(key,"“);

在这里插入图片描述

使用RedisTemplate

private final RedisTemplate<String, Object> redisTemplate;
redisTemplate.delete(key);

防止键和值默认的jdk序列化方式出现二进制码：

package com.partner.boot.common;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.springframework.cache.annotation.EnableCaching;
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;

@Configuration
@EnableCaching
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        // 设置 key的序列化方式  防止默认的jdk序列化方式出现二进制码  看不懂
        redisTemplate.setKeySerializer(new StringRedisSerializer());

        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance ,
                ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer); // value的序列化类型

        redisTemplate.setConnectionFactory(connectionFactory);
        return redisTemplate;
    }
}

使用RedisUtils封装

基本使用工具类：

package com.partner.boot.utils;

import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.connection.RedisConnectionCommands;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.concurrent.TimeUnit;

@SuppressWarnings(value = {"unchecked"})
@Component
@Slf4j
public class RedisUtils {
    private static RedisTemplate<String, Object> staticRedisTemplate;

    private final RedisTemplate<String, Object> redisTemplate;

    public RedisUtils(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    // Springboot启动成功之后会调用这个方法
    @PostConstruct
    public void initRedis() {
        // 初始化设置 静态staticRedisTemplate对象，方便后续操作数据
        staticRedisTemplate = redisTemplate;
    }

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key   缓存的键值
     * @param value 缓存的值
     */
    public static <T> void setCacheObject(final String key, final T value) {
        staticRedisTemplate.opsForValue().set(key, value);
    }

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key      缓存的键值
     * @param value    缓存的值
     * @param timeout  时间
     * @param timeUnit 时间颗粒度
     */
    public static <T> void setCacheObject(final String key, final T value, final long timeout, final TimeUnit timeUnit) {
        staticRedisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }

    /**
     * 获得缓存的基本对象。
     *
     * @param key 缓存键值
     * @return 缓存键值对应的数据
     */
    public static <T> T getCacheObject(final String key) {
        return (T) staticRedisTemplate.opsForValue().get(key);
    }

    /**
     * 删除单个对象
     *
     * @param key
     */
    public static boolean deleteObject(final String key) {
        return Boolean.TRUE.equals(staticRedisTemplate.delete(key));
    }

    /**
     * 获取单个key的过期时间
     *
     * @param key
     * @return
     */
    public static Long getExpireTime(final String key) {
        return staticRedisTemplate.getExpire(key);
    }

    /**
     * 发送ping命令
     * redis 返回pong
     */
    public static void ping() {
        String res = staticRedisTemplate.execute(RedisConnectionCommands::ping);
        log.info("Redis ping ==== {}", res);
    }

}

完整工具类：

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.*;
import java.util.concurrent.TimeUnit;

/**
* redis 工具类
**/
@SuppressWarnings(value = {"unchecked", "rawtypes"})
@Component
public class RedisUtils {
private static RedisTemplate staticRedisTemplate;

private final RedisTemplate redisTemplate;

public RedisUtils(RedisTemplate redisTemplate) {
    // 防止key中文乱码
    redisTemplate.setKeySerializer(new StringRedisSerializer()); // key的序列化类型

    Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance ,
                                       ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
    objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

    jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
    redisTemplate.setValueSerializer(jackson2JsonRedisSerializer); // value的序列化类型
    redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
    redisTemplate.afterPropertiesSet();
    this.redisTemplate = redisTemplate;
}

@PostConstruct
public void initRedis() {
    // 初始化设置 静态redis对象，方便后续操作数据
    staticRedisTemplate = redisTemplate;
}

/**
* 缓存基本的对象，Integer、String、实体类等
*
* @param key   缓存的键值
* @param value 缓存的值
*/
public static <T> void setCacheObject(final String key, final T value) {
    staticRedisTemplate.opsForValue().set(key, value);
}

        /**
* 缓存基本的对象，Integer、String、实体类等
*
* @param key      缓存的键值
* @param value    缓存的值
* @param timeout  时间
* @param timeUnit 时间颗粒度
*/
public static <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit) {
    staticRedisTemplate.opsForValue().set(key, value, timeout, timeUnit);
}

public static <T> void setCacheObject(final String key, final T value, final long timeoutInSecond) {
	setCacheObject(key, value, timeoutInSecond, TimeUnit.SECONDS);
}

  /**
  * 设置有效时间
  *
  * @param key     Redis键
  * @param timeout 超时时间
  * @return true=设置成功；false=设置失败
  */
  public static boolean expire(final String key, final long timeout) {
  	return expire(key, timeout, TimeUnit.SECONDS);
  }

  /**
  * 设置有效时间
  *
  * @param key     Redis键
  * @param timeout 超时时间
  * @param unit    时间单位
  * @return true=设置成功；false=设置失败
  */
  public static boolean expire(final String key, final long timeout, final TimeUnit unit) {
  	return Boolean.TRUE.equals(staticRedisTemplate.expire(key, timeout, unit));
  }

 /**
 * 获取单个key的过期时间
 * @param key
 * @return
 */
  public static Long getExpireTime(final String key) {
    return staticRedisTemplate.getExpire(key);
  }

  /**
  * 获得缓存的基本对象。
  *
  * @param key 缓存键值
  * @return 缓存键值对应的数据
  */
  public static <T> T getCacheObject(final String key) {
  ValueOperations<String, T> operation = staticRedisTemplate.opsForValue();
  	return operation.get(key);
  }

  /**
  * 删除单个对象
  *
  * @param key
  */
  public static boolean deleteObject(final String key) {
  	return Boolean.TRUE.equals(staticRedisTemplate.delete(key));
  }

  /**
  * 删除集合对象
  *
  * @param collection 多个对象
  * @return
  */
  public static Long deleteObject(final Collection collection) {
  	return staticRedisTemplate.delete(collection);
  }

  /**
  * 缓存List数据
  *
  * @param key      缓存的键值
  * @param dataList 待缓存的List数据
  * @return 缓存的对象
  */
  public static <T> long setCacheList(final String key, final List<T> dataList) {
  Long count = staticRedisTemplate.opsForList().rightPushAll(key, dataList);
  	return count == null ? 0 : count;
  }

  /**
  * 获得缓存的list对象
  *
  * @param key 缓存的键值
  * @return 缓存键值对应的数据
  */
  public static <T> List<T> getCacheList(final String key) {
  	return staticRedisTemplate.opsForList().range(key, 0, -1);
  }

  /**
  * 缓存Set
  *
  * @param key     缓存键值
  * @param dataSet 缓存的数据
  * @return 缓存数据的对象
  */
  public static <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet) {
      BoundSetOperations<String, T> setOperation = staticRedisTemplate.boundSetOps(key);
      Iterator<T> it = dataSet.iterator();
      while (it.hasNext()) {
      setOperation.add(it.next());
      }
      return setOperation;
  }

  /**
  * 获得缓存的set
  *
  * @param key
  * @return
  */
  public static <T> Set<T> getCacheSet(final String key) {
  	return staticRedisTemplate.opsForSet().members(key);
  }

  /**
  * 缓存Map
  *
  * @param key
  * @param dataMap
  */
  public static <T> void setCacheMap(final String key, final Map<String, T> dataMap) {
      if (dataMap != null) {
      	staticRedisTemplate.opsForHash().putAll(key, dataMap);
      }
  }

  /**
  * 获得缓存的Map
  *
  * @param key
  * @return
  */
  public static <T> Map<String, T> getCacheMap(final String key) {
  	return staticRedisTemplate.opsForHash().entries(key);
  }

  /**
  * 往Hash中存入数据
  *
  * @param key   Redis键
  * @param hKey  Hash键
  * @param value 值
  */
  public static <T> void setCacheMapValue(final String key, final String hKey, final T value) {
  	staticRedisTemplate.opsForHash().put(key, hKey, value);
  }

  /**
  * 获取Hash中的数据
  *
  * @param key  Redis键
  * @param hKey Hash键
  * @return Hash中的对象
  */
  public static <T> T getCacheMapValue(final String key, final String hKey) {
  HashOperations<String, String, T> opsForHash = staticRedisTemplate.opsForHash();
  	return opsForHash.get(key, hKey);
  }

  /**
  * 删除Hash中的数据
  *
  * @param key
  * @param hKey
  */
  public static void delCacheMapValue(final String key, final String hKey) {
      HashOperations hashOperations = staticRedisTemplate.opsForHash();
      hashOperations.delete(key, hKey);
  }

  /**
  * 获取多个Hash中的数据
  *
  * @param key   Redis键
  * @param hKeys Hash键集合
  * @return Hash对象集合
  */
  public static <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys) {
  	return staticRedisTemplate.opsForHash().multiGet(key, hKeys);
  }

  /**
  * 获得缓存的基本对象列表
  *
  * @param pattern 字符串前缀
  * @return 对象列表
  */
  public static Collection<String> keys(final String pattern) {
  	return staticRedisTemplate.keys(pattern);
  	}
}
龙崎流河
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Redis详解及在项目中应用
weixin_43816557的博客
08-16 6449
本人目前写的所有文章都是基于springboot项目中可能用到的框架技术，如有需要，可在专栏中寻找。本文从简单介绍redis的基本操刀到在项目中redis的应用，再到缓存预热的介绍，最后介绍了创建更新缓存计划内容，由浅入深逐步剖析。...
redis在项目中的使用
宇默
02-21 346
一、为什么使用 解决应用服务器的cpu和内存压力 减少io的读操作，减轻io的压力 关系型数据库的扩展性不强，难以改变表结构 二、优点： nosql数据库没有关联关系，数据结构简单，拓展表比较容易 nosql读取速度快，对较大数据处理快 三、适用场景： 数据高并发的读写 海量数据的读写 对扩展性要求高的数据 四、不适场...
Redis基础篇——介绍以及了解
WXiangQian
10-24 662
Redis基础篇 安装 Redis基础篇——Redis安装 Redis 介绍 Redis 是完全开源免费的，遵守BSD协议，是一个高性能的key-value数据库。 Redis 与其他 key - value 缓存产品有以下三个特点： Redis支持数据的持久化，可以将内存中的数据保存在磁盘...
Redis: 在项目中的应用
最新发布
玉汝于成
04-19 1158
在分布式系统中，单纯的Java API并不能提供分布式锁的能力，为了解决这个问题就需要一种跨JVM的互斥机制来控制共享资源的访问，这就是分布式锁要解决的问题。Redission是一个在Redis的基础上实现的Java驻内存数据网格（in-Memory Data Grid）。它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务，其中就包含了各种分布式锁的实现。可重入锁（ReentrantLock）公平锁（Fair Lock）联锁（MultiLock）红锁（RedLock）
Redis在项目中的应用
Li2992673708的博客
09-09 1009
需要根据具体的项目需求和场景来选择合适的 Redis 应用方式，并结合 Redis 提供的丰富功能和数据结构进行开发和优化。将用户的得分或其他指标作为有序集合的分值，可以快速获取排名和前几名的数据。可以将重要的数据存储在 Redis 中，并配合持久化机制，将数据持久化到磁盘，以防止数据丢失。地理位置服务：Redis 提供了地理位置数据的存储和查询功能，可以用于构建地理位置相关的应用，如附近的人、地理位置索引等。通过 Redis 的原子操作和锁的特性，可以实现多个进程或线程之间的互斥访问控制。
Redis的介绍及基本使用
qq_47075878的博客
05-13 1633
学习尚硅谷的Redis学习时所做的笔记。
Redis缓存在项目中的使用
qq_40285302的博客
11-01 200
关于redis为什么能作为缓存这个问题我们就不说了，直接来说一下redis缓存到底如何在项目中使用吧： 1.redis缓存如何在项目中配置？    1.1redis缓存单机版和集群版配置？（redis的客户端jedis常用） 1 2 3 4 5 6 7 8 9 10 11 12 13 ...
C# winform中使用Redis
03-22
在C# WinForm应用中使用Redis作为数据存储和缓存工具是一种常见的技术实践。Redis，全称Remote Dictionary Server，是一个高性能的键值数据库，支持多种数据结构如字符串、哈希、列表、集合和有序集合等，广泛应用于...
Laravel中Redis的配置和使用
08-22
例如，我们可以使用以下代码来设置和获取Redis中的数据： use Illuminate\Support\Facades\Redis; class IndexController extends Controller { public function useRedis() { Redis::set('foo', 2); echo ...
SpringBoot项目中使用redis缓存的方法步骤
08-28
本篇文章主要介绍了SpringBoot项目中使用redis缓存的方法步骤，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
新手入门redis 项目使用
08-15
新手入门redis 在项目中应用，学习！综合业务管理平台分布式redis集群 开发与运维
Redis如何在项目中合理使用经验分享
09-09
Redis，全称Remote Dictionary Server，是一款高性能的键值存储系统，尤其适合于处理大量数据的高速访问需求。它以其高效、灵活的数据结构和丰富的功能，成为许多互联网...希望这些经验对你在项目中使用Redis有所帮助。
C#中如何使用redis
12-17
在C#中使用Redis作为数据存储和缓存系统是一个高效的选择，因为它提供了丰富的数据结构和原子性操作。Redis是一个开源的、基于键值对的NoSQL数据库，它将数据存储在内存中，以提供高速访问。为了在C#应用程序中使用...
Redis配置
zq123zzz的博客
02-13 110
Redis基本配置
Redis在项目中怎么用的，存的是什么
大连赵哥的博客
02-25 647
Redis在项目中怎么用的，存的是什么
Java随笔 | Springboot项目中引入并使用redis（步骤）
野生猿林仔的博客
01-30 2402
在Springboot项目中使用Redis需先确保服务器（或主机）已安装Redis并开启端口。在业务层中使用Redis有两种装配方式，两者任选其一即可。
java语言里redis在项目中使用场景，每个场景的样例代码
wuchongyong的博客
05-18 1540
#22、分布式事务消息实现幂等性：使用Redis实现分布式事务消息实现幂等性，避免重复操作。##23、分布式缓存更新实现幂等性：使用Redis实现分布式缓存更新实现幂等性，避免重复操作。##19、分布式事务消息：使用Redis实现分布式事务消息，支持跨服务的事务消息处理。##20、分布式锁实现限流：使用Redis实现分布式锁实现限流功能，控制请求流量。##21、分布式锁实现幂等性：使用Redis实现分布式锁实现幂等性，避免重复操作。##7、聊天室：使用Redis实现聊天室功能，支持实时聊天、消息记录等。
Redis总结及项目中应用
weixin_49238443的博客
07-22 3450
总结redis常见问题与超卖问题
项目中redis的使用
06-07
在项目中，Redis通常用于缓存数据、消息队列、计数器、分布式锁等功能。以下是一些常见的应用场景： 1. 缓存数据：将经常访问的数据缓存到Redis中，减轻数据库的负担，提高访问速度。 2. 消息队列：使用Redis的List数据结构作为消息队列，实现异步处理任务或者消息推送。 3. 计数器：使用Redis的Increment命令实现计数器，可以实现实时统计访问量、PV、UV等数据。 4. 分布式锁：使用Redis的setnx命令实现分布式锁，保证多个进程或者线程同时访问共享资源时的数据安全。 在代码中使用Redis可以使用Redis的客户端，如Jedis、Lettuce等，连接Redis服务器并进行对应的操作。例如，使用Jedis操作Redis缓存可以如下： ```java //连接Redis服务器 Jedis jedis = new Jedis("127.0.0.1", 6379); //设置缓存 jedis.set("key", "value"); //获取缓存 String value = jedis.get("key"); //关闭连接 jedis.close(); ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

龙崎流河

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

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

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

打赏作者

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

抵扣说明：

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

余额充值