【实战】SpringBoot整合Websocket、Redis实现Websocket集群负载均衡 ...

金歌  论坛元老 | 2024-8-29 01:28:24 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 1056|帖子 1056|积分 3168

前言

信赖很多同学都用过websocket来实现服务端主动向客户端推送消息吧，基本上全部的管理类系统都会有这个功能。由于有websocket的存在，使得前后的主动交互变得容易和低本钱。其实在JAVA领域用SpringBoot框架集成Websoket照旧很简单的，本日我们重点不是集成而是通过Redis的发布订阅实现Websocket集群通讯，当然有条件的也可以用MQ代替。
技术积累

什么是Websocket

WebSocket是一种在单个TCP连接上举行全双工通讯的协议。WebSocket通讯协议于2011年被IETF定为标准RFC 6455，并由RFC7936增补规范。WebSocket API也被W3C定为标准。
WebSocket使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在WebSocket API中，浏览器和服务器只必要完成一次握手，两者之间就直接可以创建持久性的连接，并举行双向数据传输。

什么是Redis发布订阅

Redis 的发布订阅（Pub/Sub）是一种消息通讯模式：发送者（pub）发送消息，订阅者（sub）接收消息。Redis 客户端可以订阅恣意数目的频道。当有新消息通过 PUBLISH 下令发送给频道时，这个消息会被发送给订阅它的全部客户端。

Redis发布订阅与消息队列的区别

Redis的发布订阅（Pub/Sub）和消息队列是两种不同的消息通报模式，它们的紧张区别在于消息的处理方式和使用场景。
消息的处理方式：
在 Redis 的发布订阅模式中，消息是即时的，也就是说，当消息发布后，只有当前在线且订阅了该频道的客户端才能收到这个消息，消息不会被存储，一旦发布，当前没有在线的客户端将无法接收到这个消息。
在消息队列中，消息是持久化的，消息被发送到队列后，会一直在队列中等候被消费，即使没有在线的消费者，消息也不会丢失，消费者下次上线后可以继承从队列中获取到消息。
实战演示

本次演示采用demo情势，仅仅提供演示Websocket集群的实现方式，以及解决消息负载均衡的问题。演示案例重点偏后端实现Websoket集群通讯，不涉及前后端心跳检测，如果应用在生产环境前端必要增加心跳检测与重复创建。
本实战采用原生spring websocket，后续有时间再提供netty版本，以及产线版本。有条件的同学可以自己实现，原理都差不多。
SpringBoot整合Websoket

1、项目结构

2、springcloud 版本
  1. <parent>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-parent</artifactId>
  4.     <version>2.3.12.RELEASE</version>
  5.     <relativePath/> <!-- lookup parent from repository -->
  6. </parent>
  7. <properties>
  8.     <java.version>8</java.version>
  9.     <spring-cloud.version>Hoxton.SR12</spring-cloud.version>
  10. </properties>
  11. <dependencyManagement>
  12.     <dependencies>
  13.         <dependency>
  14.             <groupId>org.springframework.cloud</groupId>
  15.             <artifactId>spring-cloud-dependencies</artifactId>
  16.             <version>${spring-cloud.version}</version>
  17.             <type>pom</type>
  18.             <scope>import</scope>
  19.         </dependency>
  20.     </dependencies>
  21. </dependencyManagement>
复制代码
3、maven依赖
  1. <dependency>
  2.     <groupId>com.alibaba</groupId>
  3.     <artifactId>fastjson</artifactId>
  4.     <version>1.2.68</version>
  5. </dependency>
  7. <dependency>
  8.     <groupId>org.springframework.boot</groupId>
  9.     <artifactId>spring-boot-starter-websocket</artifactId>
  10. </dependency>
  12. <!-- 整合thymeleaf前端页面 -->
  13. <dependency>
  14.     <groupId>org.springframework.boot</groupId>
  15.     <artifactId>spring-boot-starter-thymeleaf</artifactId>
  16. </dependency>
