springmvc(18)使用WebSocket 和 STOMP 实现消息功能

【0】README

1）本文旨在介绍如何利用 WebSocket 和 STOMP 实现消息功能；

2）要知道， WebSocket 是发送和接收消息的底层API，而SockJS 是在 WebSocket 之上的 API；最后 STOMP（面向消息的简单文本协议）是基于 SockJS 的高级API

（干货——简而言之，WebSocket 是底层协议，SockJS 是WebSocket 的备选方案，也是底层协议，而 STOMP 是基于 WebSocket（SockJS）的上层协议）

3）broker==经纪人，代理；

4）当然，你可以直接跳转到 STOMP 知识（章节【3】）；

【1】WebSocket

1）intro：WebSocket 协议提供了通过一个套接字实现全双工通信的功能。也能够实现 web 浏览器和 server 间的异步通信，全双工意味着 server 与浏览器间可以发送和接收消息。

【1.1】使用 spring 的低层级 WebSocket API

1）intro：为了在 spring 中使用较低层级的 API 来处理消息。有如下方案：

scheme1）我们必须编写一个实现 WebSocketHandler:

[java] view plain copy

public interface WebSocketHandler {

void afterConnectionEstablished(WebSocketSession session) throws Exception;

void handleMessage(WebSocketSession session, WebSocketMessage<?> message) throws Exception;

void handleTransportError(WebSocketSession session,

Throwable exception) throws Exception;

void afterConnectionClosed(WebSocketSession session,

CloseStatus closeStatus) throws Exception;

boolean supportsPartialMessages();

}

scheme2）当然，我们也可以扩展 AbstractWebSocketHandler（更加简单一点）；

[java] view plain copy

// you can also extends TextWebSocketHandler

public class ChatTextHandler extends AbstractWebSocketHandler {



// handle text msg.

@Override

protected void handleTextMessage(WebSocketSession session,

   TextMessage message) throws Exception {

  session.sendMessage(new TextMessage("hello world."));

}

}

对以上代码的分析（Analysis）：当然了，我们还可以重载其他三个方法：

[java] view plain copy

handleBinaryMessage()

handlePongMessage()

handleTextMessage()

scheme3）也可以扩展 TextWebSocketHandler（文本 WebSocket 处理器），不在扩展AbstractWebSocketHandler ， TextWebSocketHandler 继承 AbstractWebSocketHandler ；

2）你可能会关系建立和关闭连接感兴趣。可以重载 afterConnectionEstablished() and afterConnectionClosed():

[java] view plain copy

// 当新连接建立的时候，被调用;
public void afterConnectionEstablished(WebSocketSession session)
throws Exception {
logger.info("Connection established");
}

[java] view plain copy

// 当连接关闭时被调用；
@Override
public void afterConnectionClosed(
WebSocketSession session, CloseStatus status) throws Exception {
logger.info("Connection closed. Status: " + status);
}

3）现在已经有了 message handler 类了，下面对其进行配置，配置到 springmvc 的运行环境中。

[java] view plain copy

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer{
@Override
public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
registry.addHandler(getTextHandler(), "/websocket/p2ptext");
} // 将 ChatTextHandler 处理器映射到 /websocket/p2ptext 路径下.
@Bean
public ChatTextHandler getTextHandler() {
return new ChatTextHandler();
}
}

对上述代码的分析（Analysis）：registerWebSocketHandlers方法是注册消息处理器的关键：通过调用 WebSocketHandlerRegistry .addHandler() 方法来注册信息处理器；

Attention）server 端的 WebSocket 配置完毕，下面配置客户端；

4）WebSocket 客户端配置

4.1）client 发送一个文本到 server，他监听来自 server 的文本消息。下面代码展示了利用 js 开启一个原始的 WebSocket 并使用它来发送消息给server；

4.2）代码如下：

[html] view plain copy

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>



<html lang="zh-CN">

<head>

<meta charset="utf-8">

<meta http-equiv="X-UA-Compatible" content="IE=edge">

<meta name="viewport" content="width=device-width, initial-scale=1">



<title>web socket</title>



<link href="<c:url value="/"/>bootstrap/css/bootstrap.min.css"

rel="stylesheet">





<script src="<c:url value="/"/>bootstrap/jquery/jquery.min.js"></script>



<script src="<c:url value="/"/>bootstrap/js/bootstrap.min.js"></script>



<script type="text/javascript">

$(document).ready(function() {

websocket_client();

});



