spring boot + websocket+redis 实现集群消息推送

已于 2022-08-19 16:51:09 修改
阅读量1.9k 收藏 10
点赞数 1
分类专栏： BUG库 文章标签： redis websocket spring boot
于 2022-08-19 16:41:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zombie_p/article/details/126418043
版权

SpringBoot WebSocket Redis集群 消息推送 Nginx配置
关键词由CSDN通过智能技术生成

spring boot + websocket

遇到的问题

  1. 当使用redis做集群部署的时候，由于spring boot 版本与redis 版本不匹配，redis设置了username，而依赖没有相关的设置，所以只能升级依赖
  2. websocket做集群部署时，前端做消息推送，没办法正确推送，所有使用redis 的发布订阅功能来实现
  3. 前端连接websocket一直连接失败，通过nginx转发之后，后端找不到相关接口，则需要在nginx配置websocke的做转发

添加后端依赖

Spring boot 版本：2.3.4
spring boot redis 版本：2.4.1 （因为redis版本较高，所以需要升级redis依赖到2.4.1，否则用户名验证失败）
如需配置集群则添加以下三个依赖
jedis 版本：2.9.0
lettuce-core 版本：6.1.0
reactor-core 版本：3.3.16
spring boot websocket 版本：2.3.4

集成websocket

  1. 添加websocket配置
import org.springframework.context.annotation.Bean;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;
import org.springframework.context.annotation.Configuration;

@Configuration
public class WebSocketConfig
{
    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }
}
  1. 加添websocket的连接入口
import org.slf4j.LoggerFactory;
import java.io.IOException;
import javax.websocket.OnError;
import javax.websocket.OnMessage;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.JSON;
import org.apache.commons.lang3.StringUtils;
import javax.websocket.OnClose;
import javax.websocket.OnOpen;
import org.springframework.data.redis.listener.Topic;
import org.springframework.data.redis.connection.MessageListener;
import org.springframework.data.redis.listener.ChannelTopic;
import javax.websocket.server.PathParam;
import com.dgri.gmp.hr.config.SubscribeListener;
import com.dgri.gmp.hr.utils.RedisUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import javax.websocket.Session;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
import org.slf4j.Logger;
import javax.websocket.server.ServerEndpoint;
import org.springframework.stereotype.Component;

@Component
@ServerEndpoint("/websocket/pushMessage/{userId}")
public class WebSocketServer
{
    private static Logger log;
    private final String TOPIC_PREFIX = "websocket_topic_";
    private static AtomicInteger onlineCount;
    private static ConcurrentHashMap<String, WebSocketServer> webSocketMap;
    private Session session;
    private String userId;
    @Autowired
    private RedisMessageListenerContainer redisMessageListenerContainer;
    @Autowired
    private RedisUtil redisUtil;
    private SubscribeListener subscribeListener;
    
    public WebSocketServer() {
        this.userId = "";
    }
    
    @OnOpen
    public void onOpen(final Session session, @PathParam("userId") final String userId) {
        this.session = session;
        this.userId = userId;
        if (WebSocketServer.webSocketMap.containsKey(userId)) {
            WebSocketServer.webSocketMap.remove(userId);
            WebSocketServer.webSocketMap.put(userId, this);
        }
        else {
            WebSocketServer.webSocketMap.put(userId, this);
            this.addOnlineCount();
        }
        WebSocketServer.log.info("用户连接:" + userId + ",当前在线人数为:" + this.getOnlineCount());
        (this.subscribeListener = new SubscribeListener()).setSession(session);
        this.redisMessageListenerContainer.addMessageListener((MessageListener)this.subscribeListener, (Topic)new ChannelTopic("websocket_topic_" + userId));
    }
    
    @OnClose
    public void onClose() {
        if (WebSocketServer.webSocketMap.containsKey(this.userId)) {
            WebSocketServer.webSocketMap.remove(this.userId);
            this.subOnlineCount();
        }
        this.redisMessageListenerContainer.removeMessageListener((MessageListener)this.subscribeListener);
        WebSocketServer.log.info("用户退出:" + this.userId + ",当前在线人数为:" + this.getOnlineCount());
    }
    