复制代码
4、设置文件
  1. server:
  2.   port: 8888
  3. spring:
  4.   profiles:
  5.     active: dev
  6.   mvc:
  7.     pathmatch:
  8.       # Springfox使用的路径匹配是基于AntPathMatcher的，而Spring Boot 2.6.X使用的是PathPatternMatcher
  9.       matching-strategy: ant_path_matcher
  10.   thymeleaf:
  11.     mode: HTML
  12.     encoding: UTF-8
  13.     content-type: text/html
  14.     cache: false
  15.     prefix: classpath:/templates/
复制代码
5、thymeleaf 页面
websocket.html
  1. <!DOCTYPE html>
  2. <html>
  3. <head>
  4.     <meta charset="utf-8">
  5.     <title>websocket通讯</title>
  6. </head>
  7. <script src="https://cdn.bootcss.com/jquery/3.3.1/jquery.js"></script>
  8. <script>
  9.     var socket;
  10.     function openSocket() {
  11.         if (typeof (WebSocket) == "undefined") {
  12.             console.log("您的浏览器不支持WebSocket");
  13.         } else {
  14.             console.log("您的浏览器支持WebSocket");
  15.             //实现化WebSocket对象，指定要连接的服务器地址与端口  建立连接
  16.             //等同于socket = new WebSocket("ws://localhost:8888/xxxx/im/25");
  17.             //var socketUrl="${request.contextPath}/im/"+$("#userId").val();
  18.             var socketUrl = "ws://192.168.1.4:7777/ws/" + $("#userId").val();
  19.             socketUrl = socketUrl.replace("https", "ws").replace("http", "ws");
  20.             console.log(socketUrl);
  21.             if (socket != null) {
  22.                 socket.close();
  23.                 socket = null;
  24.             }
  25.             socket = new WebSocket(socketUrl);
  26.             //打开事件
  27.             socket.onopen = function () {
  28.                 console.log("websocket已打开");
  29.                 //socket.send("这是来自客户端的消息" + location.href + new Date());
  30.             };
  31.             //获得消息事件
  32.             socket.onmessage = function (msg) {
  33.                 console.log("接收消息为："+msg.data);
  34.             };
  35.             //关闭事件
  36.             socket.onclose = function () {
  37.                 console.log("websocket已关闭");
  38.             };
  39.             //发生了错误事件
  40.             socket.onerror = function () {
  41.                 console.log("websocket发生了错误");
  42.             }
  43.         }
  44.     }
  46.     //心跳检测与重复验证自己实现
  48.     function sendMessage() {
  49.         if (typeof (WebSocket) == "undefined") {
  50.             console.log("您的浏览器不支持WebSocket");
  51.         } else {
  52.             console.log("您的浏览器支持WebSocket");
  53.             console.log('发送消息为：{"fromUserId":"' + $("#userId").val() + '","toUserId":"' + $("#toUserId").val() + '","contentText":"' + $("#contentText").val() + '"}');
  54.             socket.send('{"fromUserId":"' + $("#userId").val() + '","toUserId":"' + $("#toUserId").val() + '","contentText":"' + $("#contentText").val() + '"}');
  55.         }
  56.     }
  58. </script>
  59. <body>
  60. <p>【userId】：<div><input id="userId" name="userId" type="text" value="10"></div>
  61. <p>【toUserId】：<div><input id="toUserId" name="toUserId" type="text" value="20"></div>
  62. <p>【内容】：<div><input id="contentText" name="contentText" type="text" value="hello websocket"></div>
  63. <p>【操作】：<div><button onclick="openSocket()">开启socket</button></div>
  64. <p>【操作】：<div><button onclick="sendMessage()">发送消息</button></div>
  65. </body>
  66. </html>
