秒杀商品查询接口性能优化（redis中取值）

最新推荐文章于 2024-06-07 21:41:12 发布
最新推荐文章于 2024-06-07 21:41:12 发布
阅读量38 收藏
点赞数
分类专栏： springboot分布式电商秒杀系统 文章标签： 性能优化 redis 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68935893/article/details/135030895
版权 
package com.java1234.miaosha.controller;

import com.java1234.miaosha.constant.Constant;
import com.java1234.miaosha.entity.MiaoShaGoods;
import com.java1234.miaosha.entity.R;
import com.java1234.miaosha.service.IMiaoShaGoodsService;
import com.java1234.miaosha.util.RedisUtil;
import com.java1234.miaosha.vo.MiaoShaGoodsVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 秒杀商品控制器
 */
@RestController
@RequestMapping("/miaoShaGoods")
public class MiaoShaGoodsController {

    @Autowired
    private IMiaoShaGoodsService miaoShaGoodsService;


    @Autowired
    private RedisUtil redisUtil;
    /**
     * 查询所有秒杀商品
     * @return
     */
    @RequestMapping("/findAll")
    public R findAll(){
        List<MiaoShaGoodsVo> miaoShaGoodsList=null;
        Object o=redisUtil.get(Constant.REDIS_MIAOSHA_GOODS);
        if(o==null){
            System.out.println("从数据库里面查询");
            miaoShaGoodsList = miaoShaGoodsService.listAll();
            redisUtil.set(Constant.REDIS_MIAOSHA_GOODS,miaoShaGoodsList,Constant.REDIS_MIAOSHA_GOODS_EXPIRE);

        }else{
            System.out.println("从redis中取值");
            miaoShaGoodsList= (List<MiaoShaGoodsVo>) o;
        }
        Map<String,Object> map=new HashMap<>();
        map.put("data",miaoShaGoodsList);
        return R.ok(map);
    }
}


package com.java1234.miaosha.util;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

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

/**
 * Redis工具类
 * @author Administrator
 *
 */
@Component
public class RedisUtil {

	@Resource(name="redisTemplate")
	private RedisTemplate<String, Object> redisTemplate;

	@Resource(name="redisTemplate2")
	private RedisTemplate<String, Object> redisTemplate2;


