SpringBoot+Redis实现分布式WebSocket

什么是分布式WebSocket？

是指在分布式系统架构中实现WebSocket的通讯机制，它答应在不同的服务器节点之间共享和同步WebSocket会话状态，从而实现跨多个服务器的实时消息通报。

在分布式环境中实现WebSocket的挑衅主要包罗以下几点：

• 会话共享：在分布式系统中，用户的WebSocket毗连大概与不同的服务器创建，这就要求系统可以或许在不同服务器间共享WebSocket会话信息，以便消息可以或许被正确地通报到所有相关的客户端。
  
• 负载平衡：使用负载平衡可以进步系统的可用性和伸缩性。但是，当WebSocket哀求在服务器之间负载平衡时，需要确保客户端可以与正确的服务器创建毗连，而且可以或许接收到所有的消息。
  
• 故障转移：在出现服务器故障时，系统需要可以或许将WebSocket会话无缝迁移到其他健康的服务器上，以保证服务的一连性。
  
• 一致性：确保所有用户在任何时候看到的都是一致的消息状态，这对于实时通讯非常紧张。
  

为了办理这些挑衅，可以采取以下几种策略：

• 使用消息署理：通过引入一个中央化的消息署理（如RabbitMQ、Redis Pub/Sub等），可以让所有的服务器都毗连到这个消息署理。当一个服务器需要发送消息时，它将消息发送到消息署理，然后由消息署理负责将消息分发到所有毗连的客户端。如许可以确保消息的一致性和可靠性。
  
• 共享会话存储：使用一个共享的会话存储（如数据库或内存数据网格）来保存WebSocket会话的状态。如许，即使客户端最初毗连到的服务器发生故障，其他服务器也可以接管会话并继承处理消息。
  
• 基于路由的负载平衡：使用智能负载平衡器（如Nginx、HAProxy等），它们可以根据特定的路由规则（如会话ID或用户ID）将WebSocket毗连定向到特定的服务器。
  
• 服务发现：在微服务架构中，可以使用服务发现机制来动态地找到负责特定会话的服务器，并将消息路由到那里。
  
• WebSocket署理：使用专门的WebSocket署理服务器，它可以在多个后端服务器之间署理WebSocket毗连，并确保消息的通报和会话的同步。
  
• 应用层协议：计划应用层协议来处理分布式WebSocket的复杂性，比方通过引入心跳机制来检测毗连的健康状态，并通过预定的协议来同步会话状态。
  

总的来说，在实践中，大概需要结合多种策略来构建一个健壮的分布式WebSocket办理方案，以满足不同场景下的需求。别的，还需要思量安全性、性能和可扩展性等因素，以确保系统的稳定性和可靠性。


温故而知新：单点WebSocket实现

SpringBoot2.0集成WebSocket，实现后台向前端推送信息_springboot集成websocket-CSDN博客

https://zhengkai.blog.csdn.net/article/details/80275084
简单版本：在Java中使用Redis实现WebSocket

要在Java中使用Redis实现WebSocket，你需要使用一个支持WebSocket的Java Web框架，如Spring Boot，以及一个支持Redis的Java库，如Jedis。以下是一个简单的示例：

添加依赖项到你的pom.xml文件

1. <dependencies>
2.     <dependency>
3.         <groupId>org.springframework.boot</groupId>
4.         <artifactId>spring-boot-starter-websocket</artifactId>
5.     </dependency>
6.     <dependency>
7.         <groupId>org.springframework.boot</groupId>
8.         <artifactId>spring-boot-starter-data-redis</artifactId>
9.     </dependency>
10. </dependencies>

复制代码

创建一个WebSocket设置类