复制代码
6、消息实体
Message.java
  1. import lombok.Data;
  3. /**
  4. * Message
  5. * @author senfel
  6. * @version 1.0
  7. * @date 2024/5/17 14:39
  8. */
  9. @Data
  10. public class Message {
  11.     /**
  12.      * 消息编码
  13.      */
  14.     private String code;
  16.     /**
  17.      * 来自（保证唯一）
  18.      */
  19.     private String fromUserId;
  21.     /**
  22.      * 去自（保证唯一）
  23.      */
  24.     private String toUserId;
  26.     /**
  27.      * 内容
  28.      */
  29.     private String contentText;
  31. }
复制代码
7、Websocket设置类
WebSocketConfig.java
  1. import org.springframework.context.annotation.Bean;
  2. import org.springframework.stereotype.Component;
  3. import org.springframework.web.socket.server.standard.ServerEndpointExporter;
  4. /**
  5. * WebSocketConfig
  6. * @author senfel
  7. * @version 1.0
  8. * @date 2024/5/16 16:51
  9. */
  10. @Component
  11. public class WebSocketConfig {
  12.     @Bean
  13.     public ServerEndpointExporter serverEndpointExporter() {
  14.         System.out.println("启动websocket支持");
  15.         return new ServerEndpointExporter();
  16.     }
  17. }
  20. Websocket 服务类
  21. WebSocketServer.java
  22. import com.example.ccedemo.config.SpringUtil;
  23. import org.apache.commons.lang3.StringUtils;
  24. import org.slf4j.Logger;
  25. import org.slf4j.LoggerFactory;
  26. import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
  27. import org.springframework.data.redis.core.StringRedisTemplate;
  28. import org.springframework.stereotype.Component;
  29. import javax.websocket.*;
  30. import javax.websocket.server.PathParam;
  31. import javax.websocket.server.ServerEndpoint;
  32. import java.util.concurrent.ConcurrentHashMap;
  33. import java.util.concurrent.CopyOnWriteArraySet;
  35. /**
  36. * WebSocketServer
  37. * @author senfel
  38. * @version 1.0
  39. * @date 2024/5/16 16:59
  40. */
  41. @ConditionalOnClass(value = WebSocketConfig.class)
  42. @Component
  43. @ServerEndpoint("/ws/{deviceId}")
  44. public class WebSocketServer {
  46.     protected Logger logger = LoggerFactory.getLogger(this.getClass());
  48.     /**与某个客户端的连接会话，需要通过它来给客户端发送数据*/
  49.     private Session session;
  50.     /**
  51.      * 设备ID
  52.      */
  53.     private String deviceId;
  54.     /**concurrent包的线程安全Set，用来存放每个客户端对应的MyWebSocket对象。
  55.     虽然@Component默认是单例模式的，但springboot还是会为每个websocket连接初始化一个bean，所以可以用一个静态set保存起来。
  56.     注：底下WebSocket是当前类名*/
  57.     private static CopyOnWriteArraySet<WebSocketServer> webSockets =new CopyOnWriteArraySet<>();
  58.     /**用来存在线连接用户信息*/
  59.     private static ConcurrentHashMap<String,Session> sessionPool = new ConcurrentHashMap<String,Session>();
  61.     /**
  62.      * 链接成功调用的方法
  63.      */
  64.     @OnOpen
  65.     public void onOpen(Session session, @PathParam(value="deviceId")String deviceId) {
  66.         try {
  67.             if(StringUtils.isEmpty(deviceId)||deviceId.equals("undefined")){
  68.                 return;
  69.             }
  70.             this.session = session;
  71.             this.deviceId = deviceId;
  72.             webSockets.add(this);
  73.             sessionPool.put(deviceId, session);
  74.             logger.info("【websocket消息】有新的连接，总数为:"+webSockets.size());
  75.             StringBuffer stringBuffer = new StringBuffer();
  76.             sessionPool.forEach((key, value) -> {
  77.                 stringBuffer.append(key).append(";");
  78.             });
  79.             logger.info("当前服务器连接有客户端有:"+stringBuffer.toString());
  80.         } catch (Exception e) {
  81.         }
  82.     }
  84.     /**
  85.      * 链接关闭调用的方法
  86.      */
  87.     @OnClose
  88.     public void onClose() {
  89.         try {
  90.             webSockets.remove(this);
  91.             sessionPool.remove(this.deviceId);
  92.             logger.info("【websocket消息】连接断开，总数为:"+webSockets.size());
  93.             StringBuffer stringBuffer = new StringBuffer();
  94.             sessionPool.forEach((key, value) -> {
  95.                 stringBuffer.append(key).append(";");
  96.             });
  97.             logger.info("当前服务器连接有客户端有:"+stringBuffer.toString());
  98.         } catch (Exception e) {
  99.         }
  100.     }
  101.     /**
  102.      * 收到客户端消息后调用的方法
  103.      * @param message
  104.      */
  105.     @OnMessage
  106.     public void onMessage(String message) {
  107.         logger.info("【websocket消息】收到客户端消息:"+message);
  108.         SpringUtil.getBean(StringRedisTemplate.class).convertAndSend("webSocketMsgPush",message);
  109.     }
  111.     /** 发送错误时的处理
  112.      * @param session
  113.      * @param error
  114.      */
  115.     @OnError
  116.     public void onError(Session session, Throwable error) {
  117.         logger.error("用户错误,原因:"+error.getMessage());
  118.         error.printStackTrace();
  119.     }
  123.     /**
  124.      * 广播消息
  125.      * @author senfel
  126.      * @date 2024/5/17 17:10
  127.      * @return void
  128.      */
  129.     public void sendAllMessage(String message) {
  130.         logger.info("【websocket消息】广播消息:"+message);
  131.         for(WebSocketServer webSocket : webSockets) {
  132.             try {
  133.                 if(webSocket.session.isOpen()) {
  134.                     webSocket.session.getAsyncRemote().sendText(message);
  135.                 }
  136.             } catch (Exception e) {
  137.                 e.printStackTrace();
  138.             }
  139.         }
  140.     }
  143.     /**
  144.      * 单点消息 单人
  145.      * @param deviceId
  146.      * @param message
  147.      * @author senfel
  148.      * @date 2024/5/17 17:10
  149.      * @return void
  150.      */
  151.     public void sendOneMessage(String deviceId, String message) {
  152.         Session session = sessionPool.get(deviceId);
  153.         if (session != null&&session.isOpen()) {
  154.             try {
  155.                 logger.info("【websocket消息】 单点消息:"+message);
  156.                 session.getAsyncRemote().sendText(message);
  157.             } catch (Exception e) {
  158.                 e.printStackTrace();
  159.             }
  160.         }
  161.     }
  163.     /**
  164.      * 单点消息
  165.      * @param deviceId
  166.      * @param object
  167.      * @author senfel
  168.      * @date 2024/5/17 17:10
  169.      * @return void
  170.      */
  171.     public void sendOneObject(String deviceId, Object object) {
  172.         Session session = sessionPool.get(deviceId);
  173.         if (session != null&&session.isOpen()) {
  174.             try {
  175.                 logger.info("【websocket消息】 单点消息(对象):"+object);
  176.                 session.getAsyncRemote().sendObject(object);
  177.             } catch (Exception e) {
  178.                 e.printStackTrace();
  179.             }
  180.         }
  181.     }
  183.     /**
  184.      * 单点消息(多人)
  185.      * @param deviceIds
  186.      * @param message
  187.      * @author senfel
  188.      * @date 2024/5/17 17:11
  189.      * @return void
  190.      */
  191.     public void sendMoreMessage(String[] deviceIds, String message) {
  192.         for(String deviceId:deviceIds) {
  193.             Session session = sessionPool.get(deviceId);
  194.             if (session != null&&session.isOpen()) {
  195.                 try {
  196.                     logger.info("【websocket消息】 单点消息:"+message);
  197.                     session.getAsyncRemote().sendText(message);
  198.                 } catch (Exception e) {
  199.                     e.printStackTrace();
  200.                 }
  201.             }
  202.         }
  203.     }
  205. }
