java点赞功能的实现，类似微信点赞，用户仅能点赞一次，基于redis进行操作

最新推荐文章于 2023-10-09 09:16:56 发布
最新推荐文章于 2023-10-09 09:16:56 发布
阅读量2.6k 收藏 14
点赞数 3
分类专栏： redis的使用 文章标签： redis java 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LOVE320722/article/details/120564041
版权
该博客介绍了如何利用Redis的Set数据结构实现新闻点赞功能。当用户点赞或取消点赞时，通过Redis进行操作。如果点赞状态为1，则添加到Set中，反之则从Set中移除。同时，博客提供了相关的Redis操作代码，包括查询、添加、删除等操作。
摘要由CSDN通过智能技术生成

1.redis 基本知识

redis5种基本数据
学习参考链接
在这里插入图片描述
缓存点赞信息的数据结构是set集合，不太了解的同学请参考上面的链接
在这里插入图片描述

2.实现逻辑

传入点赞人id，被点赞的id，以及点赞的状态status 0取消，1点赞
先查询redis中是否有缓存，无新建，有添加

3.实现代码

 @PostMapping("/clickPraise")
    public ResultVO clickPraise(HttpServletRequest request, @RequestBody String param) {
        if (JSON.parseObject(param).containsKey("newsId")) {
            if (JSON.parseObject(param).containsKey("status")) {
                RegAlumniuser user = sysUserUtil.getUser(request);
                String newsId = JSON.parseObject(param).getString("newsId");//新闻主键id
                String status = JSON.parseObject(param).getString("status");//点赞状态
                if (status.equals("1")) {//点赞状态为1 ，点赞
                    boolean b = redisUtil.hasKey("like_news" + newsId);
                    if (b == false) {//不存在，需新建
                        redisUtil.sSet("like_news" + newsId, newsId + "::" + user.getRegAlumniuserid());
                    }
                    redisUtil.sSetAndTime("like_news" + newsId, 3000, newsId + "::" + user.getRegAlumniuserid());//存在则向缓存中添加
                } else {//取消点赞
                    redisUtil.setRemove("like_news" + newsId, newsId + "::" + user.getRegAlumniuserid());
                }
                boolean b = redisUtil.sHasKey("like_news" + newsId, newsId + "::" + user.getRegAlumniuserid());//判断value是否还在redis中
                if (b == true) {
                    return new ResultVO(ResultCode.SUCCESS, 1);//点赞成功
                }
                return new ResultVO(ResultCode.SUCCESS, 0);//无点赞
            }
            return new ResultVO(ResultCode.FAILED, "请传入参数");
        }
        return new ResultVO(ResultCode.FAILED, "请传入参数");
    }

redis工具类

package common.util;

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

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

/**
 * @ClassName RedisUtil
 * @Description redis工具类
 * @author
 * @date 
 */