1. import org.springframework.context.annotation.Bean;
2. import org.springframework.context.annotation.Configuration;
3. import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
4. import org.springframework.data.redis.core.RedisTemplate;
5. import org.springframework.data.redis.listener.ChannelTopic;
6. import org.springframework.data.redis.listener.RedisMessageListenerContainer;
7. import org.springframework.data.redis.listener.adapter.MessageListenerAdapter;
8. import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
9. import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
10. import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;
11. //by zhengkai.blog.csdn.net
12. @Configuration
13. @EnableWebSocketMessageBroker
14. public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
16.     @Override
17.     public void registerStompEndpoints(StompEndpointRegistry registry) {
18.         registry.addEndpoint("/websocket").withSockJS();
19.     }
21.     @Override
22.     public void configureMessageBroker(org.springframework.messaging.simp.config.MessageBrokerRegistry registry) {
23.         registry.enableSimpleBroker("/topic");
24.         registry.setApplicationDestinationPrefixes("/app");
25.     }
27.     @Bean
28.     public JedisConnectionFactory jedisConnectionFactory() {
29.         return new JedisConnectionFactory();
30.     }
32.     @Bean
33.     public RedisTemplate<String, Object> redisTemplate() {
34.         RedisTemplate<String, Object> template = new RedisTemplate<>();
35.         template.setConnectionFactory(jedisConnectionFactory());
36.         return template;
37.     }
39.     @Bean
40.     public MessageListenerAdapter messageListenerAdapter() {
41.         return new MessageListenerAdapter(new RedisMessageListener());
42.     }
44.     @Bean
45.     public RedisMessageListenerContainer redisMessageListenerContainer() {
46.         RedisMessageListenerContainer container = new RedisMessageListenerContainer();
47.         container.setConnectionFactory(jedisConnectionFactory());
48.         container.addMessageListener(messageListenerAdapter(), topic());
49.         return container;
50.     }
52.     @Bean
53.     public ChannelTopic topic() {
54.         return new ChannelTopic("websocket-topic");
55.     }
56. }

复制代码

创建一个WebSocket消息监听器

1. import org.springframework.data.redis.connection.Message;
2. import org.springframework.data.redis.connection.MessageListener;
3. import org.springframework.stereotype.Component;
5. @Component
6. public class RedisMessageListener implements MessageListener {
8.     @Override
9.     public void onMessage(Message message, byte[] pattern) {
10.         System.out.println("Received message: " + message);
11.     }
12. }

复制代码

发送消息到WebSocket客户端

在你的控制器中，你可以使用SimpMessagingTemplate来发送消息到WebSocket客户端：

1. import org.springframework.beans.factory.annotation.Autowired;
2. import org.springframework.messaging.simp.SimpMessagingTemplate;
3. import org.springframework.web.bind.annotation.GetMapping;
4. import org.springframework.web.bind.annotation.RestController;
6. @RestController
7. public class WebSocketController {
9.     @Autowired
10.     private SimpMessagingTemplate messagingTemplate;
12.     @GetMapping("/send")
13.     public String sendMessage() {
14.         messagingTemplate.convertAndSend("/topic/websocket-topic", "Hello from Redis!");
15.         return "Message sent!";
16.     }
17. }

复制代码

正式版本：用SpringBoot+Redis实现分布式WebSocket

 

• 将消息（<用户id，消息内容>）统一推送到一个消息队列（Redis、Kafka等）的的topic，然后每个应用节点都订阅这个topic，在接收到WebSocket消息后取出这个消息的“消息接收者的用户ID/用户名”，然后再比对自身是否存在相应用户的毗连，如果存在则推送消息，否则扬弃接收到的这个消息（这个消息接收者所在的应用节点会处理）
  
• 在用户创建WebSocket毗连后，使用Redis缓存记任命户的WebSocket创建在哪个应用节点上，然后同样使用消息队列将消息推送到接收者所在的应用节点上面（实现上比方案一要复杂，但是网络流量会更低）
  

 
 1. 界说一个WebSocket Channel枚举类