function websocket_client() {

var hostaddr = window.location.host + "<c:url value='/websocket/p2ptext' />";

var url = 'ws://' + hostaddr;

var sock = new WebSocket(url);



// 以下的 open(), onmessage(), onclose()

// 对应到 ChatTextHandler 的

// afterConnectionEstablished(), handleTextMessage(), afterConnectionClosed();



sock.open = function() {

alert("open successfully.");

sayMarco();

};



sock.onmessage = function(e) {

alert("onmessage");

alert(e);

};



sock.onclose = function() {

alert("close");

};



function sayMarco() {

sock.send("this is the websocket client.");

}

}

</script>

</head>



<body>

<div id="websocket">

websocket div.

</div>

</body>

</html>

error）这样配置后， WebSocket 无法正常运行；

【2】应对不支持 WebSocket 的场景（引入 SockJS）

1）problem+solutions：

1.1）problem：许多浏览器不支持 WebSocket 协议；

1.2）solutions： SockJS 是 WebSocket 技术的一种模拟。SockJS 会尽可能对应 WebSocket API，但如果 WebSocket 技术不可用的话，就会选择另外的通信方式协议；

2）SockJS 会优先选择 WebSocket 协议，但是如果 WebSocket协议不可用的话，他就会从如下方案中挑选最优可行方案：

[java] view plain copy

XHR streaming
XDR streaming
iFrame event source
iFrame HTML file
XHR polling
XDR polling
iFrame XHR polling
JSONP polling

3）如何在 server 端配置 SockJS ：添加 withSockJS() 方法；

[java] view plain copy

// 将 ChatTextHandler 映射到 /chat/text 路径下.
@Override
public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
registry.addHandler(getTextHandler(), "/websocket/p2ptext").withSockJS();
// withSockJS() 方法声明我们想要使用 SockJS 功能，如果WebSocket不可用的话，会使用 SockJS；
}

4）客户端配置 SockJS，想要确保加载了 SockJS 客户端；

4.1）具体做法是依赖于 JavaScript 模块加载器（如 require.js or curl.js）　还是简单使用 <script> 标签加载 JavaScript 库。最简单的方法是使用 <script> 标签从 SockJS CDN 中进行加载，如下所示：

[javascript] view plain copy

<script src="http://cdn.sockjs.org/sockjs-0.3.min.js"></script>

Attention）用 WebJars 解析 Web资源（可选，有兴趣的童鞋可以尝试下）

A1）在springmvc 配置中搭建一个资源处理器，让它负责解析路径以 "webjars/**" 开头的请求，这也是 WebJars 的标准路径：

[java] view plain copy

@Override

public void addResourceHandlers(ResourceHandlerRegistry registry) {

registry.addResourceHandler("/webjars/**")

.addResourceLocations("classpath:/META-INF/resources/webjars/");

}

A2）在这个资源处理器准备就绪后，我们可以在 web 页面中使用如下的 <script> 标签加载 SockJS 库；

[javascript] view plain copy

<script src="sockjs.min.js}"> </script>

5）处理加载 SockJS 客户端库以外，还要修改两行代码：

[javascript] view plain copy

var url = 'p2ptext';
var sock = new SockJS(url);

对以上代码的分析（Analysis）：

A1）SockJS 所处理的URL 是 "http://" 或 "https://" 模式，而不是 "ws://" or "wss://" ；

A2）其他的函数如 onopen, onmessage, and onclose ，SockJS 客户端与 WebSocket 一样；

6）SockJS 为 WebSocket 提供了备选方案。但无论哪种场景，对于实际应用来说，这种通信形式层级过低。下面看一下如何在 WebSocket 之上使用 STOMP协议，来为浏览器和 server间的通信增加适当的消息语义； （干货——引入 STOMP—— Simple Text Oriented Message Protocol——面向消息的简单文本协议）

【3】使用 STOMP消息

1）intro：如何理解 STOMP 与 WebSocket 的关系：

1.1）假设 HTTP 协议并不存在，只能使用 TCP 套接字来编写 web 应用，你可能认为这是一件疯狂的事情；

1.2）不过幸好，我们有 HTTP协议，它解决了 web 浏览器发起请求以及 web 服务器响应请求的细节；

1.3）直接使用 WebSocket（SockJS）就很类似于使用 TCP 套接字来编写 web 应用；因为没有高层协议，因此就需要我们定义应用间所发送消息的语义，还需要确保连接的两端都能遵循这些语义；

1.4）同 HTTP 在 TCP 套接字上添加请求-响应模型层一样，STOMP 在 WebSocket 之上提供了一个基于帧的线路格式层，用来定义消息语义；（干货——STOMP 在 WebSocket 之上提供了一个基于帧的线路格式层，用来定义消息语义）