    @OnMessage
    public void onMessage(final String message, final Session session) {
        WebSocketServer.log.info("用户消息:" + this.userId + ",报文:" + message);
        if (StringUtils.isNotBlank((CharSequence)message)) {
            try {
                final JSONObject jsonObject = JSON.parseObject(message);
                jsonObject.put("fromUserId", (Object)this.userId);
                final String toUserId = jsonObject.getString("toUserId");
                if (StringUtils.isNotBlank((CharSequence)toUserId) && WebSocketServer.webSocketMap.containsKey(toUserId)) {
                    WebSocketServer.webSocketMap.get(toUserId).sendMessage(message);
                }
                else {
                    this.redisUtil.publish("websocket_topic_" + toUserId, message);
                    WebSocketServer.log.error("请求的userId:" + toUserId + "不在该服务器上");
                }
            }
            catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    @OnError
    public void onError(final Session session, final Throwable error) {
        WebSocketServer.log.error("用户错误:" + this.userId + ",原因:" + error.getMessage());
        error.printStackTrace();
    }
    
    public void sendMessage(final String message) {
        try {
            this.session.getBasicRemote().sendText(message);
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    public static void sendInfo(final String message, final String userId) {
        WebSocketServer.log.info("发送消息到:" + userId + "，报文:" + message);
        if (StringUtils.isNotBlank((CharSequence)userId) && WebSocketServer.webSocketMap.containsKey(userId)) {
            WebSocketServer.webSocketMap.get(userId).sendMessage(message);
        }
        else {
            WebSocketServer.log.error("用户" + userId + ",不在线！");
        }
    }
    
    public int getOnlineCount() {
        return WebSocketServer.onlineCount.get();
    }
    
    public void addOnlineCount() {
        WebSocketServer.onlineCount.getAndIncrement();
    }
    
    public void subOnlineCount() {
        WebSocketServer.onlineCount.getAndDecrement();
    }
    
    static {
        WebSocketServer.log = LoggerFactory.getLogger((Class)WebSocketServer.class);
        WebSocketServer.onlineCount = new AtomicInteger(0);
        WebSocketServer.webSocketMap = new ConcurrentHashMap<String, WebSocketServer>();
    }
}

集成redis集群

1.配置application.yml

#==========================redis配置信息===========================
spring: 
  redis: 
    username: redis_user #用户名
    password: 11111111 #密码
    cluster: 
      timeout: 60000
      nodes: 127.0.0.1:5001,127.0.0.1:5001,127.0.0.1:5001,127.0.0.1:5001
      max-redirects: 3  # 获取失败最大重定向次数
    lettuce:
      pool:
        max-active: 50  #连接池最大连接数
        max-idle: 20 # 连接池最大空闲连接
        min-idle: 5 # 连接池最小空闲连接
  1. 添加redis集群配置文件
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.core.env.MapPropertySource;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.listener.PatternTopic;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.data.redis.listener.adapter.MessageListenerAdapter;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.data.redis.support.collections.RedisProperties;

import com.dgri.gmp.hr.websocket.TestRedisMsgReceiver;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;

/**
 * @description： redis监听配置类
 */
@Configuration
public class RedisConfig {
    private final Environment environment;
    
    public RedisConfig(Environment environment) {
        this.environment = environment;
    }
 
    @Bean
    @ConditionalOnMissingBean(RedisConnectionFactory.class)
    public RedisConnectionFactory RedisConnectionFactory() {
        Map<String, Object> source = new HashMap<String, Object>();
        source.put("spring.redis.cluster.nodes", environment.getProperty("spring.redis.cluster.nodes"));
        source.put("spring.redis.cluster.timeout", environment.getProperty("spring.redis.cluster.timeout"));
        source.put("spring.redis.cluster.max-redirects", environment.getProperty("spring.redis.cluster.max-redirects"));
        MapPropertySource mapPropertySource = new MapPropertySource("RedisClusterConfiguration", source);
        RedisClusterConfiguration  redisClusterConfiguration = new RedisClusterConfiguration(mapPropertySource);
 
        //获取application.yml 中的密码（密文）
        String password = environment.getProperty("spring.redis.password");
        
        String username = environment.getProperty("spring.redis.username");
        //解密密码并停驾到配置中
        redisClusterConfiguration.setUsername(username);
        redisClusterConfiguration.setPassword(RedisPassword.of(password));
        return new LettuceConnectionFactory(redisClusterConfiguration);
    }
 
 
    @Bean("StringRedisTemplate")
    public StringRedisTemplate createStringRedisTemplate( RedisConnectionFactory factory){
        StringRedisTemplate stringRedisTemplate = new StringRedisTemplate(factory);
        stringRedisTemplate.setKeySerializer(new StringRedisSerializer());
        stringRedisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        return stringRedisTemplate;
    }
    

    @Bean
    public RedisTemplate<String, Object> redisTemplate( RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        //设置value hashValue值的序列化
        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<Object>(
                Object.class);
        ObjectMapper om = new ObjectMapper();
//        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        serializer.setObjectMapper(om);
        redisTemplate.setValueSerializer(serializer);
        redisTemplate.setHashValueSerializer(serializer);
        //key hasKey的序列化
        redisTemplate.setKeySerializer(stringRedisSerializer);
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }


    /**
     * description: 手动注册Redis监听到IOC
     *
     * @param redisConnectionFactory
     * @return: org.springframework.data.redis.listener.RedisMessageListenerContainer
     */
    @Bean
    public RedisMessageListenerContainer redisMessageListenerContainer( RedisConnectionFactory redisConnectionFactory,
    		@Qualifier("listenerAdapter") MessageListenerAdapter listenerAdapter) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(redisConnectionFactory);
        //----test
        container.addMessageListener(listenerAdapter, new PatternTopic("TOPIC_TEST"));
        return container;
    }
    
    @Bean(name = "listenerAdapter")
    MessageListenerAdapter listenerAdapter(TestRedisMsgReceiver receiver) {
        System.out.println("消息适配器---test");
        return new MessageListenerAdapter(receiver, "onMessage");
    }
  1. 添加redis 监听文件
import java.io.IOException;
import java.nio.charset.StandardCharsets;

import javax.websocket.Session;

import org.springframework.data.redis.connection.Message;
import org.springframework.data.redis.connection.MessageListener;

import com.dgri.gmp.hr.websocket.WebSocketServer;

import cn.hutool.core.util.ObjectUtil;

/**
 * @description： redis监听
 */
public class SubscribeListener implements MessageListener {

    /**
     * 当前websocket的session
     */
    private Session session;

    public Session getSession() {
        return session;
    }

    public void setSession(Session session) {
        this.session = session;
    }

    @Override
    public void onMessage(Message message, byte[] bytes) {
    	System.out.println("=====================监听到redis消息===================="+message);
        String msg = new String(message.getBody(),StandardCharsets.UTF_8).trim();
//        replaceAll("\"", "");
        if (ObjectUtil.isNotEmpty(session) && session.isOpen()) {
            try {
                session.getBasicRemote().sendText(msg);
            } catch (IOException e) {
            	System.out.printf("发送消息异常，msg = {} , e = {}", msg, e);
            }
        }
    }
}
  1. 添加redis 发布
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

@Component
public class RedisUtil
{
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    
    
    public void publish(final String key, final String value) {
       this.stringRedisTemplate.convertAndSend(key, (Object)value);
    }
}
  1. 如果使用nginx 进行转发的话 需要添加一下配置，才能正常连接上wensocket
location /你的代理地址  {        
        proxy_pass http://你的IP地址:端口号/websocket/pushMessage;
        proxy_connect_timeout 4s; 
        proxy_read_timeout 7200s; 
        proxy_send_timeout 12s; 
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }

前端websocket

1.websocket公共js

不想写了
Zombie@
关注
专栏目录
Springboot+websocket+Stomp使用Redis实现分布式消息推送
左岸天涯--博客
10-24 2512
引言 由于新需求，需要实现多语言下实现websocket消息通讯推送，本来打算引入高级消息队列协议的，但体量没那么大，所以选型时选择了通过redis的队列来实现。 实现步骤 pom引入 <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <optional&
netty+springBoot+webSocket+redis实现各个客户端之间通信、及时聊天等功能
qq_30765051的博客
10-02 5918
本项目用到的技术 1、netty框架，为什么要使用netty框架呢？netty框架是基于Nio的，那和传统的Bio有什么区别呢？ Bio BIO 有的称之为 basic(基本) IO,有的称之为 block(阻塞) IO，主要应用于文件 IO 和网络 IO， 这里不再说文件 IO， 在 JDK1.4 之前，我们建立网络连接的时候只能采用 BIO，需要先在服务端启动一个 ServerSocket，然...
springboot+websocket+redis实现聊天室
08-05
springboot+websocket+redis实现聊天室功能，可以实现私聊和群聊(并支持发送图片)
【实战】SpringBoot整合Websocket、Redis实现Websocket集群负载均衡
勤于笔记，成于点滴。
05-18 2673
因为有websocket的存在，使得前后的主动交互变得容易和低成本。其实在JAVA领域用SpringBoot框架集成Websoket还是很简单的，今天我们重点不是集成而是通过Redis的发布订阅实现Websocket集群通信，当然有条件的也可以用MQ代替。
Spring Boot 中实现 WebSocket 服务并让客户端实时接收消息
最新发布
m0_74825409的博客
09-29 1547
在 Spring Boot 中实现 WebSocket 服务并让客户端实时接收消息，可以使用 Spring Boot 内置的 WebSocket 支持。下面我为你提供一个基于 Spring Boot 和 WebSocket 的完整 Demo。
springboot+websocket+redis
凉白开不加冰
06-10 8111
介绍：通过websocket+redis做一个简单的客服聊天系统 流程图： 说明： 客服管理人员登录后台，点击客服界面的时候，创建websocket客户端，等待接受用户消息 用户从页面点击客服服务的时候，创建websocket客户端，这时候将消息发送给客服 客服接收到用户消息，回复消息给用户 用户发送消息以及客服回复消息都通过API接口调用，然后转发给对应的websocket客户端 第一步：...
SpringBoot+WebSocket+Redis整合
weixin_41849935的博客
09-27 1313
经过在网上看前辈的帖子终于经过精心的粘贴复制和查找错误整理出了 目录 DemoController类 package com.Config; import java.io.IOException; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.
Websocket只看这一篇就够了 SpringBoot+Websocket+Redis 实现websocket集群
无知无畏的博客
08-27 3785
关于websocket做一次全面的总结。 实现的难点在什么地方？ WebSocketSession 是不能放在redis中共享的。所以共享Session的方法是不可行的。 WebSocket是长链接所以只能通过保持连接的服务器通知对应的客户端。一旦需要发送消息的服务器和保持连接的服务器不是同一台服务器时就有问题了。 实现WebSocket集群的2种方式 用redis的订阅/推送功能实现的。（推荐） 用redis存客户端连接对应的服务器的IP+端口，再用http去调用对应服务器的接口。 用redi.
Spring Boot系列21 Spring Websocket实现websocket集群方案讨论
热门推荐
不积跬步无以至千里; 不积小流无以成江海
07-26 2万+
概述 本文对websocket集群的方案进行讨论： 实现websocket集群。 通过webscoket实现前端实时接收服务推送的信息的功能; 将指定的消息推送到指定的用户 webscoket集群方案 集群方案分析 在上个博文Spring Boot系列20 Spring Websocket实现向指定的用户发送消息中实现向指定用户发送消息的功能，但是我们将提供websock...
stomp+websocket 集群问题_「多人聊天室」WebSocket集群/分布式改造
weixin_35042833的博客
01-21 386
文章来源：https://dwz.cn/jPGInM6l作者：蛮三刀把刀书接上文，我们开始对我们的小小聊天室进行集群化改造。本文内容摘要：为何要改造为分布式集群如何改造为分布式集群用户在聊天室集群如何发消息用户在聊天室集群如何接收消息补充知识点：STOMP 简介功能一：向聊天室集群中的全体用户发消息——Redis的订阅/发布功能二：集群集群用户上下线通知——Redis订阅发布功能三：集群用户信息维...
Springboot 整合 WebSocket ，使用STOMP协议+Redis 解决负载场景问题
m0_64867293的博客
12-05 475
import com.fasterxml.jackson.annotation.JsonAutoDetect; import com.fasterxml.jackson.annotation.PropertyAccessor; import com.fasterxml.jackson.databind.ObjectMapper; import com.stomp.stomptest.listener.RedisListener; import org.springframework.cache.annota
springboot+netty+websocket+redis
03-08
springboot+netty+websocket+redis 分布式聊天，实现简单的聊天功能
SpringBoot+nacos+websocket+redis+mysql+mybatis-plus微服务项目实战
01-11
SpringBoot+nacos+websocket+redis+mysql+oracle+swagger2+mybatis-plus
java开发基于SpringBoot+WebSocket+Redis分布式即时通讯群聊系统.zip
06-24
Java开发基于SpringBoot+WebSocket+Redis分布式即时通讯群聊系统。一个基于Spring Boot + WebSocket + Redis，可快速开发的分布式即时通讯群聊系统。适用于直播间聊天、游戏内聊天、客服聊天等临时性群聊场景。 Java开发基于SpringBoot+WebSocket+Redis分布式即时通讯群聊系统。一个基于Spring Boot + WebSocket + Redis，可快速开发的分布式即时通讯群聊系统。适用于直播间聊天、游戏内聊天、客服聊天等临时性群聊场景。Java开发基于SpringBoot+WebSocket+Redis分布式即时通讯群聊系统。一个基于Spring Boot + WebSocket + Redis，可快速开发的分布式即时通讯群聊系统。适用于直播间聊天、游戏内聊天、客服聊天等临时性群聊场景。Java开发基于SpringBoot+WebSocket+Redis分布式即时通讯群聊系统。一个基于Spring Boot + WebSocket + Redis，可快速开发的分布式即时通讯群聊系统。适用于直播间聊天、游戏内聊天
SpringBoot+Redis实现分布式WebSocket
★【World Of Moshow 郑锴】★
03-19 3991
在分布式系统架构中实现WebSocket的通信机制，它允许在不同的服务器节点之间共享和同步WebSocket会话状态，从而实现跨多个服务器的实时消息传递。会话共享：在分布式系统中，用户的WebSocket连接可能与不同的服务器建立，这就要求系统能够在不同服务器间共享WebSocket会话信息，以便消息能够被正确地传递到所有相关的客户端。负载均衡：使用负载均衡可以提高系统的可用性和伸缩性。
springboot+websocket+redis 实现websocket集群订阅
m0_37695902的博客
02-15 1214
在某些业务场景，我们需要页面对于后台的操作进行实时的刷新，这时候就需要使用websocket。 通常在后台单机的情况下没有任何的问题，如果后台经过nginx等进行负载的话，则会导致前台不能准备的接收到后台给与的响应。socket属于长连接，其session只会保存在一台服务器上，其他负载及其不会持有这个session，这时需要给保存某个客户端session信息的用户发送消息就发送不到，此时，我们需要使用redis的发布订阅来实现，session的共享。 所有用户向redis订阅，redis通过广播的形式发送
SpringBoot+WebSocket+Redis 实现消息推送
chenxue843400447的博客
01-15 5276
环境： SpringBoot 2.0.0.3 + JDK 1.8 + IDEA + Redis(spring-boot-starter-data-redis) + Nginx1.14 坑点： 程序以war包运行。websocket配置问题 服务器开启了Nginx代理，导致websocket 404 websocket短时间 自动关闭。 redis消息发布/订阅模式发...
【SpringBoot整合Redis+WebSoket】
Small ink的博客
12-26 1592
socket属于长连接，其session只会保存在一台服务器上，其他负载及其不会持有这个session，此时，我们需要使用redis的发布订阅来实现，session的共享。因为现在很多项目都是前后分离的，所以前端走后端基本都是通过Nginx或公共网关来统一转发请求，WebSoket使用的是长连接默认的Nginx是不支持长连接的所以需要配置，请参考。sendMessage：发生消息的方法（自己封装的，并不限制，按要求扩展），因为我们使用的是redis的发布订阅方式所以我们使用的是Redis的订阅来发送消息。
爬山的蜗牛旅程：十一、springboot +websocket+redis 实现分布式在线聊天
m0_37781593的博客
09-26 1021
学习springboot的旅程，就像蜗牛爬山，一点点的往上爬，一点点的欣赏旅途的风景 小猿公司的系统又要升级了，现在要实现在线聊天。这个怎么搞呢？ 特别是在分布式系统下，怎么搞分布式在线聊天呢？ 第一点：客户端与服务端通过websocket技术创建连接（这样服务端才能向客户端推送数据） 第二点：服务端之间的通信，请看redis的订阅和发布 第三点：创建聊天测试页面 springboot 实...
Spring Boot+Websocket即时通讯实战指南
资源摘要信息:"Spring boot整合websocket实现即时通讯" 知识点一：Spring Boot框架 Spring Boot是一个开源的Java基础框架，主要用于简化Spring应用的初始搭建以及开发过程。它使用特定的方式来配置Spring，以便于...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值