1. public enum WebSocketChannelEnum {
2.     //测试使用的简易点对点聊天
3.     CHAT("CHAT", "测试使用的简易点对点聊天", "/topic/reply");
5.     WebSocketChannelEnum(String code, String description, String subscribeUrl) {
6.         this.code = code;
7.         this.description = description;
8.         this.subscribeUrl = subscribeUrl;
9.     }
11.     /**
12.      * 唯一CODE
13.      */
14.     private String code;
15.     /**
16.      * 描述
17.      */
18.     private String description;
19.     /**
20.      * WebSocket客户端订阅的URL
21.      */
22.     private String subscribeUrl;
24.     public String getCode() {
25.         return code;
26.     }
28.     public String getDescription() {
29.         return description;
30.     }
32.     public String getSubscribeUrl() {
33.         return subscribeUrl;
34.     }
36.     /**
37.      * 通过CODE查找枚举类
38.      */
39.     public static WebSocketChannelEnum fromCode(String code){
40.         if(StringUtils.isNoneBlank(code)){
41.             for(WebSocketChannelEnum channelEnum : values()){
42.                 if(channelEnum.code.equals(code)){
43.                     return channelEnum;
44.                 }
45.             }
46.         }
48.         return null;
49.     }
51. }

复制代码

2. 设置基于Redis的消息队列

需要注意的是，在大中型正式项目中并不保举使用Redis实现的消息队列，由于颠末测试它并不是特别可靠，以是应该思量使用Kafka、rabbitMQ等专业的消息队列中央件

1. @Configuration
2. @ConditionalOnClass({JedisCluster.class})
3. public class RedisConfig {
5.     @Value("${spring.redis.timeout}")
6.     private String timeOut;
8.     @Value("${spring.redis.cluster.nodes}")
9.     private String nodes;
11.     @Value("${spring.redis.cluster.max-redirects}")
12.     private int maxRedirects;
14.     @Value("${spring.redis.jedis.pool.max-active}")
15.     private int maxActive;
17.     @Value("${spring.redis.jedis.pool.max-wait}")
18.     private int maxWait;
20.     @Value("${spring.redis.jedis.pool.max-idle}")
21.     private int maxIdle;
23.     @Value("${spring.redis.jedis.pool.min-idle}")
24.     private int minIdle;
26.     @Value("${spring.redis.message.topic-name}")
27.     private String topicName;
29.     @Bean
30.     public JedisPoolConfig jedisPoolConfig(){
31.         JedisPoolConfig config = new JedisPoolConfig();
32.         config.setMaxTotal(maxActive);
33.         config.setMaxIdle(maxIdle);
34.         config.setMinIdle(minIdle);
35.         config.setMaxWaitMillis(maxWait);
37.         return config;
38.     }
40.     @Bean
41.     public RedisClusterConfiguration redisClusterConfiguration(){
42.         RedisClusterConfiguration configuration = new RedisClusterConfiguration(Arrays.asList(nodes));
43.         configuration.setMaxRedirects(maxRedirects);
45.         return configuration;
46.     }
48.     /**
49.      * JedisConnectionFactory
50.      */
51.     @Bean
52.     public JedisConnectionFactory jedisConnectionFactory(RedisClusterConfiguration configuration,JedisPoolConfig jedisPoolConfig){
53.         return new JedisConnectionFactory(configuration,jedisPoolConfig);
54.     }
56.     /**
57.      * 使用Jackson序列化对象
58.      */
59.     @Bean
60.     public Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer(){
61.         Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
63.         ObjectMapper objectMapper = new ObjectMapper();
64.         objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
65.         objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
66.         serializer.setObjectMapper(objectMapper);
68.         return serializer;
69.     }
71.     /**
72.      * RedisTemplate
73.      */
74.     @Bean
75.     public RedisTemplate<String, Object> redisTemplate(JedisConnectionFactory factory, Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer){
76.         RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
77.         redisTemplate.setConnectionFactory(factory);
79.         //字符串方式序列化KEY
80.         StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
81.         redisTemplate.setKeySerializer(stringRedisSerializer);
82.         redisTemplate.setHashKeySerializer(stringRedisSerializer);
84.         //JSON方式序列化VALUE
85.         redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
86.         redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
88.         redisTemplate.afterPropertiesSet();
90.         return redisTemplate;
91.     }
93.     /**
94.      * 消息监听器
95.      */
96.     @Bean
97.     MessageListenerAdapter messageListenerAdapter(MessageReceiver messageReceiver, Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer){
98.         //消息接收者以及对应的默认处理方法
99.         MessageListenerAdapter messageListenerAdapter = new MessageListenerAdapter(messageReceiver, "receiveMessage");
100.         //消息的反序列化方式
101.         messageListenerAdapter.setSerializer(jackson2JsonRedisSerializer);
103.         return messageListenerAdapter;
104.     }
106.     /**
107.      * message listener container
108.      */
109.     @Bean
110.     RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory
111.             , MessageListenerAdapter messageListenerAdapter){
112.         RedisMessageListenerContainer container = new RedisMessageListenerContainer();
113.         container.setConnectionFactory(connectionFactory);
114.         //添加消息监听器
115.         container.addMessageListener(messageListenerAdapter, new PatternTopic(topicName));
117.         return container;
118.     }
120. }