2）STOMP 帧：该帧由命令，一个或多个头信息以及负载所组成。如下就是发送数据的一个 STOMP帧：（干货——引入了 STOMP帧格式）

[javascript] view plain copy

SEND
destination:/app/marco
content-length:20
{\"message\":\"Marco!\"}

对以上代码的分析（Analysis）：

A1）SEND：STOMP命令，表明会发送一些内容；

A2）destination：头信息，用来表示消息发送到哪里；

A3）content-length：头信息，用来表示负载内容的大小；

A4）空行：

A5）帧内容（负载）内容：

3）STOMP帧信息最有意思的是 destination头信息了： 它表明 STOMP 是一个消息协议，类似于 JMS 或 AMQP。消息会发送到某个目的地，这个目的地实际上可能真的有消息代理作为支撑。另一方面，消息处理器也可以监听这些目的地，接收所发送过来的消息；

【3.1】启用STOMP 消息功能

1）intro：spring 的消息功能是基于消息代理构建的，因此我们必须要配置一个消息代理和其他的一些消息目的地；（干货——spring 的消息功能是基于消息代理构建的）

2）如下代码展现了如何通过 java配置启用基于代理的的web 消息功能；

（干货——@EnableWebSocketMessageBroker 注解的作用：能够在 WebSocket 上启用 STOMP）

[java] view plain copy

package com.spring.spittr.web;
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.AbstractWebSocketMessageBrokerConfigurer;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig extends AbstractWebSocketMessageBrokerConfigurer {
@Override
public void configureMessageBroker(MessageBrokerRegistry config) {
config.enableSimpleBroker("/topic", "/queue");
config.setApplicationDestinationPrefixes("/app");
// 应用程序以 /app 为前缀，而代理目的地以 /topic 为前缀.
// js.url = "/spring13/app/hello" -> @MessageMapping("/hello") 注释的方法.
}
@Override
public void registerStompEndpoints(StompEndpointRegistry registry) {
registry.addEndpoint("/hello").withSockJS();
// 在网页上我们就可以通过这个链接 /server/hello ==<c:url value='/hello'></span> 来和服务器的WebSocket连接
}
}

对以上代码的分析（Analysis）：

A1）EnableWebSocketMessageBroker注解表明： 这个配置类不仅配置了 WebSocket，还配置了基于代理的 STOMP 消息；

A2）它重载了 registerStompEndpoints() 方法：将 "/hello" 路径注册为 STOMP 端点。这个路径与之前发送和接收消息的目的路径有所不同，这是一个端点，客户端在订阅或发布消息到目的地址前，要连接该端点，即用户发送请求 url='/server/hello' 与 STOMP server 进行连接，之后再转发到订阅url；（server== name of your springmvc project ）（干货——端点的作用——客户端在订阅或发布消息到目的地址前，要连接该端点）

A3）它重载了 configureMessageBroker() 方法：配置了一个简单的消息代理。如果不重载，默认case下，会自动配置一个简单的内存消息代理，用来处理 "/topic" 为前缀的消息。但经过重载后，消息代理将会处理前缀为 "/topic" and "/queue" 消息。

A4）之外：发送应用程序的消息将会带有 "/app" 前缀，下图展现了这个配置中的消息流；

对上述处理step的分析（Analysis）：

A1）应用程序的目的地以 "/app" 为前缀，而代理的目的地以 "/topic" 和 "/queue" 作为前缀；

A2）以应用程序为目的地的消息将会直接路由到带有 @MessageMapping 注解的控制器方法中；(干货—— @MessageMapping的作用)

A3）而发送到代理上的消息，包括 @MessageMapping注解方法的返回值所形成的消息，将会路由到代理上，并最终发送到订阅这些目的地客户端；

（干货——client 连接地址和发送地址是不同的，以本例为例，前者是/server/hello, 后者是/server/app/XX，先连接后发送）

【3.1.1】启用 STOMP 代理中继

1）intro：在生成环境下，可能会希望使用真正支持 STOMP 的代理来支持 WebSocket 消息，如RabbitMQ 或 ActiveMQ。这样的代理提供了可扩展性和健壮性更好的消息功能，当然，他们也支持 STOMP 命令；

2）如何使用 STOMP 代理来替换内存代理，代码如下：

[java] view plain copy

@Override
public void configureMessageBroker(MessageBrokerRegistry registry) {
// 启用了 STOMP 代理中继功能，并将其代理目的地前缀设置为 /topic and /queue .
registry.enableStompBrokerRelay("/queue", "/topic")
.setRelayPort(62623);
registry.setApplicationDestinationPrefixes("/app"); // 应用程序目的地.
}

对以上代码的分析（Analysis）：（干货——STOMP代理前缀和应用程序前缀的意义）

A1）方法第一行启用了 STOMP 代理中继功能： 并将其目的地前缀设置为 "/topic" or "/queue" ；spring就能知道所有目的地前缀为 "/topic" or "/queue" 的消息都会发送到 STOMP 代理中；

A2）方法第二行设置了应用的前缀为 "app"：所有目的地以 "/app" 打头的消息（发送消息url not 连接url）都会路由到带有 @MessageMapping 注解的方法中，而不会发布到代理队列或主题中；

3）下图阐述了代理中继如何应用于 spring 的 STOMP 消息处理之中。与上图的关键区别在于： 这里不再模拟STOMP 代理的功能，而是由代理中继将消息传送到一个真正的消息代理来进行处理；

Attention）

A1）enableStompBrokerRelay() and setApplicationDestinationPrefixes() 方法都可以接收变长参数；

A2）默认情况下： STOMP 代理中继会假设代理监听 localhost 的61613 端口，并且 client 的 username 和password 均为 guest。当然你也可以自行定义；

[java] view plain copy

@Override

public void configureMessageBroker(MessageBrokerRegistry registry) {

registry.enableStompBrokerRelay("/topic", "/queue")

.setRelayHost("rabbit.someotherserver")

.setRelayPort(62623)

.setClientLogin("marcopolo")

.setClientPasscode("letmein01");

registry.setApplicationDestinationPrefixes("/app", "/foo");

} // setXXX()方法是可选的

【3.2】处理来自客户端的 STOMP 消息

1）借助 @MessageMapping 注解能够在控制器中处理 STOMP 消息

[java] view plain copy

package com.spring.spittr.web;
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.handler.annotation.SendTo;
import org.springframework.stereotype.Controller;
import com.spring.pojo.Greeting;
import com.spring.pojo.HelloMessage;
@Controller
public class GreetingController {
@MessageMapping("/hello")
@SendTo("/topic/greetings")
public Greeting greeting(HelloMessage message) throws Exception {
System.out.println("receiving " + message.getName());
System.out.println("connecting successfully.");
return new Greeting("Hello, " + message.getName() + "!");
}
}

对以上代码的分析（Analysis）：

A1）@MessageMapping注解：表示 handleShout()方法能够处理指定目的地上到达的消息；

A2）这个目的地（消息发送目的地url）就是 "/server/app/hello"，其中 "/app" 是隐含的 ,"/server" 是 springmvc 项目名称；

2）因为我们现在处理的不是 HTTP，所以无法使用 spring 的 HttpMessageConverter 实现将负载转换为Shout 对象。Spring 4.0 提供了几个消息转换器如下：（Attention，如果是传输json数据的话，定要添加 Jackson jar 包到你的springmvc 项目中，不然连接不会成功的）

【3.2.1】处理订阅（@SubscribeMapping注解）

1）@SubscribeMapping注解的方法：当收到 STOMP 订阅消息的时候，带有 @SubscribeMapping 注解的方法将会触发；其也是通过 AnnotationMethodMessageHandler 来接收消息的；

2）@SubscribeMapping注解的应用场景：实现请求-回应模式。在请求-回应模式中，客户端订阅一个目的地，然后预期在这个目的地上获得一个一次性的响应；（干货——引入了@SubsribeMapping注解实现请求-回应模式）

2.1）看个荔枝：

[java] view plain copy

@SubscribeMapping({"/marco"})
public Shout handleSubscription() {
Shout outgoing = new Shout();
outgoing.setMessage("Polo!");
return outgoing;
}

对以上代码的分析（Analysis）：

A1）@SubscribeMapping注解的方法来处理对 "/app/macro" 目的地订阅（与 @MessageMapping类似，"/app" 是隐含的）；

A2）请求-回应模式与 HTTP GET 的全球-响应模式差不多：关键区别在于， HTTP GET 请求是同步的，而订阅的全球-回应模式是异步的，这样客户端能够在回应可用时再去处理，而不必等待；（干货——HTTP GET 请求是同步的，而订阅的请求-回应模式是异步的）

【3.2.2】编写 JavaScript 客户端

1）intro：借助 STOMP 库，通过 JavaScript发送消息

[javascript] view plain copy

<script type="text/javascript">
var stompClient = null;
function setConnected(connected) {
document.getElementById('connect').disabled = connected;
document.getElementById('disconnect').disabled = !connected;
document.getElementById('conversationDiv').style.visibility = connected ? 'visible' : 'hidden';
document.getElementById('response').innerHTML = '';
}
function connect() {
var socket = new SockJS("<c:url value='/hello'/>");
stompClient = Stomp.over(socket);
stompClient.connect({}, function(frame) {
setConnected(true);
console.log('Connected: ' + frame);
stompClient.subscribe('/topic/greetings', function(greeting){
showGreeting(JSON.parse(greeting.body).content);
});
});
}
function disconnect() {
if (stompClient != null) {
stompClient.disconnect();
}
setConnected(false);
console.log("Disconnected");
}
function sendName() {
var name = document.getElementById('name').value;
stompClient.send("/app/hello", {}, JSON.stringify({ 'name': name }));
}
function showGreeting(message) {
var response = document.getElementById('response');
var p = document.createElement('p');
p.style.wordWrap = 'break-word';
p.appendChild(document.createTextNode(message));
response.appendChild(p);
}
</script>

对以上代码的分析（Analysis）： 以上代码连接“/hello” 端点并发送 ”name“；

2）stompClient.send("/app/hello", {}, JSON.stringify({'name':name}))： 第一个参数：json 负载消息发送的目的地；第二个参数：是一个头信息的Map，它会包含在 STOMP 帧中；第三个参数：负载消息；

（干货—— stomp client 连接地址和发送地址不一样的，连接地址为 <c:url value='/hello'/> ==localhost:8080/springmvc_project_name/hello , 而发送地址为 '/app/hello'，这里要当心）

downloading these files below from https://github.com/pacosonTang/SpringInAction/tree/master/spring18

[javascript] view plain copy

<script src="<c:url value="/resources/sockjs-1.1.1.js" />"></script>
<script src="<c:url value="/resources/stomp.js" />"></script>

[javascript] view plain copy

//this line.
function connect() {
var socket = new SockJS("<c:url value='/hello'/>");
stompClient = Stomp.over(socket);
stompClient.connect({}, function(frame) {
setConnected(true);
console.log('Connected: ' + frame);
stompClient.subscribe('/topic/greetings', function(greeting){
showGreeting(JSON.parse(greeting.body).content);
});
stompClient.subscribe('/app/macro',function(greeting){
alert(JSON.parse(greeting.body).content);
showGreeting(JSON.parse(greeting.body).content);
});
});
}
function sendName() {
var name = document.getElementById('name').value;
stompClient.send("/app/hello", {}, JSON.stringify({ 'name': name }));
}

[java] view plain copy

package com.spring.spittr.web;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.handler.annotation.SendTo;
import org.springframework.messaging.simp.SimpMessageSendingOperations;
import org.springframework.messaging.simp.SimpMessagingTemplate;
import org.springframework.messaging.simp.annotation.SubscribeMapping;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import com.spring.pojo.Greeting;
import com.spring.pojo.HelloMessage;
@Controller
public class GreetingController {
// @MessageMapping defines the sending addr for client.
// 消息发送地址: /server/app/hello
@MessageMapping("/hello")
@SendTo("/topic/greetings")
public Greeting greeting(HelloMessage message) throws Exception {
System.out.println("receiving " + message.getName());
System.out.println("connecting successfully.");
return new Greeting("Hello, " + message.getName() + "!");
}
@SubscribeMapping("/macro")
public Greeting handleSubscription() {
System.out.println("this is the @SubscribeMapping('/marco')");
Greeting greeting = new Greeting("i am a msg from SubscribeMapping('/macro').");
return greeting;
}
/*@MessageMapping("/feed")
@SendTo("/topic/feed")
public Greeting greetingForFeed(HelloMessage message) throws Exception {
System.out.println("receiving " + message.getName());
System.out.println("connecting successfully.");
return new Greeting("i am /topic/feed, hello " + message.getName() + "!");
}*/
// private SimpMessagingTemplate template;
// SimpMessagingTemplate implements SimpMessageSendingOperations.
private SimpMessageSendingOperations template;
@Autowired
public GreetingController(SimpMessageSendingOperations template) {
this.template = template;
}
@RequestMapping(path="/feed", method=RequestMethod.POST)
public void greet(
@RequestParam String greeting) {
String text = "you said just now " + greeting;
this.template.convertAndSend("/topic/feed", text);
}
}

[java] view plain copy

package com.spring.spittr.web;
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.AbstractWebSocketMessageBrokerConfigurer;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig extends AbstractWebSocketMessageBrokerConfigurer {
@Override
public void configureMessageBroker(MessageBrokerRegistry config) {
config.enableSimpleBroker("/topic", "/queue");
config.setApplicationDestinationPrefixes("/app");
// 应用程序以 /app 为前缀，而代理目的地以 /topic 为前缀.
// js.url = "/spring13/app/hello" -> @MessageMapping("/hello") 注释的方法.
}
@Override
public void registerStompEndpoints(StompEndpointRegistry registry) {
registry.addEndpoint("/hello").withSockJS();
// 在网页上我们就可以通过这个链接 /server/hello 来和服务器的WebSocket连接
}
}

[java] view plain copy

package com.spring.spittr.web;
import java.io.IOException;
import org.springframework.context.MessageSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.support.ResourceBundleMessageSource;
import org.springframework.core.io.FileSystemResource;
import org.springframework.web.multipart.MultipartResolver;
import org.springframework.web.multipart.commons.CommonsMultipartResolver;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.springframework.web.servlet.view.InternalResourceViewResolver;
import org.springframework.web.servlet.view.tiles3.TilesConfigurer;
import org.springframework.web.servlet.view.tiles3.TilesViewResolver;
@Configuration
@ComponentScan(basePackages = { "com.spring.spittr.web" })
@EnableWebMvc
@Import({WebSocketConfig.class})
public class WebConfig extends WebMvcConfigurerAdapter {
@Bean
public TilesConfigurer tilesConfigurer() {
TilesConfigurer tiles = new TilesConfigurer();
tiles.setDefinitions(new String[] { "/WEB-INF/layout/tiles.xml" });
tiles.setCheckRefresh(true);
return tiles;
}
// config processing for static resources.
@Override
public void configureDefaultServletHandling(
DefaultServletHandlerConfigurer configurer) {
configurer.enable();
}
// InternalResourceViewResolver
@Bean
public ViewResolver viewResolver1() {
TilesViewResolver resolver = new TilesViewResolver();
return resolver;
}
@Bean
public ViewResolver viewResolver2() {
InternalResourceViewResolver resolver = new InternalResourceViewResolver();
resolver.setPrefix("/WEB-INF/views/");
resolver.setSuffix(".jsp");
resolver.setExposeContextBeansAsAttributes(true);
resolver.setViewClass(org.springframework.web.servlet.view.JstlView.class);
return resolver;
}
@Bean
public MessageSource messageSource() {
ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
messageSource.setBasename("messages");
return messageSource;
}
@Bean
public MultipartResolver multipartResolver() throws IOException {
CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();
multipartResolver.setUploadTempDir(new FileSystemResource("/WEB-INF/tmp/spittr/uploads"));
multipartResolver.setMaxUploadSize(2097152);
multipartResolver.setMaxInMemorySize(0);
return multipartResolver;
}
}

【3.3】发送消息到客户端

1）intro：spring提供了两种发送数据到 client 的方法：

method1）作为处理消息或处理订阅的附带结果；

method2）使用消息模板；

【3.3.1】在处理消息后，发送消息（server 对 client 请求的响应消息）

1）intro：如果你想要在接收消息的时候，在响应中发送一条消息，修改方法签名不是void 类型即可，如下：

[java] view plain copy

@MessageMapping("/hello")
@SendTo("/topic/greetings") //highlight line.
public Greeting greeting(HelloMessage message) throws Exception {
System.out.println("receiving " + message.getName());
System.out.println("connecting successfully.");
return new Greeting("Hello, " + message.getName() + "!");
}

对以上代码的分析（Analysis）：返回的对象将会进行转换（通过消息转换器）并放到 STOMP 帧的负载中，然后发送给消息代理（消息代理分为 STOMP代理中继和内存消息代理）；

2）默认情况下：帧所发往的目的地会与触发处理器方法的目的地相同。所以返回的对象会写入到 STOMP 帧的负载中，并发布到 "/topic/stomp" 目的地。不过，可以通过 @SendTo 注解，重载目的地；（干货——注解 @SendTo 注解的作用）
代码同上。
对以上代码的分析（Analysis）：消息将会发布到 /topic/hello，所有订阅这个主题的应用都会收到这条消息；

3）@SubscriptionMapping 注解标注的方式也能发送一条消息，作为订阅的回应。

3.1）看个荔枝： 通过为控制器添加如下的方法，当客户端订阅的时候，将会发送一条 shout 信息：

[java] view plain copy

@SubscribeMapping("/macro") // defined in Controller. attention for addr '/macro' in server.
public Greeting handleSubscription() {
System.out.println("this is the @SubscribeMapping('/marco')");
Greeting greeting = new Greeting("i am a msg from SubscribeMapping('/macro').");
return greeting;
}

[javascript] view plain copy

function connect() {
var socket = new SockJS("<c:url value='/hello'/>");
stompClient = Stomp.over(socket);
stompClient.connect({}, function(frame) {
setConnected(true);
console.log('Connected: ' + frame);
stompClient.subscribe('/topic/greetings', function(greeting){
showGreeting(JSON.parse(greeting.body).content);
});
// starting line.
stompClient.subscribe('/app/macro',function(greeting){
alert(JSON.parse(greeting.body).content);
showGreeting(JSON.parse(greeting.body).content);
}); // ending line. attention for addr '/app/macro' in client.
});
}

对以上代码的分析（Analysis）：

A0）这个SubscribeMapping annotation标记的方法，是在订阅的时候调用的，也就是说，基本是只执行一次的方法，client 调用定义在server 的该 Annotation 标注的方法，它就会返回结果，不过经过代理。

A1）这里的 @SubscribeMapping 注解表明当客户端订阅 "/app/macro" 主题的时候（"/app"是应用目的地的前缀，注意，这里没有加springmvc 项目名称前缀），将会调用 handleSubscription 方法。它所返回的shout 对象将会进行转换并发送回client；

A2）SubscribeMapping注解的区别在于： 这里的 Shout 消息将会直接发送给 client，不用经过消息代理；但，如果为方法添加 @SendTo 注解的话，那么消息将会发送到指定的目的地，这样就会经过代理；（干货——SubscribeMapping注解返回的消息直接发送到 client，不经过代理，而 @SendTo 注解的路径，就会经过代理，然后再发送到目的地）

【3.3.2】在应用的任意地方发送消息

1）intro：spring 的 SimpMessagingTemplate 能够在应用的任何地方发送消息，不必以接收一条消息为前提；

2）看个荔枝： 让首页订阅一个 STOMP主题，在 Spittle 创建的时候，该主题能够收到 Spittle 更新时的 feed；

2.1）JavaScript 代码：

[javascript] view plain copy

<script>
var sock = new SockJS('spittr');
var stomp = Stomp.over(sock);
stomp.connect('guest', 'guest', function(frame) {
console.log('Connected');
stomp.subscribe("/topic/spittlefeed", handleSpittle); // highlight.
});
function handleSpittle(incoming) {
var spittle = JSON.parse(incoming.body);
console.log('Received: ', spittle);
var source = $("#spittle-template").html();
var template = Handlebars.compile(source);
var spittleHtml = template(spittle);
$('.spittleList').prepend(spittleHtml);
}
</script>

对以上代码的分析（Analysis）： 在连接到 STMOP 代理后，我们订阅了 "/topic/spittlefeed" 主题，并指定当消息到达的是，由 handleSpittle()函数来处理 Spittle 更新。

2.2） server 端代码：使用 SimpMessagingTemplate 将所有新创建的 Spittle 以消息的形式发布到 "/topic/feed" 主题上；

[java] view plain copy

@Service
public class SpittleFeedServiceImpl implements SpittleFeedService {
private SimpMessageSendingOperations messaging;
@Autowired
public SpittleFeedServiceImpl(
SimpMessageSendingOperations messaging) { // 注入消息模板.
this.messaging = messaging;
}
public void broadcastSpittle(Spittle spittle) {
messaging.convertAndSend("/topic/spittlefeed", spittle); // 发送消息.
}
}

对以上代码的分析（Analysis）：

A1）配置 spring 支持 stomp 的一个附带功能是在spring应用上下文中已经包含了 Simple

A2）在发布消息给 STOMP 主题的时候，所有订阅该主题的客户端都会收到消息。但有的时候，我们希望将消息发送给指定用户；

【4】为目标用户发送消息

1）intro：在使用 srping 和 STOMP 消息功能的时候，有三种方式来利用认证用户：

way1）@MessageMapping and @SubscribeMapping 注解标注的方法能够使用 Principal 来获取认证用户；

way2）@MessageMapping, @SubscribeMapping, and @MessageException 方法返回的值能够以消息的形式发送给认证用户；

way3）SimpMessagingTemplate 能够发送消息给特定用户；

【4.1】在控制器中处理用户的消息

1）看个荔枝： 编写一个控制器方法，根据传入的消息创建新的Spittle 对象，并发送一个回应，表明对象创建成功；（这种 REST也可以实现，不过它是同步的，而这里是异步的）；

1.1）代码如下：它会处理传入的消息并将其存储我 Spittle：

[java] view plain copy

@MessageMapping("/spittle")

@SendToUser("/queue/notifications")

public Notification handleSpittle(

Principal principal, SpittleForm form) {

Spittle spittle = new Spittle(

principal.getName(), form.getText(), new Date());

spittleRepo.save(spittle);

return new Notification("Saved Spittle");

}

1.2）该方法最后返回一个新的 Notificatino，表明对象保存成功；

1.3）该方法使用了 @MessageMapping("/spittle") 注解，所以当有发往 "/app/spittle" 目的地的消息到达时，该方法就会触发；如果用户已经认证的话，将会根据 STOMP 帧上的头信息得到 Principal 对象；

1.4）@SendToUser注解：指定了 Notification 要发送的目的地 "/queue/notifications"；

1.5）表明上， "/queue/notifications" 并不会与特定用户相关联，但因为这里使用的是 @SendToUser注解，而不是 @SendTo，所以就会发生更多的事情了；

2）看一下针对控制器方法发布的 Notificatino 对象的目的地，客户端该如何进行订阅。

2.1）看个荔枝：考虑如下的 JavaScript代码，它订阅了一个用户特定的目的地：

[javascript] view plain copy

stomp.subscribe("/user/queue/notifications", handleNotifications);

对以上代码的分析（Analysis）：这个目的地使用了 "/user" 作为前缀，在内部，以"/user" 为前缀的消息将会通过 UserDestinationMessageHandler 进行处理，而不是 AnnotationMethodMessageHandler 或 SimpleBrokerMessageHandler or StompBrokerRelayMessageHandler，如下图所示：

Attention）UserDestinationMessageHandler 的主要任务： 是将用户消息重新路由到某个用户独有的目的地上。在处理订阅的时候，它会将目标地址中的 "/user" 前缀去掉，并基于用户的会话添加一个后缀。如，对 "/user/queue/notifications" 的订阅最后可能路由到名为 "/queue/notifacations-user65a4sdfa" 目的地上；

【4.2】为指定用户发送消息

1）intro：SimpMessagingTemplate还提供了 convertAndSendToUser() 方法，该方法能够让我们给特定用户发送消息；

2）我们在 web 应用上添加一个特性： 当其他用户提交的 Spittle 提到某个用户时，将会提醒该用户（干货——这难道不是微博的 @ 功能吗）

2.1）看个荔枝：如果Spittle 文本中包含 "@tangrong"，那么我们就应该发送一条消息给使用 tangrong 用户名登录的client，代码实例如下：

[java] view plain copy

@Service
public class SpittleFeedServiceImpl implements SpittleFeedService {
private SimpMessagingTemplate messaging;
// 实现用户提及功能的正则表达式
private Pattern pattern = Pattern.compile("\\@(\\S+)");
@Autowired
public SpittleFeedServiceImpl(SimpMessagingTemplate messaging) {
this.messaging = messaging;
}
public void broadcastSpittle(Spittle spittle) {
messaging.convertAndSend("/topic/spittlefeed", spittle);
Matcher matcher = pattern.matcher(spittle.getMessage());
if (matcher.find()) {
String username = matcher.group(1);
// 发送提醒给用户.
messaging.convertAndSendToUser(
username, "/queue/notifications",
new Notification("You just got mentioned!"));
}
}
}

【5】处理消息异常

1）intro：我们也可以在控制器方法上添加 @MessageExceptionHandler 注解，让它来处理 @MessageMapping 方法所抛出的异常；

2）看个荔枝：它会处理消息方法所抛出的异常；

[java] view plain copy

@MessageExceptionHandler
public void handleExceptions(Throwable t) {
logger.error("Error handling message: " + t.getMessage());
}

3）我们也可以以参数的形式声明它所能处理的异常；

[java] view plain copy

@MessageExceptionHandler(SpittleException.class) // highlight line.
public void handleExceptions(Throwable t) {
logger.error("Error handling message: " + t.getMessage());
}
// 或者：
@MessageExceptionHandler( {SpittleException.class, DatabaseException.class}) // highlight line.
public void handleExceptions(Throwable t) {
logger.error("Error handling message: " + t.getMessage());
}

4）该方法还可以回应一个错误：

[java] view plain copy

@MessageExceptionHandler(SpittleException.class)
@SendToUser("/queue/errors")
public SpittleException handleExceptions(SpittleException e) {
logger.error("Error handling message: " + e.getMessage());
return e;
}
// 如果抛出 SpittleException 的话，将会记录这个异常，并将其返回.
// 而 UserDestinationMessageHandler 会重新路由这个消息到特定用户所对应的唯一路径；

springmvc(18)使用WebSocket 和 STOMP 实现消息功能

猜你喜欢