复制代码
8、controller提供接口
  1. import org.springframework.web.bind.annotation.GetMapping;
  2. import org.springframework.web.bind.annotation.RequestMapping;
  3. import org.springframework.web.bind.annotation.RestController;
  4. import org.springframework.web.servlet.ModelAndView;
  6. /**
  7. * TestController
  8. * @author senfel
  9. * @version 1.0
  10. * @date 2024/5/17 17:49
  11. */
  12. @RestController
  13. @RequestMapping("/api/websocket")
  14. public class BaseController {
  16.     @GetMapping("page")
  17.     public ModelAndView page(Long userId){
  18.         ModelAndView websocket = new ModelAndView("websocket");
  19.         websocket.addObject("userId",userId);
  20.         return websocket;
  21.     }
  22. }
复制代码
Websoket集群负载均衡

大家都知道Websoket是一个长链接，在不断开的情况下服务端与客户端是可以自由通讯的，这是由于服务端缓存了会话。
如果我们后端采用集群部署，那么可能多个用户的缓存会话会分散在各个服务器上。在我们给指定用户推送消息时就有可能调用服务器上并没有这个用户的会话。
以是，我们引入Redis发布订阅，将消息举行转发到全部的服务端，只有有会话缓存的服务端才会乐成推送消息。讲到这里就比力明显了吧，完美解决Websoket负载均衡的问题。
1、maven引入Redis
  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-data-redis</artifactId>
  4. </dependency>