复制代码

这里使用的设置：

1. spring:
2.   ...
3.   #redis
4.   redis:
5.       cluster:
6.         nodes: namenode22:6379,datanode23:6379,datanode24:6379
7.         max-redirects: 6
8.       timeout: 300000
9.       jedis:
10.         pool:
11.           max-active: 8
12.           max-wait: 100000
13.           max-idle: 8
14.           min-idle: 0
15.       #自定义的监听的TOPIC路径
16.       message:
17.         topic-name: topic-test

复制代码

3. 界说一个Redis消息的处理者

1. @Component
2. public class MessageReceiver {
3.     private final Logger logger = LoggerFactory.getLogger(getClass());
5.     @Autowired
6.     private SimpMessagingTemplate messagingTemplate;
8.     @Autowired
9.     private SimpUserRegistry userRegistry;
11.     /**
12.      * 处理WebSocket消息
13.      */
14.     public void receiveMessage(RedisWebsocketMsg redisWebsocketMsg) {
15.         logger.info(MessageFormat.format("Received Message: {0}", redisWebsocketMsg));
16.         //1. 取出用户名并判断是否连接到当前应用节点的WebSocket
17.         SimpUser simpUser = userRegistry.getUser(redisWebsocketMsg.getReceiver());
19.         if(simpUser != null && StringUtils.isNoneBlank(simpUser.getName())){
20.             //2. 获取WebSocket客户端的订阅地址
21.             WebSocketChannelEnum channelEnum = WebSocketChannelEnum.fromCode(redisWebsocketMsg.getChannelCode());
23.             if(channelEnum != null){
24.                 //3. 给WebSocket客户端发送消息
25.                 messagingTemplate.convertAndSendToUser(redisWebsocketMsg.getReceiver(), channelEnum.getSubscribeUrl(), redisWebsocketMsg.getContent());
26.             }
27.         }
29.     }
30. }

复制代码

4. 在Controller中发送WebSocket消息