@Component
public class RedisUtil {

    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    public RedisUtil(){

    }

// =============================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;
        }
    }

    /**
     * 根据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(CollectionUtils.arrayToList(key));
            }
        }
    }

    /**
     * 删除所有缓存
     */
    @SuppressWarnings("unchecked")
    public void delAll() {

        redisTemplate.execute((RedisCallback) connection -> {
            connection.flushDb();
            return null; }
            );
//        Set<String> keys = redisTemplate.keys(""+"*");
//        redisTemplate.delete(keys);
    }


    public Set<String> keys(){

        return redisTemplate.keys("*");
    }


    // ============================String=============================
    /**
     * 普通缓存获取
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(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 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 key 键
     * @param delta 要增加几(大于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 delta 要减少几(小于0)
     * @return
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    // ================================Map=================================
    /**
     * HashGet
     * @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 值
     * @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 值
     * @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;
        }
    }

}
不加糖的沙
关注
专栏目录
（Java企业 / 公司项目）点赞业务系统设计（一）
全栈技术分享，项目分享，资料分享
09-10 912
按照CSDN文章点赞来进行简单的制作一个点赞和取消点赞的业务需求，当然肯定比他的设计还要简单毕竟这么大的社区。点赞功能与其它功能不同，没有复杂的原型和需求，仅仅是一个点赞、取消点赞的操作。 所以，今天我们就不需要从原型图来分析，而是仅仅从这个功能的实现方案来思考。第一次我们使用的是服务调用openfeign，后来改用了MQ的方式 这个数据结构设计应该都能看得懂吧，有多个id进行关联，实体业务有很多这里就是举例了两个一个用户评论id ，相关的课程比如他讲的好我给这个课程点赞 3.创建项目模块 只要先创建
基于SpringBoot+redis如何实现一个点赞功能？
weixin_45566993的博客
01-22 1669
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 基于SpringBoot+redis如何实现一个点赞功能？ 解析： 基于 SpringCloud, 用户发起点赞、取消点赞后先存入 Redis 中，再每隔两小时从 Redis 读取点赞数据写入数据库中做持久化存储。 点赞功能在很多系统中都有，但别看功能小，想要做好需要考虑的东西
JavaWeb 实现点赞功能
12-22
写了一个点赞功能 　　主要内容是实现一个用户对同一文章只能点赞一次，第二次是取消赞 　　思路： 　　1.首先通过aid和uid遍历点赞表great。 　　2.若不能够查找到符合的great，则文章的great值+1；若能够查找到符合的great，则文章的great值-1。 　　3.然后更新数据库中这条数据 　　Dao层主要代码如下 　　//点赞 　　public Great findGreat(Integer aid， Integer uid) { 　　String hql="from Great where aid=? and uid=?"; 　　List
java实现点赞功能，记录点赞数，只点一次
sinat_36891648的博客
08-25 1209
需求：用户点击增加点赞数，再次点击取消点赞，并记录点赞数 1.使用redis记录点赞信息，防止重复点赞或取消点赞 2.使用数据库记录点赞记录、用户表记录点赞数
Java代码实现点赞功能
weixin_54051907的博客
02-21 1041
个人搭建的一个美食教程网站，每个美食教程的详细页面有一个点赞按钮，每个用户可以通过点击按钮来点赞与取消点赞，并可以看见当前菜品有多少个赞。 因为点赞与取消点赞是一个在页面上用户操作比较频繁的功能，而点赞数这个字段是存储在美食教程表里的，用户每点击一次按钮就要修改这个字段会产生很大的数据库开销，所以不考虑直接操作MySQL数据库，转而采用Redis进行存储。后面可采用Quartz框架进行定时的数据同步操作。采用Redis存储就面临着该选择那一种数据结构来存储每一个教程的点赞数据。根据上面提到的场景可以做出分析
JAVA项目点赞功能如何实现?如何利用缓存优化？如何防止刷赞?
最新发布
weixin_73077810的博客
10-09 2284
本文对业务中的点赞功能做出详细的思路整理，搭配着缓存优化和防刷策略讲解，提高对于该类业务的理解
java 登录 次数_Java用Cookie限制点赞次数(简版)
weixin_36039452的博客
02-21 207
本文简单利用Cookie技术来简单的限制点赞次数，并不能杜绝游客的恶意点赞。好了，不啰嗦了，先来看看基础知识：ajax+springMVC+cookie中间框架你随意，楼主这里用了springMVC，只要取得HttpServletRequest和HttpServletResponse你就可以操作cookie啦什么是Cookiecookie 是存储于访问者的计算机中的变量。每当同一台计算机通过浏览器...
全网最全的Java SpringBoot点赞功能实现
「 虚幻私塾」
01-22 2398
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 前言 最近公司在做一个NFT商城的项目，大致就是一个只买卖数字产品的平台，项目中有个需求是用户可以给商品点赞，还需要获取商品的点赞总数，类似下图 起初感觉这功能很好实现，无非就是加个点赞表嘛，后来发现事情并没有这么简单。 一开始的设计是这样的，一共有三张表：商品表、用户表、点
点赞模块设计 - Redis缓存 + 定时写入数据库实现高性能点赞功能
m0_74931226的博客
12-14 727
点赞功能在很多系统中都有，但别看功能小，想要做好需要考虑的东西还挺多的。 点赞、取消点赞是高频次的操作，若每次都读写数据库，大量的操作会影响数据库性能，所以需要做缓存。 至于多久从 Redis 取一次数据存到数据库中，根据项目的实际情况定吧，我是暂时设了两个小时。 项目需求需要查看都谁点赞了，所以要存储每个点赞的点赞人、被点赞人，不能简单的做计数。
Spring Boot+MyBatis+Redis+ActiveMQ+MySQL+Thymeleaf实现简单的高并发点赞功能
weixin_43395911的博客
02-29 2106
Spring Boot+MyBatis+Redis+ActiveMQ+MySQL+Thymeleaf实现简单的高并发点赞功能 1.项目概述 在社交网站或App中，点赞场景非常多，比如微信、微博、QQ空间、博客、抖音等软件都有点赞功能。别小看一个简单的点赞功能，里面要考虑的细节还是很多的。比如一些名人发的微博，由于其粉丝众多，一条微博可能在短时间内有上百万的点赞数。面对这种高并发点赞场景，如果项目没...
mysql实现点赞和取消_Redis是如何实现点赞、取消点赞的？
weixin_33914777的博客
02-02 431
本文转载自【微信公众号：java进阶架构师，ID:java_jiagoushi】经微信公众号授权转载，如需转载与原文作者联系redis相关文章：分布式系统关注点——先写DB还是「缓存」？付磊：一份完整的阿里云 Redis 开发规范，值得收藏！一个牛逼的多级缓存实现方案基于redis分布式锁实现“秒杀”(含代码)百亿数据量下，掌握这些Redis技巧你就能Hold全场9个提升逼格的redis命令get...
（仿牛客社区项目）Java开发笔记4.2：实现点赞功能
weixin_45700663的博客
07-22 2360
（仿牛客社区项目）Java开发笔记4.2：实现点赞功能
如何高效的使用java实现类似抖音的评论点赞列表（互动消息）以及点赞的基本操作
weixin_59441154的博客
06-21 3027
一个java的点赞功能以及联表查询点赞和被点赞列表的实现
点赞功能实现
07-24
点赞之后替换图片，显示加一
基于java进行点赞功能的实现
qq_55983332的博客
04-19 1914
1.首先进行建表，大部分点赞都是文章，帖子，或者商品的点赞，然后登录用户进行点赞，创建表的话需要文章，帖子，或者商品的id和用户的id，我这里是文章postId和userId2.接下来就是代码层面的实现controller层（PostThumbAddRequest中放的是文章id） service层 serviceImpl层（用户串行点赞必须加锁） doPostThumbInner是对数据库进行操作的，实现如下 封装了事务的方法，出现错误立即回滚。大概逻辑就是首先判断首先是否已经进行过点赞
Java使用Springboot+Redis实现点赞功能
ChristineTX的博客
09-28 7340
1. 流程图 流程图 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zec3qocj-1632797596589)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210928102514830.png)] 实现思路 由于点赞属于一种频繁的提交操作，如果直接选用数据库做存储，对于数据库的压力比较大。这里考虑使用缓存作为中间层，然后定时的将数据持久化数据库，降低数据库的读写压力。缓
SpringBoot实现物品点赞功能后端代码
weixin_51297617的博客
10-05 702
SpringBoot实现物品点赞功能 效果： 功能： 首先还是一个先发请求返回数据，但是先数据存到了redis中，然后使用springboot定时任务每隔一定时间将数据存到mysql中。这样可以防止redis挂掉之后数据丢失。 数据库设计： MySQL使用了一张表和另外几张表的一个字段，一张存放点赞信息，就是谁点赞了谁在啥时候。字段存放点赞数量。就是物品信息表。评论表这些。 redis，使用的是hash数据结构，redis_liked存放点赞数据，redis_liked_count存放点赞数量数据。 解
基于SpringCloud分布式微服务+微信小程序实现短视频社交app设计+sql数据库(毕设源码).zip
06-15
基础能力强的可以在此基础上修改调整，以实现类似其他功能。 基于SpringCloud分布式微服务+微信小程序实现短视频社交app设计 开发软件： Idea + 微信web开发者工具 + mysql5.6 + redis 1 微信小程序端 (1)用户...
点赞功能java_jquery实现点赞功能
weixin_39861054的博客
02-28 325
点赞已经流行多年，点赞功能很多地方都会出现，如何实现爱心点赞功能，这篇文章主要为大家详细介绍了jquery点赞功能实现代码，欢迎大家点赞。要实现的点赞功能比较简单，就是实现点击按钮，有心向上飘，一直飘出屏幕外。首先只需要在body中定义一个button。和盛放心的盒子由于还要引进心的图片，所以在这里我们在设置css样式的时候还要设置图片img的样式。css代码如下：*{margin: 0px;pa...
一个简单的点赞功能的实现
weixin_45600855的博客
03-01 2609
点赞功能的实现使用的技术前端HTMLajax、jquery后端java、servletMySql 使用的技术 前端：html、ajax、jquery 后端：java、servlet、MySql 前端 HTML <%@ page contentType="text/html;charset=UTF-8" language="java" %> <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> <htm
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值