复制代码
2、设置文件
  1. spring:
  2.   redis:
  3.     host: 127.0.0.1
  4.     port: 6379
复制代码
3、Redis设置类
RedisConfig.java
  1. import com.fasterxml.jackson.annotation.JsonAutoDetect;
  2. import com.fasterxml.jackson.annotation.PropertyAccessor;
  3. import com.fasterxml.jackson.databind.ObjectMapper;
  4. import org.springframework.cache.annotation.CachingConfigurerSupport;
  5. import org.springframework.cache.annotation.EnableCaching;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.context.annotation.Configuration;
  8. import org.springframework.context.annotation.Primary;
  9. import org.springframework.data.redis.connection.RedisConnectionFactory;
  10. import org.springframework.data.redis.core.RedisTemplate;
  11. import org.springframework.data.redis.listener.PatternTopic;
  12. import org.springframework.data.redis.listener.RedisMessageListenerContainer;
  13. import org.springframework.data.redis.listener.adapter.MessageListenerAdapter;
  14. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
  15. import org.springframework.data.redis.serializer.StringRedisSerializer;
  17. /**
  18. * RedisConfig
  19. * @author senfel
  20. * @version 1.0
  21. * @date 2024/5/17 14:31
  22. */
  23. @Configuration
  24. @EnableCaching
  25. public class RedisConfig extends CachingConfigurerSupport {
  27.     @Bean
  28.     @Primary
  29.     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
  31.         RedisTemplate<String, Object> template = new RedisTemplate<>();
  32.         template.setConnectionFactory(factory);
  34.         Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);
  35.         StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
  36.         ObjectMapper om = new ObjectMapper();
  37.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  38.         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  39.         jacksonSeial.setObjectMapper(om);
  40.         template.setValueSerializer(jacksonSeial);
  41.         template.setKeySerializer(stringRedisSerializer);
  42.         template.setHashKeySerializer(stringRedisSerializer);
  43.         template.setHashValueSerializer(jacksonSeial);
  44.         template.afterPropertiesSet();
  45.         return template;
  46.     }
  48.     @Bean
  49.     RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory,
  50.                                             MessageListenerAdapter topicAdapter) {
  51.         RedisMessageListenerContainer container = new RedisMessageListenerContainer();
  52.         container.setConnectionFactory(connectionFactory);
  53.         //订阅了主题 webSocketMsgPush
  54.         container.addMessageListener(topicAdapter, new PatternTopic("webSocketMsgPush"));
  55.         return container;
  56.     }
  57.     /**
  58.      * 消息监听器适配器，绑定消息处理器
  59.      *
  60.      * @return
  61.      */
  62.     @Bean
  63.     MessageListenerAdapter topicAdapter() {
  64.         return new MessageListenerAdapter(new RedisListener());
  65.     }
  66. }