1. @Controller
2. @RequestMapping(("/wsTemplate"))
3. public class RedisMessageController {
4.     private final Logger logger = LoggerFactory.getLogger(getClass());
6.     @Value("${spring.redis.message.topic-name}")
7.     private String topicName;
9.     @Autowired
10.     private SimpMessagingTemplate messagingTemplate;
12.     @Autowired
13.     private SimpUserRegistry userRegistry;
15.     @Resource(name = "redisServiceImpl")
16.     private RedisService redisService;
18.     /**
19.      * 给指定用户发送WebSocket消息
20.      */
21.     @PostMapping("/sendToUser")
22.     @ResponseBody
23.     public String chat(HttpServletRequest request) {
24.         //消息接收者
25.         String receiver = request.getParameter("receiver");
26.         //消息内容
27.         String msg = request.getParameter("msg");
28.         HttpSession session = SpringContextUtils.getSession();
29.         User loginUser = (User) session.getAttribute(Constants.SESSION_USER);
31.         HelloMessage resultData = new HelloMessage(MessageFormat.format("{0} say: {1}", loginUser.getUsername(), msg));
32.         this.sendToUser(loginUser.getUsername(), receiver, WebSocketChannelEnum.CHAT.getSubscribeUrl(), JsonUtils.toJson(resultData));
34.         return "ok";
35.     }
37.     /**
38.      * 给指定用户发送消息，并处理接收者不在线的情况
39.      * @param sender 消息发送者
40.      * @param receiver 消息接收者
41.      * @param destination 目的地
42.      * @param payload 消息正文
43.      */
44.     private void sendToUser(String sender, String receiver, String destination, String payload){
45.         SimpUser simpUser = userRegistry.getUser(receiver);
47.         //如果接收者存在，则发送消息
48.         if(simpUser != null && StringUtils.isNoneBlank(simpUser.getName())){
49.             messagingTemplate.convertAndSendToUser(receiver, destination, payload);
50.         }
51.         //如果接收者在线，则说明接收者连接了集群的其他节点，需要通知接收者连接的那个节点发送消息
52.         else if(redisService.isSetMember(Constants.REDIS_WEBSOCKET_USER_SET, receiver)){
53.             RedisWebsocketMsg<String> redisWebsocketMsg = new RedisWebsocketMsg<>(receiver, WebSocketChannelEnum.CHAT.getCode(), payload);
55.             redisService.convertAndSend(topicName, redisWebsocketMsg);
56.         }
57.         //否则将消息存储到redis，等用户上线后主动拉取未读消息
58.         else{
59.             //存储消息的Redis列表名
60.             String listKey = Constants.REDIS_UNREAD_MSG_PREFIX + receiver + ":" + destination;
61.             logger.info(MessageFormat.format("消息接收者{0}还未建立WebSocket连接，{1}发送的消息【{2}】将被存储到Redis的【{3}】列表中", receiver, sender, payload, listKey));
63.             //存储消息到Redis中
64.             redisService.addToListRight(listKey, ExpireEnum.UNREAD_MSG, payload);
65.         }
67.     }
70.     /**
71.      * 拉取指定监听路径的未读的WebSocket消息
72.      * @param destination 指定监听路径
73.      * @return java.util.Map<java.lang.String,java.lang.Object>
74.      */
75.     @PostMapping("/pullUnreadMessage")
76.     @ResponseBody
77.     public Map<String, Object> pullUnreadMessage(String destination){
78.         Map<String, Object> result = new HashMap<>();
79.         try {
80.             HttpSession session = SpringContextUtils.getSession();
81.             //当前登录用户
82.             User loginUser = (User) session.getAttribute(Constants.SESSION_USER);
84.             //存储消息的Redis列表名
85.             String listKey = Constants.REDIS_UNREAD_MSG_PREFIX + loginUser.getUsername() + ":" + destination;
86.             //从Redis中拉取所有未读消息
87.             List<Object> messageList = redisService.rangeList(listKey, 0, -1);
89.             result.put("code", "200");
90.             if(messageList !=null && messageList.size() > 0){
91.                 //删除Redis中的这个未读消息列表
92.                 redisService.delete(listKey);
93.                 //将数据添加到返回集，供前台页面展示
94.                 result.put("result", messageList);
95.             }
96.         }catch (Exception e){
97.             result.put("code", "500");
98.             result.put("msg", e.getMessage());
99.         }
101.         return result;
102.     }
104. }

复制代码

5. WebSocket相关设置