	//=============================common============================
	/**
	 * 指定缓存失效时间
	 * @param key 键
	 * @param time 时间(秒)
	 * @return
	 */
	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;
		}
	}

	/**
	 * 指定缓存失效时间
	 * @param prefix 前缀
	 * @param key 键
	 * @param time 时间(秒)
	 * @return
	 */
	public boolean expire(String prefix,String key,long time){
		try {
			if(time>0){
				redisTemplate.expire(prefix+key, time, TimeUnit.SECONDS);
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 根据key 获取过期时间
	 * @param key 键 不能为null
	 * @return 时间(秒) 返回0代表为永久有效
	 */
	public long getExpire(String key){
		return redisTemplate.getExpire(key,TimeUnit.SECONDS);
	}

	/**
	 * 判断key是否存在
	 * @param key 键
	 * @return true 存在 false不存在
	 */
	public boolean hasKey(String key){
		try {
			return redisTemplate.hasKey(key);
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 删除缓存
	 * @param key 可以传一个值 或多个
	 */
	@SuppressWarnings("unchecked")
	public void del(String ... key){
		if(key!=null&&key.length>0){
			if(key.length==1){
				redisTemplate.delete(key[0]);
			}else{
				redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
			}
		}
	}

	//============================String=============================
	/**
	 * 普通缓存获取
	 * @param key 键
	 * @return 值
	 */
	public Object get(String key){
		return key==null?null:redisTemplate.opsForValue().get(key);
	}

	/**
	 * 普通缓存获取
	 * @param prefix 前缀
	 * @param key 键
	 * @return 值
	 */
	public Object get(String prefix,String key){
		return key==null?null:redisTemplate.opsForValue().get(prefix+key);
	}

	/**
	 * 普通缓存放入
	 * @param key 键
	 * @param value 值
	 * @return true成功 false失败
	 */
	public boolean set(String key,Object value) {
		try {
			redisTemplate.opsForValue().set(key, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}

	}

	/**
	 * 普通缓存放入(带前缀)
	 * @param prefix 前缀
	 * @param key 键
	 * @param value 值
	 * @return true成功 false失败
	 */
	public boolean set(String prefix,String key,Object value) {
		try {
			redisTemplate.opsForValue().set(prefix+key, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}

	}


	/**
	 * 普通缓存放入(带前缀)
	 * @param prefix 前缀
	 * @param key 键
	 * @param value 值
	 * @return true成功 false失败
	 */
	public boolean set2(String prefix,String key,Object value) {
		try {
			redisTemplate2.opsForValue().set(prefix+key, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}

	}

	/**
	 * 普通缓存放入并设置时间
	 * @param key 键
	 * @param value 值
	 * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
	 * @return true成功 false 失败
	 */
	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;
		}
	}

	/**
	 * 普通缓存放入并设置时间
	 * @param prefix 前缀
	 * @param key 键
	 * @param value 值
	 * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
	 * @return true成功 false 失败
	 */
	public boolean set(String prefix,String key,Object value,long time){
		try {
			if(time>0){
				redisTemplate.opsForValue().set(prefix+key, value, time, TimeUnit.SECONDS);
			}else{
				set(prefix+key, value);
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

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

	/**
	 * 递减
	 * @param key 键
	 * @param by 要减少几(小于0)
	 * @return
	 */
	public long decr(String key, long delta){
		if(delta<0){
			throw new RuntimeException("递减因子必须大于0");
		}
		return redisTemplate2.opsForValue().increment(key, -delta);
	}

	/**
	 * 递减
	 * @param key 键
	 * @param by 要减少几(小于0)
	 * @return
	 */
	public long decr(String prefix,String key, long delta){
		if(delta<0){
			throw new RuntimeException("递减因子必须大于0");
		}
		return redisTemplate2.opsForValue().decrement(prefix+key, delta);
	}

	//================================Map=================================
	/**
	 * HashGet
	 * @param key 键 不能为null
	 * @param item 项 不能为null
	 * @return 值
	 */
	public Object hget(String key,String item){
		return redisTemplate.opsForHash().get(key, item);
	}

	/**
	 * 获取hashKey对应的所有键值
	 * @param key 键
	 * @return 对应的多个键值
	 */
	public Map<Object,Object> hmget(String key){
		return redisTemplate.opsForHash().entries(key);
	}

	/**
	 * HashSet
	 * @param key 键
	 * @param map 对应多个键值
	 * @return true 成功 false 失败
	 */
	public boolean hmset(String key, Map<String,Object> map){
		try {
			redisTemplate.opsForHash().putAll(key, map);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * HashSet 并设置时间
	 * @param key 键
	 * @param map 对应多个键值
	 * @param time 时间(秒)
	 * @return true成功 false失败
	 */
	public boolean hmset(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;
		}
	}

	/**
	 * 向一张hash表中放入数据,如果不存在将创建
	 * @param key 键
	 * @param item 项
	 * @param value 值
	 * @return true 成功 false失败
	 */
	public boolean hset(String key,String item,Object value) {
		try {
			redisTemplate.opsForHash().put(key, item, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 向一张hash表中放入数据,如果不存在将创建
	 * @param key 键
	 * @param item 项
	 * @param value 值
	 * @param time 时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
	 * @return true 成功 false失败
	 */
	public boolean hset(String key,String item,Object value,long time) {
		try {
			redisTemplate.opsForHash().put(key, item, value);
			if(time>0){
				expire(key, time);
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 删除hash表中的值
	 * @param key 键 不能为null
	 * @param item 项 可以使多个 不能为null
	 */
	public void hdel(String key, Object... item){
		redisTemplate.opsForHash().delete(key,item);
	}

	/**
	 * 判断hash表中是否有该项的值
	 * @param key 键 不能为null
	 * @param item 项 不能为null
	 * @return true 存在 false不存在
	 */
	public boolean hHasKey(String key, String item){
		return redisTemplate.opsForHash().hasKey(key, item);
	}

	/**
	 * hash递增 如果不存在,就会创建一个 并把新增后的值返回
	 * @param key 键
	 * @param item 项
	 * @param by 要增加几(大于0)
	 * @return
	 */
	public double hincr(String key, String item,double by){
		return redisTemplate.opsForHash().increment(key, item, by);
	}

	/**
	 * hash递减
	 * @param key 键
	 * @param item 项
	 * @param by 要减少记(小于0)
	 * @return
	 */
	public double hdecr(String key, String item,double by){
		return redisTemplate.opsForHash().increment(key, item,-by);
	}

	//============================set=============================
	/**
	 * 根据key获取Set中的所有值
	 * @param key 键
	 * @return
	 */
	public Set<Object> sGet(String key){
		try {
			return redisTemplate.opsForSet().members(key);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 根据value从一个set中查询,是否存在
	 * @param key 键
	 * @param value 值
	 * @return true 存在 false不存在
	 */
	public boolean sHasKey(String key,Object value){
		try {
			return redisTemplate.opsForSet().isMember(key, value);
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 将数据放入set缓存
	 * @param key 键
	 * @param values 值 可以是多个
	 * @return 成功个数
	 */
	public long sSet(String key, Object...values) {
		try {
			return redisTemplate.opsForSet().add(key, values);
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}

	/**
	 * 将set数据放入缓存
	 * @param key 键
	 * @param time 时间(秒)
	 * @param values 值 可以是多个
	 * @return 成功个数
	 */
	public long sSetAndTime(String key,long time,Object...values) {
		try {
			Long count = redisTemplate.opsForSet().add(key, values);
			if(time>0) expire(key, time);
			return count;
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}

	/**
	 * 获取set缓存的长度
	 * @param key 键
	 * @return
	 */
	public long sGetSetSize(String key){
		try {
			return redisTemplate.opsForSet().size(key);
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}

	/**
	 * 移除值为value的
	 * @param key 键
	 * @param values 值 可以是多个
	 * @return 移除的个数
	 */
	public long setRemove(String key, Object ...values) {
		try {
			Long count = redisTemplate.opsForSet().remove(key, values);
			return count;
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}
	//===============================list=================================

	/**
	 * 获取list缓存的内容
	 * @param key 键
	 * @param start 开始
	 * @param end 结束  0 到 -1代表所有值
	 * @return
	 */
	public List<Object> lGet(String key,long start, long end){
		try {
			return redisTemplate.opsForList().range(key, start, end);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 获取list缓存的长度
	 * @param key 键
	 * @return
	 */
	public long lGetListSize(String key){
		try {
			return redisTemplate.opsForList().size(key);
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}

	/**
	 * 通过索引 获取list中的值
	 * @param key 键
	 * @param index 索引  index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
	 * @return
	 */
	public Object lGetIndex(String key,long index){
		try {
			return redisTemplate.opsForList().index(key, index);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 将list放入缓存
	 * @param key 键
	 * @param value 值
	 * @param time 时间(秒)
	 * @return
	 */
	public boolean lSet(String key, Object value) {
		try {
			redisTemplate.opsForList().rightPush(key, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 将list放入缓存
	 * @param key 键
	 * @param value 值
	 * @param time 时间(秒)
	 * @return
	 */
	public boolean lSet(String key, Object value, long time) {
		try {
			redisTemplate.opsForList().rightPush(key, value);
			if (time > 0) expire(key, time);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 将list放入缓存
	 * @param key 键
	 * @param value 值
	 * @param time 时间(秒)
	 * @return
	 */
	public boolean lSet(String key, List<Object> value) {
		try {
			redisTemplate.opsForList().rightPushAll(key, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 将list放入缓存
	 * @param key 键
	 * @param value 值
	 * @param time 时间(秒)
	 * @return
	 */
	public boolean lSet(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中的某条数据
	 * @param key 键
	 * @param index 索引
	 * @param value 值
	 * @return
	 */
	public boolean lUpdateIndex(String key, long index,Object value) {
		try {
			redisTemplate.opsForList().set(key, index, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 移除N个值为value
	 * @param key 键
	 * @param count 移除多少个
	 * @param value 值
	 * @return 移除的个数
	 */
	public long lRemove(String key,long count,Object value) {
		try {
			Long remove = redisTemplate.opsForList().remove(key, count, value);
			return remove;
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}
}
九品印相
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
秒杀商品详情后台接口开发
m0_68935893的博客
12-18 337
【代码】秒杀商品详情后台接口开发。
Node + Redis 接口性能优化实战
06-15
为什么要使用Redis优化接口性能？ -----?原因很简单，快！非常快！ 如果遇到大并发，高负载的网站中你是必须要考虑redis的，redis数据库中的所有数据都存储在内存中。由于内存的读写速度远快于硬盘，因此Redis的的的在性能上对比其他基于硬盘存储的数据库有非常明显的优势。 我们在碰到需要执行耗时特别久，且结果不频繁变动的SQL，就特别适合将运行结果放入缓存，这样，后面的请求就去缓存中读取，请求使得能够非常迅速的响应，极大的提升我们的API接口的性能。
Redis03-优惠券秒杀
qq_42861526的博客
10-08 1063
该方法的思路：一个long类型有8个字节，用四个字节(32位)存放时间信息(136.102208 年)，四个字节存放这一天的订单数量。那么这种方法从项目开始计时，能够正确运行2^32 秒，每天最多能生成2^32个id。其实我们也可以只用16位来存储当前count，剩下48位来存放时间信息，如果一天内达不到2^32次方的订单id生成量，不如节省下来位数存储时间信息让项目运行的更久。
针对秒杀项目做的一些优化
qq_45661125的博客
02-09 1304
秒杀业务逻辑数据库的设计一些全局配置JSR303参数验证（手机号）登录秒杀优化缓存优化Redis的封装页面缓存对象缓存客户端的缓存（页面静态化+前后端分离）接口优化安全方面明文密码两次MD5处理秒杀接口地址隐藏接口限流 做了一个秒杀项目，并对其做了一定的优化！ 业务逻辑 数据库的设计 为什么将秒杀的商品单独建一张表（秒杀表）而不再商品表添加一个字段来判断呢，因为今天可能是秒杀，明天可能是9.9包邮，这样的话导致商品表越来越难以维护 一些全局配置 全局异常处理 错误信息描述 JSR303参数
SpringBoot、Redis轻松实现Java高并发秒杀系统笔记
今天你学Java了吗
09-13 2137
优极限【完整项目实战】半天带你用-springBoot、Redis轻松实现Java高并发秒杀系统项目笔记附带大厂面试常考秒杀问题
分布式存储极致性能Redis(2)
qq_43478625的博客
10-29 1146
分布式存储极致性能Redis一、SRM(SpringBoot+Redis+Mybatis)(重写Redis的序列化)的缓存实战1.1 新增Redis和Swagger2的配置类1.2 编写service层和controller层并编写dto层1.3 启动项目使用swagger进行测试1.3.1 测试新增1.3.2 测试删除1.3.3 测试修改1.3.4 测试查询1.4 优化(防止缓存击穿)二、redis经典五种数据类型及其底层实现2.1 redis中的所有数据类型2.2 redis注意事项及使用说明2.3 r
04 Redis 性能优化13条军规.pdf
04-23
04 Redis 性能优化13条军规.pdf04 Redis 性能优化13条军规.pdf04 Redis 性能优化13条军规.pdf04 Redis 性能优化13条军规.pdf04 Redis 性能优化13条军规.pdf04 Redis 性能优化13条军规.pdf04 Redis 性能优化13条军规....
Redis硬核性能优化
04-14
一、Redis为什么变慢了，分析Redis变慢的10个原因。 二、怎么确定Redis变慢了，多种工具协调定位是否变慢了，哪里变慢了？ 三、针对变慢如何进行精准优化？ 四、Redis优化流程化步骤，帮助应对线上问题。
Redis缓存设计与性能优化精要
12-16
本文深入探讨了Redis缓存的关键策略与性能优化技巧。首先，解决缓存穿透，强调缓存空对象与布隆过滤器的应用。接着，针对缓存击穿与雪崩问题，提出过期时间随机化和高可用架构设计的解决方案。特别强调热点Key重建...
Redis性能优化培训.pptx
08-08
通过本培训文档快速掌握Redis性能优化，主要包含Redis性能数据指标，常见性能问题分析，性能优化方案等。
MySQL之查询性能优化(四)
Cover_sky的博客
06-04 1739
一般来说，不需要去理解MySQL通信协议的内部实现细节，只需要大致理解通信协议是如何工作的。MySQL客户端和服务器之间的通信协议是"半双工"的，这意味着，在任何一个时刻，要么是由服务器向客户端发送数据，要么是由客户端向服务器发送数据，这两个动作不能同时发生。所以，我们也无法也无须将一个消息切成小块独立来发送。这种协议让MySQL通信简单快速，但是也从很多地方限制了MySQL.一个明显的限制是，这意味着没法进行流量控制。一旦一端开始发送消息，另一端要接收完整个消息才能响应它。
Web 网页性能优化
guoqkmiss的博客
06-04 970
预加载扫描程序的角色是推测性，也就是说，它会检查原始标记，以便查找资源，以便在主要HTML解析器发现之前抓取相应资源预加载扫描程序是一种浏览器优化，采用辅助HTML解析器的形式，可扫描原始HTML响应，以找出并推测性地提取资源，然后主HTML解析器才会发现这些资源为了充分利用预加载扫描器，服务器发送的HTML标记中应包含关键资源。由CSS使用属性加载的图片。这些图片引用位于CSS中，预加载扫描器无法发现这些引用动态加载的脚本，采用元素标记（使用JavaScript注入DOM。
Linux 性能优化基础
czw
06-07 823
【代码】Linux 性能优化基础。
MySQL之查询性能优化(十)
最新发布
Cover_sky的博客
06-07 705
由于历史原因，MySQL并不支持松散索引扫描，也就无法按照不连续的方式扫描一个索引。通常，MySQL的索引扫描需要先定义一个起点和终点，即使需要的数据只是这段索引中很少数的几个，MySQL仍需要扫描这段儿索引中的每一个条目。下面我们通过一个示例说明这点。因为索引的前导字段是列a，但是在查询中只指定了字段b,MySQL无法使用这个索引，从而只能通过全表扫描找到匹配的行，如图所示。了解索引的物理结构的话，不难发现还可以有一个更快的办法执行上面的查询。
小索引大力量，记一次explain的性能优化经历
Hanko的专栏
06-04 1041
在 MySQL 的生产环境中，性能问题是一个常见的挑战。当数据库查询响应时间变慢，或者系统资源消耗异常时，我们需要快速定位问题并进行优化。MySQL 提供了一个强大的工具——EXPLAIN，它可以帮助我们分析查询语句的执行计划，从而找到性能瓶颈。本文模拟之前生产环境mysql性能问题的优化过程，对生产环境的复盘。系统上线后正常使用，大概1年后就出现业务慢，运维反馈某些业务操作会让服务器cpu飙升到100%以上。
程序性能优化
SunGuangHuiM的博客
06-04 331
索引 没加索引（where条件字段、order by字段，常用字段添加索引） 索引没生效 选错索引 SQL优化SQL数据库性能优化-CSDN博客 远程调用 并行调用 数据异构 重复调用 循环查数据库 死循环 无限递归 异步处理 线程池 mq服务器（全称消息队列服务器） 避免大事务(大事务引发的问题：死锁、锁等待、回滚时间长、接口超时、并发情况下数据库连接池被占满、数据库主从延迟) 少用@Transactional注解 将查询（select）方
MySQL之查询性能优化(三)
Cover_sky的博客
06-04 1127
在优化有问题的查询时，目标应该是找到一个更优的方法获得实际需要的记过——而不是一定总是需要从MySQL获取一模一样的结果集。有时候，可以将查询转换一种写法让其返回一样的结果，但是性能更好。但也可以通过修改应用代码，用另一种方式完成查询，最终达到一样的目的。
【核心动画-转场动画-CATransition Objective-C语言】
madoca的博客
06-05 925
【核心动画-转场动画-CATransition Objective-C语言】
springboot从redis中取值
05-12
以下是从Redis中获取值的示例代码： 1. 添加Redis依赖 在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、付费专栏及课程。

余额充值