复制代码
4、Redis订阅监听
RedisListener.java
  1. import com.alibaba.fastjson.JSONObject;
  2. import com.example.ccedemo.config.SpringUtil;
  3. import org.springframework.data.redis.connection.Message;
  4. import org.springframework.data.redis.connection.MessageListener;
  6. /**
  7. * RedisListener
  8. * @author senfel
  9. * @version 1.0
  10. * @date 2024/5/17 14:37
  11. */
  12. public class RedisListener implements MessageListener {
  14.     @Override
  15.     public void onMessage(Message msg, byte[] bytes) {
  16.         System.out.println(".监听到需要进行负载转发的消息：" + msg.toString());
  17.         com.example.ccedemo.redissocket.Message message = JSONObject.parseObject(msg.toString(), com.example.ccedemo.redissocket.Message.class);
  18.         SpringUtil.getBean(WebSocketServer.class).sendOneMessage(message.getToUserId(), message.getContentText());
  19.     }
  20. }
复制代码
实战测试

我们本地启动两个服务，分别开启端口8888、9999，然后用nginx袒露7777端口做一个负载均衡。
IDEA启动两台服务端



设置nginx负载均衡

  1. #服务器url变量定义
  2. upstream api_service1 {
  3.     server 192.168.1.4:8888;
  4.         server 192.168.1.4:9999;
  5. }
  9. #nginx配置websocket
  10. map $http_upgrade $connection_upgrade {
  11.     default upgrade;
  12.     '' close;
  13. }
  14. server {
  15.     listen  7777;
  16.         large_client_header_buffers 4 16k;
  17.         client_max_body_size 300m;
  18.         client_body_buffer_size 128k;
  19.         proxy_connect_timeout 600;
  20.         proxy_read_timeout 600;
  21.         proxy_send_timeout 600;
  22.         proxy_buffer_size 64k;
  23.         proxy_buffers   4 32k;
  24.         proxy_busy_buffers_size 64k;
  25.         proxy_temp_file_write_size 64k;
  26.         proxy_http_version 1.1;
  27.                
  28.     root  /demo/page/dist;
  29.     index  index.html;
  30.    
  31.    
  32.     #api
  33.     location /api/ {
  34.         proxy_pass  http://api_service1/api/;
  35.         proxy_set_header Host $http_host;
  36.     }
  37.    
  38.   
  40.     #nginx配置websocket
  41.     location /ws/ {
  42.         proxy_http_version 1.1;
  43.         proxy_pass  http://api_service1/ws/;
  44.         proxy_redirect off;
  45.         proxy_set_header Host $host;  
  46.         proxy_set_header X-Real-IP $remote_addr;
  47.         proxy_read_timeout 3600s;
  48.         proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
  49.         proxy_set_header Upgrade $http_upgrade;
  50.         proxy_set_header Connection $connection_upgrade;
  51.     }
  52.    
  54.     #解决页面刷新404
  55.     location / {
  56.         try_files $uri $uri/ @req;
  57.         index index.html;
  58.     }
  60.     location @req {
  61.         rewrite ^.*$ /index.html last;
  62.     }
  63. }
复制代码
浏览器访问模拟对话

1、浏览器开启多个无痕界面
http://192.168.1.4:7777/api/websocket/page
模拟对话：
多个界面的用户ID互补

2、分别开启soket,由于nginx轮询策略会分别注册在两个服务端上

3、客户端相互发送消息验证

由以上图片可知，我们两个客户端相互对话能够接收到对方推送的消息。那么，由此也可以证明我们后端Websocke集群使用Redis发布订阅的方式搭建乐成。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

金歌

论坛元老
这个人很懒什么都没写!

楼主热帖

标签云

AI 运维 CIO 存储 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表