1. @Configuration
2. @EnableWebSocketMessageBroker
3. public class WebSocketConfig implements WebSocketMessageBrokerConfigurer{
4.     @Autowired
5.     private AuthHandshakeInterceptor authHandshakeInterceptor;
7.     @Autowired
8.     private MyHandshakeHandler myHandshakeHandler;
10.     @Autowired
11.     private MyChannelInterceptor myChannelInterceptor;
13.     @Override
14.     public void registerStompEndpoints(StompEndpointRegistry registry) {
15.         registry.addEndpoint("/chat-websocket")
16.                 .addInterceptors(authHandshakeInterceptor)
17.                 .setHandshakeHandler(myHandshakeHandler)
18.                 .withSockJS();
19.     }
21.     @Override
22.     public void configureMessageBroker(MessageBrokerRegistry registry) {
23.         //客户端需要把消息发送到/message/xxx地址
24.         registry.setApplicationDestinationPrefixes("/message");
25.         //服务端广播消息的路径前缀，客户端需要相应订阅/topic/yyy这个地址的消息
26.         registry.enableSimpleBroker("/topic");
27.         //给指定用户发送消息的路径前缀，默认值是/user/
28.         registry.setUserDestinationPrefix("/user/");
29.     }
31.     @Override
32.     public void configureClientInboundChannel(ChannelRegistration registration) {
33.         registration.interceptors(myChannelInterceptor);
34.     }
36. }

复制代码

6. 示例页面

1. <head>
2.     <meta content="text/html;charset=UTF-8"/>
3.     <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
4.     <meta http-equiv="X-UA-Compatible" content="IE=edge"/>
5.     <meta name="viewport" content="width=device-width, initial-scale=1"/>
6.     <title>Chat With STOMP Message</title>
7.     <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
8.     <script src="https://cdnjs.cloudflare.com/ajax/libs/sockjs-client/1.1.4/sockjs.min.js"></script>
9.     <script src="https://cdnjs.cloudflare.com/ajax/libs/stomp.js/2.3.3/stomp.min.js"></script>
10.     <script th:src="@{/layui/layui.js}"></script>
11.     <script th:src="@{/layui/lay/modules/layer.js}"></script>
12.     <link th:href="@{/layui/css/layui.css}" rel="stylesheet">
13.     <link th:href="@{/layui/css/modules/layer/default/layer.css}" rel="stylesheet">
14.     <link th:href="@{/css/style.css}" rel="stylesheet">
15.     <style type="text/css">
16.         #connect-container {
17.             margin: 0 auto;
18.             width: 400px;
19.         }
21.         #connect-container div {
22.             padding: 5px;
23.             margin: 0 7px 10px 0;
24.         }
26.         .message input {
27.             padding: 5px;
28.             margin: 0 7px 10px 0;
29.         }
31.         .layui-btn {
32.             display: inline-block;
33.         }
34.     </style>
35.     <script type="text/javascript">
36.         var stompClient = null;
38.         $(function () {
39.             var target = $("#target");
40.             if (window.location.protocol === 'http:') {
41.                 target.val('http://' + window.location.host + target.val());
42.             } else {
43.                 target.val('https://' + window.location.host + target.val());
44.             }
45.         });
47.         function setConnected(connected) {
48.             var connect = $("#connect");
49.             var disconnect = $("#disconnect");
50.             var echo = $("#echo");
52.             if (connected) {
53.                 connect.addClass("layui-btn-disabled");
54.                 disconnect.removeClass("layui-btn-disabled");
55.                 echo.removeClass("layui-btn-disabled");
56.             } else {
57.                 connect.removeClass("layui-btn-disabled");
58.                 disconnect.addClass("layui-btn-disabled");
59.                 echo.addClass("layui-btn-disabled");
60.             }
62.             connect.attr("disabled", connected);
63.             disconnect.attr("disabled", !connected);
64.             echo.attr("disabled", !connected);
65.         }
67.         //连接
68.         function connect() {
69.             var target = $("#target").val();
71.             var ws = new SockJS(target);
72.             stompClient = Stomp.over(ws);
74.             stompClient.connect({}, function () {
75.                 setConnected(true);
76.                 log('Info: STOMP connection opened.');
78.                 //连接成功后，主动拉取未读消息
79.                 pullUnreadMessage("/topic/reply");
81.                 //订阅服务端的/topic/reply地址
82.                 stompClient.subscribe("/user/topic/reply", function (response) {
83.                     log(JSON.parse(response.body).content);
84.                 })
85.             },function () {
86.                 //断开处理
87.                 setConnected(false);
88.                 log('Info: STOMP connection closed.');
89.             });
90.         }
92.         //断开连接
93.         function disconnect() {
94.             if (stompClient != null) {
95.                 stompClient.disconnect();
96.                 stompClient = null;
97.             }
98.             setConnected(false);
99.             log('Info: STOMP connection closed.');
100.         }
102.         //向指定用户发送消息
103.         function sendMessage() {
104.             if (stompClient != null) {
105.                 var receiver = $("#receiver").val();
106.                 var msg = $("#message").val();
107.                 log('Sent: ' + JSON.stringify({'receiver': receiver, 'msg':msg}));
109.                 $.ajax({
110.                     url: "/wsTemplate/sendToUser",
111.                     type: "POST",
112.                     dataType: "json",
113.                     async: true,
114.                     data: {
115.                         "receiver": receiver,
116.                         "msg": msg
117.                     },
118.                     success: function (data) {
120.                     }
121.                 });
122.             } else {
123.                 layer.msg('STOMP connection not established, please connect.', {
124.                     offset: 'auto'
125.                     ,icon: 2
126.                 });
127.             }
128.         }
130.         //从服务器拉取未读消息
131.         function pullUnreadMessage(destination) {
132.             $.ajax({
133.                 url: "/wsTemplate/pullUnreadMessage",
134.                 type: "POST",
135.                 dataType: "json",
136.                 async: true,
137.                 data: {
138.                     "destination": destination
139.                 },
140.                 success: function (data) {
141.                     if (data.result != null) {
142.                         $.each(data.result, function (i, item) {
143.                             log(JSON.parse(item).content);
144.                         })
145.                     } else if (data.code !=null && data.code == "500") {
146.                         layer.msg(data.msg, {
147.                             offset: 'auto'
148.                             ,icon: 2
149.                         });
150.                     }
151.                 }
152.             });
153.         }
155.         //日志输出
156.         function log(message) {
157.             console.debug(message);
158.         }
159.     </script>
160. </head>
161. <body>
162.     <noscript><h2 style="color: #ff0000">Seems your browser doesn't support Javascript! Websockets rely on Javascript being
163.         enabled. Please enable
164.         Javascript and reload this page!</h2></noscript>
165.     <div>
166.         <div id="connect-container" class="layui-elem-field">
167.             <legend>Chat With STOMP Message</legend>
168.             <div>
169.                 <input id="target" type="text" class="layui-input" size="40" style="width: 350px" value="/chat-websocket"/>
170.             </div>
171.             <div>
172.                 <button id="connect" class="layui-btn layui-btn-normal" onclick="connect();">Connect</button>
173.                 <button id="disconnect" class="layui-btn layui-btn-normal layui-btn-disabled" disabled="disabled"
174.                         onclick="disconnect();">Disconnect
175.                 </button>
177.             </div>
178.             <div class="message">
179.                 <input id="receiver" type="text" class="layui-input" size="40" style="width: 350px" placeholder="接收者姓名" value=""/>
180.                 <input id="message" type="text" class="layui-input" size="40" style="width: 350px" placeholder="消息内容" value=""/>
181.             </div>
182.             <div>
183.                 <button id="echo" class="layui-btn layui-btn-normal layui-btn-disabled" disabled="disabled"
184.                         onclick="sendMessage();">Send Message
185.                 </button>
186.             </div>
187.         </div>
188.     </div>
189. </body>
190. </html>

复制代码

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