weixin_34186931
weixin_34186931

Spring Websocket 中文文档 (spring5)

为什么80%的码农都做不了架构师？>>>   hot3.png

这部分参考文档包括对Servlet堆栈的支持，包括原始WebSocket交互的WebSocket消息传递，通过SockJS的WebSocket仿真，以及通过STOMP作为WebSocket上的子协议的pub-sub消息传递。

4.1。介绍

WebSocket协议RFC 6455提供了一种标准化方法，可通过单个TCP连接在客户端和服务器之间建立全双工双向通信通道。它是来自HTTP的不同TCP协议，但设计为使用端口80和443通过HTTP工作，并允许重用现有防火墙规则。

WebSocket交互以HTTP请求开始，该HTTP请求使用HTTP "Upgrade"标头升级，或者在这种情况下切换到WebSocket协议：

GET / spring-websocket-portfolio / portfolio HTTP / 1.1
主持人：localhost：8080
升级：websocket 
连接：升级
Sec-WebSocket-Key：Uc9l9TMkWGbHFD2qnFHltg ==
Sec-WebSocket-Protocol：v10.stomp，v11.stomp
Sec-WebSocket-Version：13
来源：http：// localhost：8080

具有WebSocket支持的服务器返回：而不是通常的200状态代码：

HTTP / 1.1 101交换协议
升级：websocket
连接：升级
Sec-WebSocket-Accept：1qVdfYHU9hPOl4JYYNXF623Gzn0 =
Sec-WebSocket-Protocol：v10.stomp

成功握手后，HTTP升级请求下的TCP套接字保持打开状态，客户端和服务器都可以继续发送和接收消息。

有关WebSockets如何工作的完整介绍超出了本文档的范围。请阅读RFC 6455，HTML5的WebSocket章节，或Web上的许多介绍和教程之一。

请注意，如果WebSocket服务器在Web服务器（例如nginx）后面运行，您可能需要将其配置为将WebSocket升级请求传递到WebSocket服务器。同样，如果应用程序在云环境中运行，请检查与WebSocket支持相关的云提供程序的说明。

4.1.1。HTTP vs WebSocket

即使WebSocket被设计为HTTP兼容并以HTTP请求开始，但重要的是要理解这两种协议会导致非常不同的体系结构和应用程序编程模型。

在HTTP和REST中，应用程序被建模为多个URL。要与应用程序客户端进行交互，请访问这些URL，请求 - 响应样式。服务器根据HTTP URL，方法和标头将请求路由到适当的处理程序。

相比之下，在WebSockets中，通常只有一个URL用于初始连接，随后所有应用程序消息都在同一TCP连接上流动。这指向完全不同的异步，事件驱动的消息传递体系结构。

WebSocket也是一种低级传输协议，与HTTP不同，它没有规定消息内容的任何语义。这意味着除非客户端和服务器就消息语义达成一致，否则无法路由或处理消息。

WebSocket客户端和服务器可以通过"Sec-WebSocket-Protocol"HTTP握手请求上的标头协商使用更高级别的消息传递协议（例如STOMP），或者在没有它们的情况下，他们需要提出自己的约定。

4.1.2。什么时候用？

WebSockets可以使网页动态和交互。但是，在许多情况下，Ajax和HTTP流和/或长轮询的组合可以提供简单有效的解决方案。

例如，新闻，邮件和社交订阅源需要动态更新，但每隔几分钟就可以完全正常更新。另一方面，协作，游戏和财务应用程序需要更接近实时。

仅延迟不是决定因素。如果消息量相对较低（例如，监视网络故障），则HTTP流式传输或轮询可以提供有效的解决方案。它是低延迟，高频率和高容量的组合，是使用WebSocket的最佳选择。

还要记住，通过Internet，控制之外的限制性代理可能会阻止WebSocket交互，因为它们未配置为传递 Upgrade标头，或者因为它们关闭看似空闲的长期连接？这意味着将WebSocket用于防火墙内的内部应用程序比面向公众的应用程序更直接。

4.2。WebSocket API

在Spring WebFlux中也是如此

Spring Framework提供了一个WebSocket API，可用于编写处理WebSocket消息的客户端和服务器端应用程序。

4.2.1。WebSocketHandler

在Spring WebFlux中也是如此

创建的WebSocket服务器是为实现简单WebSocketHandler或更可能要么延长TextWebSocketHandler或BinaryWebSocketHandler：

import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.TextMessage;

public class MyHandler extends TextWebSocketHandler {

    @Override
    public void handleTextMessage(WebSocketSession session, TextMessage message) {
        // ...
    }

}

有专门的WebSocket Java-config和XML名称空间支持，用于将上述WebSocket处理程序映射到特定的URL：

import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(myHandler(), "/myHandler");
    }

    @Bean
    public WebSocketHandler myHandler() {
        return new MyHandler();
    }

}

XML配置等效：

 xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:websocket="http://www.springframework.org/schema/websocket"
    xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/websocket http://www.springframework.org/schema/websocket/spring-websocket.xsd">

    
         path="/myHandler" handler="myHandler"/>
    

     id="myHandler" class="org.springframework.samples.MyHandler"/>

以上内容适用于Spring MVC应用程序，应包含在DispatcherServlet的配置中。但是，Spring的WebSocket支持不依赖于Spring MVC。WebSocketHandler 在WebSocketHttpRequestHandler的帮助下将其集成到其他HTTP服务环境中 相对简单。

4.2.2。WebSocket握手

在Spring WebFlux中也是如此

自定义初始HTTP WebSocket握手请求的最简单方法是通过a HandshakeInterceptor，它暴露握手方法的“之前”和“之后”。这样的拦截器可用于阻止握手或使任何属性可用于WebSocketSession。例如，有一个内置拦截器，用于将HTTP会话属性传递给WebSocket会话：

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(new MyHandler(), "/myHandler")
            .addInterceptors(new HttpSessionHandshakeInterceptor());
    }

}

并且XML配置等效：

 xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:websocket="http://www.springframework.org/schema/websocket"
    xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/websocket http://www.springframework.org/schema/websocket/spring-websocket.xsd">

    
         path="/myHandler" handler="myHandler"/>
        
             class="org.springframework.web.socket.server.support.HttpSessionHandshakeInterceptor"/>
        
    

     id="myHandler" class="org.springframework.samples.MyHandler"/>

更高级的选项是扩展DefaultHandshakeHandler执行WebSocket握手步骤，包括验证客户端来源，协商子协议等。如果应用程序需要配置自定义RequestUpgradeStrategy以适应WebSocket服务器引擎和尚不支持的版本，则应用程序可能还需要使用此选项（有关此主题的更多信息，请参阅部署）。Java-config和XML命名空间都可以配置自定义 HandshakeHandler。

 

Spring提供了一个WebSocketHandlerDecorator可用于装饰WebSocketHandler附加行为的基类。使用WebSocket Java-config或XML命名空间时，默认情况下会提供并添加日志记录和异常处理实现。在ExceptionWebSocketHandlerDecorator捕获所有捕获的异常任何WebSocketHandler方法所产生的，并与状态关闭WebSocket的会议1011指示服务器错误。

4.2.3。部署

Spring WebSocket API易于集成到Spring MVC应用程序中，其中DispatcherServlet既提供HTTP WebSocket握手，也提供其他HTTP请求。通过调用也可以轻松地集成到其他HTTP处理场景中WebSocketHttpRequestHandler。这很方便易懂。但是，特殊注意事项适用于JSR-356运行时。

Java WebSocket API（JSR-356）提供了两种部署机制。第一个涉及启动时的Servlet容器类路径扫描（Servlet 3功能）; 另一个是在Servlet容器初始化时使用的注册API。这些机制都不能使用单个“前端控制器”进行所有HTTP处理 - 包括WebSocket握手和所有其他HTTP请求 - 例如Spring MVC DispatcherServlet。

这是JSR-356的一个重要限制，Spring的WebSocket支持RequestUpgradeStrategy即使在JSR-356运行时运行时也能解决特定于服务器的问题。目前，Tomcat，Jetty，GlassFish，WebLogic，WebSphere和Undertow（以及WildFly）都有这样的策略。

 

已经创建了一个克服Java WebSocket API中的上述限制的请求，可以在WEBSOCKET_SPEC-211上进行跟踪 。Tomcat，Undertow和WebSphere提供了自己的API替代方案，使其成为可能，而Jetty也是如此。我们希望更多服务器也会这样做。

第二个考虑因素是具有JSR-356支持的Servlet容器应该执行ServletContainerInitializer（SCI）扫描，这可能会减慢应用程序启动速度，在某些情况下会显着降低。如果在升级到支持JSR-356的Servlet容器版本后观察到重大影响，则应该可以通过使用以下元素选择性地启用或禁用Web片段（和SCI扫描）web.xml：

 xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation=" http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
    version="3.0">

    />

然后，您可以根据需要有选择地启用Web片段，例如Spring自己 SpringServletContainerInitializer提供对Servlet 3 Java初始化API的支持（如果需要）：

 xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation=" http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
    version="3.0">

    
        spring_web

4.2.4。服务器配置

在Spring WebFlux中也是如此

每个底层WebSocket引擎都公开控制运行时特性的配置属性，例如消息缓冲区大小，空闲超时等。

对于Tomcat，WildFly和GlassFish ServletServerContainerFactoryBean，在WebSocket Java配置中添加一个：

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

    @Bean
    public ServletServerContainerFactoryBean createWebSocketContainer() {
        ServletServerContainerFactoryBean container = new ServletServerContainerFactoryBean();
        container.setMaxTextMessageBufferSize(8192);
        container.setMaxBinaryMessageBufferSize(8192);
        return container;
    }

}

或WebSocket XML命名空间：

 xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:websocket="http://www.springframework.org/schema/websocket"
    xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/websocket http://www.springframework.org/schema/websocket/spring-websocket.xsd">

     class="org.springframework...ServletServerContainerFactoryBean">
         name="maxTextMessageBufferSize" value="8192"/>
         name="maxBinaryMessageBufferSize" value="8192"/>
 

对于客户端WebSocket配置，您应该使用WebSocketContainerFactoryBean （XML）或ContainerProvider.getWebSocketContainer()（Java配置）。

对于Jetty，您需要提供预配置的Jetty WebSocketServerFactory并DefaultHandshakeHandler通过WebSocket Java配置将其插入Spring ：

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(echoWebSocketHandler(),
            "/echo").setHandshakeHandler(handshakeHandler());
    }

    @Bean
    public DefaultHandshakeHandler handshakeHandler() {

        WebSocketPolicy policy = new WebSocketPolicy(WebSocketBehavior.SERVER);
        policy.setInputBufferSize(8192);
        policy.setIdleTimeout(600000);

        return new DefaultHandshakeHandler(
                new JettyRequestUpgradeStrategy(new WebSocketServerFactory(policy)));
    }

}

或WebSocket XML命名空间：

 xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:websocket="http://www.springframework.org/schema/websocket"
    xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/websocket http://www.springframework.org/schema/websocket/spring-websocket.xsd">

    
         path="/echo" handler="echoHandler"/>
         ref="handshakeHandler"/>
    

     id="handshakeHandler" class="org.springframework...DefaultHandshakeHandler">
         ref="upgradeStrategy"/>
    

     id="upgradeStrategy" class="org.springframework...JettyRequestUpgradeStrategy">
         ref="serverFactory"/>
    

     id="serverFactory" class="org.eclipse.jetty...WebSocketServerFactory">
        
             class="org.eclipse.jetty...WebSocketPolicy">
                 value="SERVER"/>
                 name="inputBufferSize" value="8092"/>
                 name="idleTimeout" value="600000"/>

4.2.5。允许来源

在Spring WebFlux中也是如此

从Spring Framework 4.1.5开始，WebSocket和SockJS的默认行为是仅接受相同的原始请求。也可以允许所有或指定的起源列表。此检查主要是为浏览器客户端设计的。没有什么可以阻止其他类型的客户端修改Origin标头值（有关更多详细信息，请参阅 RFC 6454：Web Origin Concept）。

3种可能的行为是：

  • 仅允许相同的原始请求（默认）：在此模式下，启用SockJS时，Iframe HTTP响应标头X-Frame-Options设置为SAMEORIGIN，并且JSONP传输被禁用，因为它不允许检查请求的来源。因此，启用此模式时不支持IE6和IE7。

  • 允许指定的原始列表：每个提供的允许来源必须以http:// 或开头https://。在此模式下，启用SockJS时，将禁用基于IFrame和JSONP的传输。因此，启用此模式时，不支持IE6到IE9。

  • 允许所有来源：要启用此模式，您应该提供*允许的原始值。在此模式下，所有传输都可用。

WebSocket和SockJS允许的起源可以配置如下所示：

import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(myHandler(), "/myHandler").setAllowedOrigins("http://mydomain.com");
    }

    @Bean
    public WebSocketHandler myHandler() {
        return new MyHandler();
    }

}

XML配置等效：

 xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:websocket="http://www.springframework.org/schema/websocket"
    xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/websocket http://www.springframework.org/schema/websocket/spring-websocket.xsd">

     allowed-origins="http://mydomain.com">
         path="/myHandler" handler="myHandler" />
    

     id="myHandler" class="org.springframework.samples.MyHandler"/>

4.3。SockJS后备

在公共Internet上，受控制之外的限制性代理可能会阻止WebSocket交互，因为它们未配置为传递Upgrade标头，或者因为它们关闭看似空闲的长期连接。

这个问题的解决方案是WebSocket仿真，即首先尝试使用WebSocket，然后依靠基于HTTP的技术来模拟WebSocket交互并公开相同的应用程序级API。

在Servlet堆栈上，Spring Framework为SockJS协议提供服务器（以及客户端）支持。

4.3.1。概观

SockJS的目标是让应用程序使用WebSocket API，但在运行时必要时可以回退到非WebSocket替代品，即无需更改应用程序代码。

SockJS包括：

  • 所述SockJS协议 以可执行的形式定义的 叙述试验。

  • 该SockJS JavaScript客户端 -在浏览器中使用客户端库。

  • SockJS服务器实现，包括Spring Framework spring-websocket模块中的一个。

  • 从4.1开始spring-websocket还提供了一个SockJS Java客户端。

SockJS专为在浏览器中使用而设计。它竭尽全力使用各种技术支持各种浏览器版本。有关SockJS传输类型和浏览器的完整列表，请参阅SockJS客户端页面。传输分为3大类：WebSocket，HTTP Streaming和HTTP Long Polling。有关这些类别的概述，请参阅 此博客文章。

SockJS客户端首先发送"GET /info"以从服务器获取基本信息。之后，它必须决定使用什么传输。如果可能，使用WebSocket。如果没有，在大多数浏览器中至少有一个HTTP流选项，如果没有，则使用HTTP（长）轮询。

所有传输请求都具有以下URL结构：

HTTP：//主机：端口/对myApp / myEndpoint / {服务器ID} / {会话ID} / {}运输

  • {server-id} - 对于在群集中路由请求有用，但在其他情况下不使用。

  • {session-id} - 关联属于SockJS会话的HTTP请求。

  • {transport} - 表示传输类型，例如“websocket”，“xhr-streaming”等。

WebSocket传输只需要一个HTTP请求即可进行WebSocket握手。之后的所有消息都在该套接字上交换。

HTTP传输需要更多请求。例如，Ajax / XHR流依赖于一个长期运行的服务器到客户端消息请求以及针对客户端到服务器消息的额外HTTP POST请求。长轮询是类似的，除了它在每个服务器到客户端发送之后结束当前请求。

SockJS增加了最小的消息框架。例如，服务器最初发送字母o（“打开”帧），消息作为[“message1”，“message2”]（JSON编码数组）发送，字母h（“心跳”帧）如果没有消息流默认为25秒，字母c（“关闭”框架）关闭会话。

要了解更多信息，请在浏览器中运行示例并观察HTTP请求。SockJS客户端允许修复传输列表，因此可以一次查看每个传输。SockJS客户端还提供了一个调试标志，可在浏览器控制台中启用有用的消息。在服务器端启用 TRACE日志记录org.springframework.web.socket。有关更多详细信息，请参阅SockJS协议 叙述测试。

4.3.2。启用S​​ockJS

通过Java配置可以轻松启用SockJS：

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(myHandler(), "/myHandler").withSockJS();
    }

    @Bean
    public WebSocketHandler myHandler() {
        return new MyHandler();
    }

}

和XML配置等价：

 xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:websocket="http://www.springframework.org/schema/websocket"
    xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/websocket http://www.springframework.org/schema/websocket/spring-websocket.xsd">

    
         path="/myHandler" handler="myHandler"/>
        />
    

     id="myHandler" class="org.springframework.samples.MyHandler"/>

以上内容适用于Spring MVC应用程序，应包含在DispatcherServlet的配置中。但是，Spring的WebSocket和SockJS支持并不依赖于Spring MVC。在SockJsHttpRequestHandler的帮助下，集成到其他HTTP服务环境中相对简单 。

在浏览器端，应用程序可以使用模拟W3C WebSocket API 的 sockjs-client（版本1.0.x）并与服务器通信，以根据其运行的浏览器选择最佳传输选项。查看 sockjs-client页面和浏览器支持的传输类型列表。客户端还提供了几个配置选项，例如，指定要包含的传输。

4.3.3。IE 8,9

Internet Explorer 8和9在一段时间内仍然很常见。他们是拥有SockJS的关键原因。本节介绍在这些浏览器中运行的重要注意事项。

SockJS客户端通过Microsoft的XDomainRequest支持IE 8和9中的Ajax / XHR流 。这适用于域，但不支持发送cookie。Cookie通常对Java应用程序至关重要。但是，由于SockJS客户端可以与许多服务器类型（不仅仅是Java）一起使用，因此需要知道cookie是否重要。如果是这样，SockJS客户端更喜欢使用Ajax / XHR进行流式传输，否则它依赖于基于iframe的技术。

最先"/info"从SockJS客户端请求是针对可能影响客户的传输选择信息的请求。其中一个细节是服务器应用程序是否依赖于cookie，例如用于身份验证或使用粘性会话进行群集。Spring的SockJS支持包括一个名为的属性sessionCookieNeeded。默认情况下启用它，因为大多数Java应用程序都依赖于JSESSIONID cookie。如果您的应用程序不需要它，您可以关闭此选项，SockJS客户端应xdr-streaming在IE 8和9中选择。

如果你使用基于iframe的运输，并且在任何情况下，这是好事，知道浏览器可以指示通过设置HTTP响应标题来阻止特定网页上的使用iframe X-Frame-Options来DENY， SAMEORIGIN或ALLOW-FROM 。这用于防止 点击劫持。

 

Spring Security 3.2+支持设置X-Frame-Options每个响应。默认情况下，Spring Security Java配置将其设置为DENY。在3.2中，Spring Security XML命名空间默认情况下不设置该标头，但可以配置为执行此操作，并且将来可以默认设置它。

见7.1节。 有关如何配置X-Frame-Options标头设置的详细信息，请参阅Spring Security文档的“默认安全标头”。您还可以查看或观看 SEC-2501以获取更多背景信息。

如果您的应用程序添加X-Frame-Options响应标头（应该！）并依赖于基于iframe的传输，则需要将标头值设置为 SAMEORIGIN或ALLOW-FROM 。除此之外，Spring SockJS支持还需要知道SockJS客户端的位置，因为它是从iframe加载的。默认情况下，iframe设置为从CDN位置下载SockJS客户端。最好将此选项配置为与应用程序源相同的URL。

在Java配置中，这可以如下所示完成。XML命名空间通过元素提供类似的选项：

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/portfolio").withSockJS()
                .setClientLibraryUrl("http://localhost:8080/myapp/js/sockjs-client.js");
    }

    // ...

}
 

在初始开发期间，请启用SockJS客户端devel模式，以防止浏览器缓存否则将被缓存的SockJS请求（如iframe）。有关如何启用它的详细信息，请参阅 SockJS客户端页面。

4.3.4。心跳

SockJS协议要求服务器发送心跳消息以阻止代理断定连接挂起。Spring SockJS配置有一个名为的属性heartbeatTime，可用于自定义频率。默认情况下，假设在该连接上没有发送其他消息，则在25秒后发送心跳。此25秒值符合以下 IETF对公共Internet应用程序的建议。

 

在WebSocket / SockJS上使用STOMP时，如果STOMP客户端和服务器协商要交换的心跳，则会禁用SockJS心跳。

Spring SockJS支持还允许配置TaskScheduler用于调度心跳任务。任务计划程序由线程池支持，默认设置基于可用处理器的数量。应用程序应考虑根据其特定需求自定义设置。

4.3.5。客户端断开连接

HTTP流式传输和HTTP长轮询SockJS传输要求连接保持打开时间比平时长。有关这些技术的概述，请参阅 此博客文章。

在Servlet容器中，这是通过Servlet 3异步支持完成的，它允许退出Servlet容器线程处理请求并继续写入来自另一个线程的响应。

一个特定的问题是Servlet API不为已经消失的客户端提供通知，请参阅SERVLET_SPEC-44。但是，Servlet容器在后续尝试写入响应时引发异常。由于Spring的SockJS服务支持服务器发送的心跳（默认情况下每25秒），这意味着如果更频繁地发送消息，通常会在该时间段或更早的时间内检测到客户端断开连接。

 

因此，网络IO故障可能仅仅因为客户端已断开连接而发生，这可能会使用不必要的堆栈跟踪填充日志。Spring尽最大努力识别代表客户端断开连接（特定于每个服务器）的网络故障，并使用中DISCONNECTED_CLIENT_LOG_CATEGORY 定义的专用日志类别记录最小消息AbstractSockJsSession。如果需要查看堆栈跟踪，请将该日志类别设置为TRACE。

4.3.6。SockJS和CORS

如果允许跨源请求（请参阅允许的来源），则SockJS协议使用CORS在XHR流和轮询传输中进行跨域支持。因此，除非检测到响应中存在CORS头，否则将自动添加CORS头。因此，如果应用程序已配置为提供CORS支持，例如通过Servlet过滤器，Spring的SockJsService将跳过此部分。

也可以通过suppressCorsSpring的SockJsService中的属性禁用这些CORS头 的添加。

以下是SockJS预期的标题和值列表：

  • "Access-Control-Allow-Origin" - 从“Origin”请求标头的值初始化。

  • "Access-Control-Allow-Credentials"- 始终设置为true。

  • "Access-Control-Request-Headers" - 从等效请求标头中的值初始化。

  • "Access-Control-Allow-Methods"- 传输支持的HTTP方法（参见TransportTypeenum）。

  • "Access-Control-Max-Age" - 设置为31536000（1年）。

对于确切的执行看到addCorsHeaders的AbstractSockJsService还有TransportType在源代码中枚举。

或者，如果CORS配置允许它考虑使用SockJS端点前缀排除URL，从而让Spring SockJsService处理它。

4.3.7。SockJsClient

提供了SockJS Java客户端，以便在不使用浏览器的情况下连接到远程SockJS端点。当需要通过公共网络在2个服务器之间进行双向通信时，即在网络代理可能妨碍使用WebSocket协议的情况下，这尤其有用。SockJS Java客户端对于测试目的也非常有用，例如模拟大量并发用户。

SockJS Java客户端支持“websocket”，“xhr-streaming”和“xhr-polling”传输。其余的仅适用于浏览器。

的WebSocketTransport可被配置成与：

  • StandardWebSocketClient 在JSR-356运行时中

  • JettyWebSocketClient 使用Jetty 9+本机WebSocket API

  • Spring的任何实现 WebSocketClient

根据XhrTransport定义，支持“xhr-streaming”和“xhr-polling”，因为从客户端的角度来看，除了用于连接服务器的URL之外没有其他区别。目前有两种实现方式：

  • RestTemplateXhrTransport使用Spring的RestTemplateHTTP请求。

  • JettyXhrTransport使用Jetty的HttpClientHTTP请求。

下面的示例显示了如何创建SockJS客户端并连接到SockJS端点：

List transports = new ArrayList<>(2);
transports.add(new WebSocketTransport(new StandardWebSocketClient()));
transports.add(new RestTemplateXhrTransport());

SockJsClient sockJsClient = new SockJsClient(transports);
sockJsClient.doHandshake(new MyWebSocketHandler(), "ws://example.com:8080/sockjs");
 

SockJS使用JSON格式的数组进行消息传递。默认使用Jackson 2并且需要在类路径上。或者，您可以配置自定义实现SockJsMessageCodec并在其上进行配置SockJsClient。

要使用SockJsClient模拟大量并发用户，您需要配置底层HTTP客户端（用于XHR传输）以允许足够数量的连接和线程。例如Jetty：

HttpClient jettyHttpClient = new HttpClient();
jettyHttpClient.setMaxConnectionsPerDestination(1000);
jettyHttpClient.setExecutor(new QueuedThreadPool(1000));

还要考虑自定义这些服务器端SockJS相关属性（有关详细信息，请参阅Javadoc）：

@Configuration
public class WebSocketConfig extends WebSocketMessageBrokerConfigurationSupport {

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/sockjs").withSockJS()
            .setStreamBytesLimit(512 * 1024)
            .setHttpMessageCacheSize(1000)
            .setDisconnectDelay(30 * 1000);
    }

    // ...
}

4.4。STOMP

WebSocket协议定义了两种类型的消息，文本和二进制，但它们的内容是未定义的。定义了客户端和服务器协商子协议的机制 - 即更高级别的消息传递协议，在WebSocket之上使用以定义每个消息可以发送什么类型的消息，每个消息的格式和内容是什么，等等上。子协议的使用是可选的，但无论是客户端还是服务器都需要就定义消息内容的某些协议达成一致。

4.4.1。概观

STOMP是一种简单的，面向文本的消息传递协议，最初是为Ruby，Python和Perl等脚本语言创建的，用于连接企业消息代理。它旨在解决常用消息传递模式的最小子集。STOMP可用于任何可靠的双向流网络协议，如TCP和WebSocket。虽然STOMP是面向文本的协议，但消息有效负载可以是文本或二进制。

STOMP是一种基于帧的协议，其帧在HTTP上建模。STOMP框架的结构：

命令
头1：VALUE1
标题2：VALUE2

车身^ @

客户端可以使用SEND或SUBSCRIBE命令发送或订阅消息以及“目标”标头，该标头描述消息的内容以及应由谁接收消息。这启用了一个简单的发布 - 订阅机制，可用于通过代理将消息发送到其他连接的客户端，或者向服务器发送消息以请求执行某些工作。

使用Spring的STOMP支持时，Spring WebSocket应用程序充当客户端的STOMP代理。消息被路由到@Controller消息处理方法或简单的内存中间代理，该代理跟踪订阅并向订阅用户广播消息。您还可以将Spring配置为使用专用的STOMP代理（例如RabbitMQ，ActiveMQ等）来实现消息的实际广播。在这种情况下，Spring维护与代理的TCP连接，向其中继消息，并将消息从其传递到连接的WebSocket客户端。因此，Spring Web应用程序可以依赖于基于HTTP的统一安全性，通用验证以及熟悉的编程模型消息处理工作。

以下是订阅接收股票报价的客户的示例，服务器可以例如通过计划任务通过a SimpMessagingTemplate向经纪人发送消息来周期性地发出报价：

订阅
ID：分1
目的地：/topic/price.stock.*

^ @

以下是客户端发送交易请求的示例，服务器可以通过该@MessageMapping方法处理该交易请求，之后，在执行之后，向客户端广播交易确认消息和详细信息：

发送
目的地：/队列/贸易
内容类型：application / JSON
内容长度：44

{ “动作”： “买入”， “股票”： “MMM”， “股份”，44} ^ @

在STOMP规范中故意将目的地的含义保持不透明。它可以是任何字符串，完全取决于STOMP服务器，以定义它们支持的目标语义和语法。然而，很常见的是，目标是类似路径的字符串，其中"/topic/.."暗示发布 - 订阅（一对多）并且"/queue/"暗示点对点（一对一）消息交换。

STOMP服务器可以使用MESSAGE命令向所有订户广播消息。以下是服务器向订阅客户端发送股票报价的示例：

信息
消息ID：nxahklf6-1
订阅：分1
目的地：/topic/price.stock.MMM

{ “股票”： “MMM”， “价格”：129.45} ^ @

知道服务器无法发送未经请求的消息非常重要。来自服务器的所有消息必须响应特定的客户端订阅，并且服务器消息的“subscription-id”头必须与客户端订阅的“id”头匹配。

以上概述旨在提供对STOMP协议的最基本的了解。建议完整地查看协议 规范。

4.4.2。优点

使用STOMP作为子协议使Spring Framework和Spring Security能够提供比使用原始WebSocket更丰富的编程模型。关于HTTP与原始TCP的关系以及它如何使Spring MVC和其他Web框架能够提供丰富的功能，可以做出同样的观点。以下是一系列好处：

  • 无需发明自定义消息传递协议和消息格式。

  • 可以使用STOMP客户端，包括 Spring Framework中的Java客户端。

  • 可以使用诸如RabbitMQ，ActiveMQ等消息代理（可选）来管理订阅和广播消息。

  • 应用程序逻辑可以@Controller根据STOMP目标标头与处理原始WebSocket消息的任意数量的消息和消息进行组织，其中单个WebSocketHandler用于给定连接。

  • 使用Spring Security根据STOMP目标和消息类型保护消息。

4.4.3。启用S​​TOMP

STOMP在WebSocket的支持是可用的spring-messaging和 spring-websocket模块。一旦拥有了这些依赖项，就可以通过带有SockJS Fallback的 WebSocket公开STOMP端点，如下所示：

import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/portfolio").withSockJS();  
    }

    @Override
    public void configureMessageBroker(MessageBrokerRegistry config) {
        config.setApplicationDestinationPrefixes("/app"); 
        config.enableSimpleBroker("/topic", "/queue"); 
    }
}
  "/portfolio" 是WebSocket（或SockJS）客户端需要连接到的端点的HTTP URL，以进行WebSocket握手。
  目标头开头的STOMP消息"/app"将路由到 类中的@MessageMapping方法@Controller。
  使用内置的消息代理进行订阅和广播; 将目标标头以“/ topic”或“/ queue”开头的邮件路由到代理。

XML中的相同配置：

 xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:websocket="http://www.springframework.org/schema/websocket"
    xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/websocket http://www.springframework.org/schema/websocket/spring-websocket.xsd">

     application-destination-prefix="/app">
         path="/portfolio">
            />
        
         prefix="/topic, /queue"/>
 

对于内置的简单代理，“/ topic”和“/ queue”前缀没有任何特殊含义。它们仅仅是区分pub-sub和点对点消息传递的惯例（即许多订阅者与一个消费者）。使用外部代理时，请检查代理的STOMP页面，以了解它支持的STOMP目标和前缀类型。

要从浏览器连接，对于SockJS，您可以使用 sockjs-client。对于STOMP，许多应用程序使用了jmesnil / stomp-websocket库（也称为stomp.js），该库功能齐全，已在生产中使用多年，但不再维护。目前， JSteunou / webstomp-client是该库中最活跃的维护和不断发展的后继者，下面的示例代码基于它：

var socket = new SockJS("/spring-websocket-portfolio/portfolio");
var stompClient = webstomp.over(socket);

stompClient.connect({}, function(frame) {
}

或者如果通过WebSocket连接（没有SockJS）：

var socket = new WebSocket("/spring-websocket-portfolio/portfolio");
var stompClient = Stomp.over(socket);

stompClient.connect({}, function(frame) {
}

请注意，stompClient上面不需要指定login和passcode标题。即使它确实如此，它们也会在服务器端被忽略或被覆盖。有关身份验证的详细信息，请参阅“ 连接到代理和 身份验证”部分。

有关更多示例代码，请参阅：

  • 使用WebSocket构建交互式Web应用程序入门指南。

  • 股票组合样本申请。

4.4.4。消息流

一旦暴露了STOMP端点，Spring应用程序就成为连接客户端的STOMP代理。本节介绍服务器端的消息流。

该spring-messaging模块包含对源自Spring Integration的消息传递应用程序的基础支持，后来被提取并整合到Spring Framework中，以便在许多Spring项目和应用程序场景中得到更广泛的使用 。下面列出了一些可用的消息传递抽象：

  • 消息  - 包含标头和有效负载的消息的简单表示。

  • MessageHandler  - 处理消息的合同。

  • MessageChannel  - 发送消息的合同，该消息支持生产者和消费者之间的松散耦合。

  • SubscribableChannel  -  MessageChannel与MessageHandler订阅者。

  • ExecutorSubscribableChannel  -  SubscribableChannel使用的Executor邮件传递。

Java配置（即@EnableWebSocketMessageBroker）和XML命名空间配置（即）都使用上述组件来组装消息工作流。下图显示了启用简单的内置消息代理时使用的组件：

上图中有3个消息通道：

  • "clientInboundChannel" - 用于传递从WebSocket客户端收到的消息。

  • "clientOutboundChannel" - 用于向WebSocket客户端发送服务器消息。

  • "brokerChannel" - 用于从服务器端的应用程序代码向消息代理发送消息。

下图显示了配置外部代理（例如RabbitMQ）以管理订阅和广播消息时使用的组件：

上图中的主要区别是使用“代理中继”通过TCP将消息传递到外部STOMP代理，以及将消息从代理传递到订阅的客户端。

当从WebSocket connectin接收消息时，它们被解码为STOMP帧，然后变成Spring Message表示，并发送到"clientInboundChannel"进行进一步处理。例如STOMP消息，其目的地标题开头"/app"可被路由到@MessageMapping在注释的控制器的方法，而"/topic"和"/queue"消息可以被直接路由到消息代理。

@Controller从客户端处理STOMP消息的带注释的消息可以通过消息代理向消息代理发送消息"brokerChannel"，并且代理将通过消息向匹配的订阅者广播消息"clientOutboundChannel"。相同的控制器也可以响应HTTP请求执行相同的操作，因此客户端可以执行HTTP POST，然后@PostMapping方法可以向消息代理发送消息以向订阅的客户端广播。

让我们通过一个简单的例子来追踪流程。鉴于以下服务器设置：

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/portfolio");
    }

    @Override
    public void configureMessageBroker(MessageBrokerRegistry registry) {
        registry.setApplicationDestinationPrefixes("/app");
        registry.enableSimpleBroker("/topic");
    }

}

@Controller
public class GreetingController {

    @MessageMapping("/greeting") {
    public String handle(String greeting) {
        return "[" + getTimestamp() + ": " + greeting;
    }

}

  1. 客户端连接到，"http://localhost:8080/portfolio"并且一旦建立了WebSocket连接，STOMP帧就开始在其上流动。

  2. 客户端发送带有目标头的SUBSCRIBE帧"/topic/greeting"。一旦接收并解码，消息就被发送到"clientInboundChannel"，然后路由到存储客户端订阅的消息代理。

  3. 客户端发送SEND帧"/app/greeting"。该"/app"前缀有助于它的路线注解控制器。"/app"删除前缀后，目标的剩余"/greeting"部分将映射到@MessageMapping方法中GreetingController。

  4. 返回的值GreetingController将转换为Spring Message，其有效负载基于返回值和默认目标标头 "/topic/greeting"（从输入目标派生，"/app"替换为 "/topic"）。生成的消息将发送到“brokerChannel”并由消息代理处理。

  5. 消息代理找到所有匹配的订户，并通过"clientOutboundChannel"from将消息编码为STOMP帧并在WebSocket连接上发送的每个发送MESSAGE帧。

下一节提供了有关注释方法的更多详细信息，包括支持的参数类型和返回值。

4.4.5。带注释的控制器

应用程序可以使用带注释的@Controller类来处理来自客户端的消息。这些类可以声明@MessageMapping，@SubscribeMapping和@ExceptionHandler 方法，如下所述。

@MessageMapping

该@MessageMapping批注可在方法基于他们的目的地将消息路由使用。它在方法级别和类型级别受支持。在类型级别@MessageMapping用于表示控制器中所有方法的共享映射。

默认情况下，目标映射应为Ant样式的路径模式，例如“/ foo *”，“/ foo / **”。模式包括对模板变量的支持，例如“/ foo / {id}”，可以使用@DestinationVariable方法参数引用。

 

应用程序可以选择切换到以点分隔的目标约定。请参见Dot as Separator。

@MessageMapping 方法可以使用以下参数进行灵活签名：

方法参数 描述

Message

用于访问完整的消息。

MessageHeaders

用于访问内部的标头Message。

MessageHeaderAccessor，SimpMessageHeaderAccessor，StompHeaderAccessor

用于通过类型化访问器方法访问标头。

@Payload

用于访问消息的有效负载，通过配置转换（例如，从JSON）MessageConverter。

不需要存在此注释，因为如果没有其他参数匹配，则默认采用它。

Payload参数可以使用@javax.validation.Valid或Spring 注释，@Validated 以便自动验证。

@Header

用于访问特定标头值以及使用org.springframework.core.convert.converter.Converter必要时的类型转换 。

@Headers

用于访问消息中的所有标头。此参数必须可分配给java.util.Map。

@DestinationVariable

用于访问从消息目标中提取的模板变量。必要时，值将转换为声明的方法参数类型。

java.security.Principal

反映WebSocket HTTP握手时登录的用户。

当@MessageMapping方法返回一个值时，默认情况下，该值通过已配置的序列化为有效负载MessageConverter，然后作为a发送Message到 "brokerChannel"它向订阅者广播的位置。出站消息的目的地与入站消息的目的地相同，但前缀为"/topic"。

您可以使用@SendTo方法批注来自定义要将有效负载发送到的目标。@SendTo也可以在类级别使用以共享发送消息的默认目标目标。@SendToUser是仅向与消息关联的用户发送消息的变体。有关详细信息，请参阅用户目标

方法的返回值@MessageMapping可以用ListenableFuture， 包装CompletableFuture，或者CompletionStage以异步方式生成有效负载。

作为从@MessageMapping方法返回有效负载的替代方法，您还可以使用the发送消息SimpMessagingTemplate，这也是在封面下处理返回值的方式。请参阅发送消息。

@SubscribeMapping

的@SubscribeMapping注释结合使用@MessageMapping，以缩小的映射到订阅消息。在这种情况下，@MessageMapping 注释指定目的地，同时@SubscribeMapping仅指示对订阅消息的兴趣。

的@SubscribeMapping方法，通常是没有任何不同@MessageMapping 相对于映射和输入参数的方法。例如，您可以将它与类型级别组合@MessageMapping以表示共享目标前缀，并且可以使用与任何@ MessageMapping`方法相同的方法参数。

关键的区别@SubscribeMapping在于方法的返回值被序列化为有效载荷并且不是发送到“brokerChannel”而是发送到“clientOutboundChannel”，有效地直接回复到客户端而不是通过代理进行广播。这对于实现一次性请求 - 回复消息交换非常有用，并且永远不会保留订阅。此模式的常见方案是在必须加载和显示数据时应用程序初始化。

阿@SubscribeMapping与也可以注释的方法@SendTo在这种情况下的返回值发送到"brokerChannel"与所述显式指定的目标目的地。

@MessageExceptionHandler

应用程序可以使用@MessageExceptionHandler方法来处理方法中的异常 @MessageMapping。感兴趣的异常可以在注释本身中声明，或者如果要获取对异常实例的访问权限，则可以通过方法参数声明：

@Controller
public class MyController {

    // ...

    @MessageExceptionHandler
    public ApplicationError handleException(MyException exception) {
        // ...
        return appError;
    }
}

@MessageExceptionHandler方法支持灵活的方法签名，并支持相同的方法参数类型和返回值作为@MessageMapping方法。

通常，@MessageExceptionHandler方法适用于@Controller声明它们的类（或类层次结构）。如果您希望这些方法在控制器之间全局应用，则可以在标记为的类中声明它们@ControllerAdvice。这与Spring MVC中的类似支持相当。

4.4.6。发送信息

如果要从应用程序的任何部分向连接的客户端发送消息，该怎么办？任何应用程序组件都可以向其发送消息"brokerChannel"。最简单的方法是SimpMessagingTemplate注入，并使用它来发送消息。通常，应该很容易按类型注入，例如：

@Controller
public class GreetingController {

    private SimpMessagingTemplate template;

    @Autowired
    public GreetingController(SimpMessagingTemplate template) {
        this.template = template;
    }

    @RequestMapping(path="/greetings", method=POST)
    public void greet(String greeting) {
        String text = "[" + getTimestamp() + "]:" + greeting;
        this.template.convertAndSend("/topic/greetings", text);
    }

}

但如果存在相同类型的另一个bean，它也可以通过其名称“brokerMessagingTemplate”进行限定。

4.4.7。简单的经纪人

内置的简单消息代理处理来自客户端的订阅请求，将它们存储在内存中，并将消息广播到具有匹配目标的连接客户端。代理支持类似路径的目标，包括对Ant样式目标模式的订阅。

 

应用程序也可以使用点分隔目标（vs斜杠）。请参见Dot as Separator。

4.4.8。外部经纪人

简单的代理非常适合入门，但仅支持STOMP命令的子集（例如，没有ack，收据等），依赖于简单的消息发送循环，并且不适合于群集。作为替代方案，应用程序可以升级到使用功能齐全的消息代理。

检查STOMP文档以查找您选择的消息代理（例如 RabbitMQ， ActiveMQ等），安装代理，并在启用STOMP支持的情况下运行它。然后在Spring配置中启用STOMP代理中继而不是简单代理。

以下是启用功能齐全的代理的示例配置：

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/portfolio").withSockJS();
    }

    @Override
    public void configureMessageBroker(MessageBrokerRegistry registry) {
        registry.enableStompBrokerRelay("/topic", "/queue");
        registry.setApplicationDestinationPrefixes("/app");
    }

}

XML配置等效：

 xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:websocket="http://www.springframework.org/schema/websocket"
    xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/websocket http://www.springframework.org/schema/websocket/spring-websocket.xsd">

     application-destination-prefix="/app">
         path="/portfolio" />
            />
        
         prefix="/topic,/queue" />

上述配置中的“STOMP代理中继”是Spring MessageHandler ，它通过将消息转发到外部消息代理来处理消息。为此，它建立到代理的TCP连接，将所有消息转发给它，然后通过其WebSocket会话将从代理接收的所有消息转发给客户端。从本质上讲，它充当“转发”，可以在两个方向上转发消息。

 

请 为项目添加io.projectreactor.ipc:reactor-netty和io.netty:netty-all依赖项以进行TCP连接管理。

此外，应用程序组件（例如HTTP请求处理方法，业务服务等）也可以向代理中继发送消息，如发送消息中所述，以便向订阅的WebSocket客户端广播消息。

实际上，代理中继实现了健壮且可扩展的消息广播。

4.4.9。连接到经纪人

STOMP代理中继维护与代理的单个“系统”TCP连接。此连接仅用于源自服务器端应用程序的消息，而不用于接收消息。您可以为此连接配置STOMP凭据，即STOMP帧login和passcode标头。这在XML命名空间和Java配置中都显示为具有默认值/ 的 systemLogin/ systemPasscodeproperties 。guestguest

STOMP代理中继还为每个连接的WebSocket客户端创建单独的TCP连接。您可以配置STOMP凭据以用于代表客户端创建的所有TCP连接。这在XML命名空间和Java配置中都显示为具有默认值/ 的clientLogin/ clientPasscodeproperties 。guestguest

 

STOMP代理中继始终 在代表客户端转发给代理的每个帧上设置login和passcode标头CONNECT。因此，WebSocket客户端无需设置这些标头; 他们会被忽略。正如身份验证 部分所述，WebSocket客户端应该依赖HTTP身份验证来保护WebSocket端点并建立客户端身份。

STOMP代理中继还通过“系统”TCP连接向消息代理发送和接收心跳。您可以配置发送和接收心跳的间隔（默认情况下每个10秒）。如果与代理的连接丢失，代理中继将继续尝试每5秒重新连接一次，直到成功为止。

任何Spring bean都可以实现ApplicationListener，以便在与代理的“系统”连接丢失并重新建立时接收通知。例如，股票报价服务广播股票报价可以在没有活动的“系统”连接时停止尝试发送消息。

默认情况下，STOMP代理中继始终连接，并在连接丢失时根据需要重新连接到同一主机和端口。如果您希望提供多个地址，则在每次尝试连接时，您都可以配置地址供应商，而不是固定的主机和端口。例如：

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig extends AbstractWebSocketMessageBrokerConfigurer {

    // ...

    @Override
    public void configureMessageBroker(MessageBrokerRegistry registry) {
        registry.enableStompBrokerRelay("/queue/", "/topic/").setTcpClient(createTcpClient());
        registry.setApplicationDestinationPrefixes("/app");
    }

    private ReactorNettyTcpClient<byte[]> createTcpClient() {

        Consumer> builderConsumer = builder -> {
            builder.connectAddress(()-> {
                // Select address to connect to ...
            });
        };

        return new ReactorNettyTcpClient<>(builderConsumer, new StompReactorNettyCodec());
    }
}

STOMP代理中继也可以配置virtualHost属性。该属性的值将被设置为host每个CONNECT帧的标题，并且可能在例如云环境中是有用的，其中建立TCP连接的实际主机与提供基于云的STOMP服务的主机不同。

4.4.10。点作为分隔符

当消息路由到@MessageMapping方法时，它们会匹配， AntPathMatcher默认情况下，模式应使用斜杠“/”作为分隔符。这是Web应用程序中的一个很好的约定，类似于HTTP URL。但是，如果您更习惯于消息传递约定，则可以切换到使用点“。” 作为分隔符。

在Java配置中：

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    // ...

    @Override
    public void configureMessageBroker(MessageBrokerRegistry registry) {
        registry.setPathMatcher(new AntPathMatcher("."));
        registry.enableStompBrokerRelay("/queue", "/topic");
        registry.setApplicationDestinationPrefixes("/app");
    }
}

在XML中：

 xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:websocket="http://www.springframework.org/schema/websocket"
        xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/websocket http://www.springframework.org/schema/websocket/spring-websocket.xsd">

     application-destination-prefix="/app" path-matcher="pathMatcher">
         path="/stomp"/>
         prefix="/topic,/queue" />
    

      id="pathMatcher" class="org.springframework.util.AntPathMatcher">  index="0" value="."/>

之后，控制器可以使用点“。” 作为@MessageMapping方法中的分隔符：

@Controller
@MessageMapping("foo")
public class FooController {

    @MessageMapping("bar.{baz}")
    public void handleBaz(@DestinationVariable String baz) {
        // ...
    }
}

客户端现在可以向其发送消息"/app/foo.bar.baz123"。

在上面的示例中，我们没有更改“代理中继”上的前缀，因为它们完全依赖于外部消息代理。检查您正在使用的代理的STOMP文档页面，以查看它为目标标头支持的约定。

另一方面，“简单代理”确实依赖于配置，PathMatcher因此如果您切换也将应用于代理的分隔符，并且将消息中的目标与订阅中的模式匹配。

4.4.11。认证

WebSocket消息传递会话中的每个STOMP都以HTTP请求开始 - 可以是升级到WebSockets的请求（即WebSocket握手），或者在SockJS回退一系列SockJS HTTP传输请求的情况下。

Web应用程序已经具有用于保护HTTP请求的身份验证和授权。通常，用户通过Spring Security使用某种机制（例如登录页面，HTTP基本身份验证或其他）进行身份验证。经过身份验证的用户的安全上下文保存在HTTP会话中，并与同一个基于cookie的会话中的后续请求相关联。

因此，对于WebSocket握手或SockJS HTTP传输请求，通常会有可通过身份验证的用户访问HttpServletRequest#getUserPrincipal()。Spring自动将该用户与为其创建的WebSocket或SockJS会话相关联，随后通过用户头与该会话上传输的所有STOMP消息相关联。

简而言之，典型的Web应用程序不需要做任何特殊的事情，而不仅仅是它已经为安全做的事情。用户在HTTP请求级别进行身份验证，并通过基于cookie的HTTP会话维护安全上下文，然后将该会话与为该用户创建的WebSocket或SockJS会话相关联，并在每次Message流经应用程序时生成用户标头。

请注意，STOMP协议在CONNECT帧上具有“登录”和“密码”标头。这些最初设计用于并且仍然需要例如用于TCP上的STOMP。但是，对于STOMP over WebSocket，Spring默认忽略STOMP协议级别的授权标头，并假定用户已在HTTP传输级别进行了身份验证，并期望WebSocket或SockJS会话包含经过身份验证的用户。

 

Spring Security提供 WebSocket子协议授权 ，该授权使用a ChannelInterceptor根据其中的用户头来授权消息。此外，Spring Session还提供 WebSocket集成 ，以确保在WebSocket会话仍处于活动状态时，用户HTTP会话不会过期。

4.4.12。令牌认证

Spring Security OAuth 支持基于令牌的安全性，包括JSON Web Token（JWT）。这可以用作Web应用程序中的身份验证机制，包括STOMP over WebSocket交互，就像上一节中所述，即通过基于cookie的会话维护身份。

同时，基于cookie的会话并不总是最适合，例如在不希望完全维护服务器端会话的应用程序中，或者在通常使用标头进行身份验证的移动应用程序中。

该WebSocket协议RFC 6455 “没有规定该服务器可以在WebSocket的握手过程中验证客户端的任何特定的方式。” 实际上，浏览器客户端只能使用标准身份验证标头（即基本HTTP身份验证）或cookie，并且不能提供自定义标头。同样，SockJS JavaScript客户端不提供使用SockJS传输请求发送HTTP头的方法，请参阅 sockjs-client问题196。相反，它确实允许发送可用于发送令牌但具有其自身缺点的查询参数，例如因为令牌可能无意中使用服务器日志中的URL进行了记录。

 

上述限制适用于基于浏览器的客户端，不适用于基于Spring Java的STOMP客户端，该客户端支持使用WebSocket和SockJS请求发送标头。

因此，希望避免使用cookie的应用程序可能无法在HTTP协议级别进行身份验证。他们可能更喜欢在STOMP消息传递协议级别使用标头进行身份验证，而不是使用Cookie。有两个简单的步骤可以做到这一点：

  1. 使用STOMP客户端在连接时传递身份验证标头。

  2. 使用a处理身份验证标头ChannelInterceptor。

下面是注册自定义身份验证拦截器的示例服务器端配置。请注意，拦截器只需要在CONNECT上进行身份验证并设置用户头Message。Spring将记录并保存经过身份验证的用户，并将其与同一会话中的后续STOMP消息相关联：

@Configuration
@EnableWebSocketMessageBroker
public class MyConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void configureClientInboundChannel(ChannelRegistration registration) {
        registration.setInterceptors(new ChannelInterceptorAdapter() {
            @Override
            public Message preSend(Message message, MessageChannel channel) {
                StompHeaderAccessor accessor =
                        MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
                if (StompCommand.CONNECT.equals(accessor.getCommand())) {
                    Authentication user = ... ; // access authentication header(s)
                    accessor.setUser(user);
                }
                return message;
            }
        });
    }
}

另请注意，在使用Spring Security的邮件授权时，您需要确保在ChannelInterceptorSpring Security之前订购身份验证配置。最好通过在自己的WebSocketMessageBrokerConfigurer标记为 的实现中声明自定义拦截器来完成@Order(Ordered.HIGHEST_PRECEDENCE + 99)。

4.4.13。用户目的地

应用程序可以发送针对特定用户的消息，Spring的STOMP支持可识别"/user/"为此目的而作为前缀的目标。例如，客户端可能订阅目标"/user/queue/position-updates"。该目的地将由该处理UserDestinationMessageHandler并且转换为用户会话唯一的目的地，例如"/queue/position-updates-user123"。这提供了订阅一般命名的目的地的便利性，同时确保不与订阅相同目的地的其他用户发生冲突，使得每个用户可以接收唯一的库存位置更新。

在发送侧，可以将消息发送到目的地，例如"/user/{username}/queue/position-updates"，该目的地 将由UserDestinationMessageHandler一个或多个目的地翻译，一个目的地用于与用户相关联的每个会话。这允许应用程序中的任何组件发送针对特定用户的消息，而不必知道除其名称和通用目标之外的任何内容。通过注释和消息传递模板也支持这一点。

例如，消息处理方法可以向与通过@SendToUser注释处理的消息相关联的用户发送消息（在类级别上也支持共享公共目的地）：

@Controller
public class PortfolioController {

    @MessageMapping("/trade")
    @SendToUser("/queue/position-updates")
    public TradeResult executeTrade(Trade trade, Principal principal) {
        // ...
        return tradeResult;
    }
}

如果用户具有多个会话，则默认情况下，所有订阅给定目标的会话都是目标。但是，有时可能需要仅定位发送正在处理的消息的会话。这可以通过将broadcast属性设置为false 来完成，例如：

@Controller
public class MyController {

    @MessageMapping("/action")
    public void handleAction() throws Exception{
        // raise MyBusinessException here
    }

    @MessageExceptionHandler
    @SendToUser(destinations="/queue/errors", broadcast=false)
    public ApplicationError handleException(MyBusinessException exception) {
        // ...
        return appError;
    }
}
 

虽然用户目的地通常意味着经过身份验证的用户，但并不严格要求。与经过身份验证的用户无关的WebSocket会话可以订阅用户目标。在这种情况下，@SendToUser注释的行为与其完全相同broadcast=false，即仅定位发送正在处理的消息的会话。

例如，还可以通过注入SimpMessagingTemplate由Java配置或XML命名空间创建的消息，从任何应用程序组件向用户目标发送消息（"brokerMessagingTemplate"如果需要，则bean名称是必需的@Qualifier）：

@Service
public class TradeServiceImpl implements TradeService {

    private final SimpMessagingTemplate messagingTemplate;

    @Autowired
    public TradeServiceImpl(SimpMessagingTemplate messagingTemplate) {
        this.messagingTemplate = messagingTemplate;
    }

    // ...

    public void afterTradeExecuted(Trade trade) {
        this.messagingTemplate.convertAndSendToUser(
                trade.getUserName(), "/queue/position-updates", trade.getResult());
    }
}
 

将用户目标与外部消息代理一起使用时，请检查代理文档，了解如何管理非活动队列，以便在用户会话结束时删除所有唯一用户队列。例如，当使用目的地时，RabbitMQ会创建自动删除队列/exchange/amq.direct/position-updates。所以在那种情况下客户可以订阅/user/exchange/amq.direct/position-updates。同样，ActiveMQ具有 用于清除非活动目标的配置选项。

在多应用程序服务器方案中，用户目标可能仍未解析，因为用户连接到不同的服务器。在这种情况下，您可以配置目标以广播未解析的消息，以便其他服务器有机会尝试。这可以通过做userDestinationBroadcast财产 MessageBrokerRegistry在Java中的配置和user-destination-broadcast该属性message-broker的XML元素。

4.4.14。事件和拦截

发布了几个ApplicationContext事件（如下所列），可以通过实现Spring的ApplicationListener接口来接收。

  • BrokerAvailabilityEvent - 表示经纪人何时可用/不可用。虽然“简单”代理在启动时立即可用，并且在应用程序运行时仍然如此，但STOMP“代理中继”可能会丢失与全功能代理的连接，例如，如果代理重新启动。代理中继具有重新连接逻辑，并在它返回时重新建立与代理的“系统”连接，因此只要状态从连接变为断开连接，反之亦然，就会发布此事件。使用该组件的组件SimpMessagingTemplate应订阅此事件，并避免在代理不可用时发送消息。在任何情况下，他们都应该准备好在MessageDeliveryException 发送消息时进行处理。

  • SessionConnectEvent - 在收到新的STOMP CONNECT时发布，指示新客户端会话的开始。该事件包含表示连接的消息，包括会话ID，用户信息（如果有）以及客户端可能已发送的任何自定义标头。这对于跟踪客户端会话很有用。订阅此事件的组件可以使用SimpMessageHeaderAccessor或 包装所包含的消息StompMessageHeaderAccessor。

  • SessionConnectedEvent - SessionConnectEvent在经纪人发送STOMP CONNECTED框架以响应CONNECT 之后不久发布的。此时，可以认为STOMP会话已完全建立。

  • SessionSubscribeEvent - 在收到新的STOMP SUBSCRIBE时发布。

  • SessionUnsubscribeEvent - 收到新的STOMP UNSUBSCRIBE时发布。

  • SessionDisconnectEvent - 在STOMP会话结束时发布。DISCONNECT可能已从客户端发送，也可能在WebSocket会话关闭时自动生成。在某些情况下，每个会话可能会多次发布此事件。对于多个断开连接事件，组件应该是幂等的。

 

使用功能齐全的代理时，STOMP“代理中继”会自动重新连接“系统”连接，以防代理暂时不可用。但是，客户端连接不会自动重新连接。假设启用了心跳，客户端通常会注意到代理在10秒内没有响应。客户端需要实现自己的重新连接逻辑。

上述事件反映了STOMP连接生命周期中的点。它们并不意味着为客户端发送的每条消息提供通知。相反，应用程序可以注册a ChannelInterceptor来拦截每个传入和传出的STOMP消息。例如，拦截入站消息：

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void configureClientInboundChannel(ChannelRegistration registration) {
        registration.setInterceptors(new MyChannelInterceptor());
    }
}

自定义ChannelInterceptor可以使用StompHeaderAccessor或SimpMessageHeaderAccessor 访问有关邮件的信息。

public class MyChannelInterceptor extends ChannelInterceptorAdapter {

    @Override
    public Message preSend(Message message, MessageChannel channel) {
        StompHeaderAccessor accessor = StompHeaderAccessor.wrap(message);
        StompCommand command = accessor.getStompCommand();
        // ...
        return message;
    }
}

请注意，与SesionDisconnectEvent上面一样，可能已从客户端发送DISCONNECT消息，或者也可能在WebSocket会话关闭时自动生成。在某些情况下，拦截器可能会在每个会话中多次拦截此消息。对于多个断开连接事件，组件应该是幂等的。

4.4.15。STOMP客户端

Spring通过WebSocket客户端提供STOMP，通过TCP客户端提供STOMP。

要开始创建和配置WebSocketStompClient：

WebSocketClient webSocketClient = new StandardWebSocketClient();
WebSocketStompClient stompClient = new WebSocketStompClient(webSocketClient);
stompClient.setMessageConverter(new StringMessageConverter());
stompClient.setTaskScheduler(taskScheduler); // for heartbeats

在上面的例子StandardWebSocketClient可以替换为，SockJsClient 因为这也是一个实现WebSocketClient。所述SockJsClient可以使用的WebSocket或基于HTTP的传输作为后备。有关更多详细信息，请参阅 SockJsClient。

接下来建立连接并为STOMP会话提供处理程序：

String url = "ws://127.0.0.1:8080/endpoint";
StompSessionHandler sessionHandler = new MyStompSessionHandler();
stompClient.connect(url, sessionHandler);

当会话准备好使用时，会通知处理程序：

public class MyStompSessionHandler extends StompSessionHandlerAdapter {

    @Override
    public void afterConnected(StompSession session, StompHeaders connectedHeaders) {
        // ...
    }
}

建立会话后，可以发送任何有效负载，并使用配置的序列化MessageConverter：

session.send("/topic/foo", "payload");

您也可以订阅目的地。这些subscribe方法需要处理订阅消息的处理程序，并返回Subscription可用于取消订阅的句柄。对于每个收到的消息，处理程序可以指定有效负载应该反序列化的目标对象类型：

session.subscribe("/topic/foo", new StompFrameHandler() {

    @Override
    public Type getPayloadType(StompHeaders headers) {
        return String.class;
    }

    @Override
    public void handleFrame(StompHeaders headers, Object payload) {
        // ...
    }

});

为了使STOMP心跳配置WebSocketStompClient有TaskScheduler 和任选定制心跳间隔10秒，其将导致一个心跳写入不活动待发送和10秒不活动读取其关闭连接。

 

当使用WebSocketStompClient性能测试来模拟来自同一台计算机的数千个客户端时，请考虑关闭心跳，因为每个连接都会调度自己的心跳任务，并且不会针对在同一台计算机上运行的大量客户端进行优化。

STOMP协议还支持收据，其中客户端必须添加“收据”标头，服务器在处理发送或订阅后用RECEIPT帧响应。为了支持这个StompSession提议 setAutoReceipt(boolean)导致要在以后每发送添加或订阅了“回执”标头。或者，您也可以手动添加“收据”标题StompHeaders。发送和订阅都返回一个实例Receiptable ，可用于注册接收成功和失败回调。对于此功能，客户端必须配置a TaskScheduler 和收据到期前的时间（默认为15秒）。

请注意，除了处理消息的异常回调以及传输级错误（包括）之外，它StompSessionHandler本身还StompFrameHandler允许它处理ERROR帧。handleExceptionhandleTransportErrorConnectionLostException

4.4.16。WebSocket范围

每个WebSocket会话都有一个属性映射。映射作为标头附加到入站客户端消息，并且可以从控制器方法访问，例如：

@Controller
public class MyController {

    @MessageMapping("/action")
    public void handle(SimpMessageHeaderAccessor headerAccessor) {
        Map<String, Object> attrs = headerAccessor.getSessionAttributes();
        // ...
    }
}

也可以在websocket作用域中声明一个Spring管理的bean 。WebSocket范围的bean可以注入控制器和“clientInboundChannel”上注册的任何通道拦截器。这些通常是单身，比任何单独的WebSocket会话都更长寿。因此，您需要为WebSocket范围的bean使用范围代理模式：

@Component
@Scope(scopeName = "websocket", proxyMode = ScopedProxyMode.TARGET_CLASS)
public class MyBean {

    @PostConstruct
    public void init() {
        // Invoked after dependencies injected
    }

    // ...

    @PreDestroy
    public void destroy() {
        // Invoked when the WebSocket session ends
    }
}

@Controller
public class MyController {

    private final MyBean myBean;

    @Autowired
    public MyController(MyBean myBean) {
        this.myBean = myBean;
    }

    @MessageMapping("/action")
    public void handle() {
        // this.myBean from the current WebSocket session
    }
}

与任何自定义作用域一样，Spring MyBean在第一次从控制器访问时初始化一个新实例，并将该实例存储在WebSocket会话属性中。随后返回相同的实例，直到会话结束。WebSocket范围的bean将调用所有Spring生命周期方法，如上面的示例所示。

4.4.17。性能

在性能方面没有银弹。许多因素可能会影响它，包括消息的大小，数量，应用程序方法是否执行需要阻止的工作，以及外部因素，如网络速度等。本部分的目标是提供可用配置选项的概述以及有关如何推理缩放的一些想法。

在消息传递应用程序中，消息通过用于由线程池支持的异步执行的通道传递。配置此类应用程序需要充分了解通道和消息流。因此，建议查看消息流。

显而易见的起点是配置支持"clientInboundChannel"和的线程池 "clientOutboundChannel"。默认情况下，两者都配置为可用处理器数量的两倍。

如果注释方法中的消息处理主要是CPU绑定的，则"clientInboundChannel"应该保持接近处理器数量的线程数。如果他们所做的工作更多是IO绑定并且需要阻塞或等待数据库或其他外部系统，则需要增加线程池大小。

 

ThreadPoolExecutor有3个重要的属性。这些是核心和最大线程池大小以及队列存储没有可用线程的任务的容量。

常见的混淆点是配置核心池大小（例如10）和最大池大小（例如20）导致具有10到20个线程的线程池。实际上，如果容量保留为其默认值Integer.MAX_VALUE，则线程池将永远不会超出核心池大小，因为所有其他任务都将排队。

请查看Javadoc，ThreadPoolExecutor了解这些属性如何工作并了解各种排队策略。

另一方面，"clientOutboundChannel"它是关于向WebSocket客户端发送消息。如果客户端位于快速网络上，则线程数应保持接近可用处理器的数量。如果它们很慢或带宽较低，则消耗消息所需的时间会更长，并给线程池带来负担。因此，增加线程池大小是必要的。

虽然“clientInboundChannel”的工作负载可以预测 - 毕竟它基于应用程序的工作 - 如何配置“clientOutboundChannel”更难，因为它基于应用程序无法控制的因素。因此，有两个与发送消息相关的附加属性。那些是"sendTimeLimit" 和"sendBufferSizeLimit"。这些用于配置允许发送多长时间以及在向客户端发送消息时可以缓冲多少数据。

一般的想法是，在任何给定时间，只有一个线程可用于发送给客户端。同时，所有其他消息都会被缓冲，您可以使用这些属性来决定允许发送消息的时间长度以及可以在平均时间内缓冲多少数据。有关重要的其他详细信息，请查看此配置的XML架构的Javadoc和文档。

以下是示例配置：

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void configureWebSocketTransport(WebSocketTransportRegistration registration) {
        registration.setSendTimeLimit(15 * 1000).setSendBufferSizeLimit(512 * 1024);
    }

    // ...

}
 xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:websocket="http://www.springframework.org/schema/websocket"
    xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/websocket http://www.springframework.org/schema/websocket/spring-websocket.xsd">

    
         send-timeout="15000" send-buffer-size="524288" />

上面显示的WebSocket传输配置还可用于配置传入STOMP消息的最大允许大小。虽然理论上WebSocket消息的大小几乎是无限的，但实际上WebSocket服务器会施加限制 - 例如，Tomcat上的8K和Jetty上的64K。因此，诸如JavaScript webstomp-client 等STOMP 客户端在16K边界处拆分较大的STOMP消息，并将它们作为多个WebSocket消息发送，因此需要服务器缓冲和重新组装。

Spring的STOMP over WebSocket支持这样做，因此应用程序可以配置STOMP消息的最大大小，而不管WebSocket服务器特定的消息大小。请记住，必要时将自动调整WebSocket消息大小，以确保它们至少可以携带16K WebSocket消息。

以下是示例配置：

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void configureWebSocketTransport(WebSocketTransportRegistration registration) {
        registration.setMessageSizeLimit(128 * 1024);
    }

    // ...

}
 xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:websocket="http://www.springframework.org/schema/websocket"
    xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/websocket http://www.springframework.org/schema/websocket/spring-websocket.xsd">

    
         message-size="131072" />

关于扩展的一个重点是使用多个应用程序实例。目前，使用简单代理无法做到这一点。但是，当使用RabbitMQ等功能齐全的代理时，每个应用程序实例都会连接到代理，并且从一个应用程序实例广播的消息可以通过代理广播到通过任何其他应用程序实例连接的WebSocket客户端。

4.4.18。监控

使用@EnableWebSocketMessageBroker或关键基础架构组件时，会自动收集统计信息和计数器，以便深入了解应用程序的内部状态。该配置还声明了一个类型的bean，WebSocketMessageBrokerStats它在一个地方收集所有可用信息，默认情况下INFO每30分钟将其记录一次。这个bean可以通过Spring导出到JMX MBeanExporter，以便在运行时查看，例如通过JDK jconsole。以下是可用信息的摘要。

客户端WebSocket会话

当前

表示当前有多少客户端会话，其中包括WebSocket与HTTP流和轮询SockJS会话进一步细分的计数。

总

表示已建立的会话总数。

异常关闭

连接失败

这些会话已经建立但在60秒内没有收到任何消息后关闭。这通常表示代理或网络问题。

超出发送限制

超过配置的发送超时或缓慢客户端可能发生的发送缓冲区限制后会话关闭（请参阅上一节）。

运输错误

在传输错误（例如无法读取或写入WebSocket连接或HTTP请求/响应）之后会话关闭。

STOMP框架

处理的CONNECT，CONNECTED和DISCONNECT帧总数，表示STOMP级别连接的客户端数量。请注意，当会话异常关闭或客户端关闭而不发送DISCONNECT帧时，DISCONNECT计数可能会更低。

STOMP经纪人接力

TCP连接

表示代表客户端WebSocket会话建立多少个TCP连接到代理。这应该等于客户端WebSocket会话的数量+ 1个用于从应用程序内发送消息的额外共享“系统”连接。

STOMP框架

代表客户端转发到代理或从代理接收的CONNECT，CONNECTED和DISCONNECT帧的总数。请注意，无论客户端WebSocket会话如何关闭，都会将DISCONNECT帧发送到代理。因此，较低的DISCONNECT帧计数表示代理主动关闭连接，可能是因为没有及时到达的心跳，无效的输入帧或其他。

客户端入站通道

来自线程池的统计信息支持“clientInboundChannel”，提供对传入消息处理的运行状况的深入了解。在此排队的任务表明应用程序可能太慢而无法处理消息。如果有I / O绑定任务（例如，慢速数据库查询，对第三方REST API的HTTP请求等），请考虑增加线程池大小。

客户出站频道

支持“clientOutboundChannel”的线程池中的统计信息，提供对客户端广播消息运行状况的深入了解。在此排队的任务表明客户端消耗消息的速度太慢。解决此问题的一种方法是增加线程池大小以适应预期的并发慢客户端数量。另一种选择是减少发送超时和发送缓冲区大小限制（参见上一节）。

SockJS任务计划程序

来自SockJS任务调度程序的线程池的统计信息，用于发送心跳。请注意，在STOMP级别协商心跳时，将禁用SockJS心跳。

4.4.19。测试

使用Spring的STOMP over WebSocket支持测试应用程序有两种主要方法。第一种是编写服务器端测试来验证控制器的功能及其带注释的消息处理方法。第二种是编写涉及运行客户端和服务器的完整端到端测试。

这两种方法并不相互排斥。相反，每个人都在整体测试策略中占有一席之地。服务器端测试更集中，更易于编写和维护。另一方面，端到端集成测试更完整，测试更多，但它们也更多地参与编写和维护。

最简单的服务器端测试形式是编写控制器单元测试。然而，由于控制器的大部分功能取决于其注释，因此这没有用。纯单元测试根本无法测试。

理想情况下，测试中的控制器应该在运行时调用，就像测试使用Spring MVC测试框架处理HTTP请求的控制器的方法一样。即没有运行Servlet容器，而是依赖Spring Framework来调用带注释的控制器。就像Spring MVC Test一样，有两种可能的替代方案，使用“基于上下文”或“独立”设置：

  1. 在Spring TestContext框架的帮助下加载实际的Spring配置，将“clientInboundChannel”作为测试字段注入，并使用它发送要由控制器方法处理的消息。

  2. 手动设置调用控制器（即SimpAnnotationMethodMessageHandler）所需的最小Spring框架基础结构，并将控制器的消息直接传递给它。

在股票投资组合 示例应用程序的测试中演示了这两种设置方案 。

第二种方法是创建端到端集成测试。为此，您需要以嵌入模式运行WebSocket服务器，并将其作为WebSocket客户端连接到它，发送包含STOMP帧的WebSocket消息。股票组合 示例应用程序的测试还演示了使用Tomcat作为嵌入式WebSocket服务器和用于测试目的的简单STOMP客户端的这种方法。

转载于:https://my.oschina.net/gemron/blog/837611

你可能感兴趣的:(Spring Websocket 中文文档 (spring5))

  • SpringBlade dict-biz/list 接口 SQL 注入漏洞 文章永久免费只为良心 oracle数据库
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
  • spring如何整合druid连接池？ 惜.己 springspringjunit数据库javaidea后端xml
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
  • SpringCloudAlibaba—Sentinel(限流) 菜鸟爪哇
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
  • springboot+vue项目实战一-创建SpringBoot简单项目 苹果酱0567 面试题汇总与解析springboot后端java中间件开发语言
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
  • Spring MVC 全面指南：从入门到精通的详细解析 一杯梅子酱 技术栈学习springmvcjava
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
  • Spring Boot中实现跨域请求 BABA8891 springboot后端java
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
  • 博客网站制作教程 2401_85194651 javamaven
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
  • RabbitMQ生产者重复机制与确认机制 java炒饭小能手 java-rabbitmqrabbitmqjava
    重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
  • VUE3 + xterm + nestjs实现web远程终端 或 连接开启SSH登录的路由器和交换机。 焚木灵 node.jsvue
    可远程连接系统终端或开启SSH登录的路由器和交换机。相关资料：xtermjs/xterm.js:Aterminalfortheweb(github.com)后端实现(NestJS)：1、安装依赖：npminstallnode-ssh@nestjs/websockets@nestjs/platform-socket.io2、我们将创建一个名为RemoteControlModule的NestJS模块，
  • 【Java】已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException 屿小夏 java开发语言
    文章目录一、分析问题背景问题背景描述出现问题的场景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException在使用Spring框架进行开发时，数据源的配置和使用是非常关键的一环。然而，有时候我们可能会遇到org.springframewo
  • SpringBoot和SpringMVC是什么关系?SpringBoot替代SpringMVC了吗? 瑞金彭于晏 springboot后端javaMVCspring数据库
    SpringBoot和SpringMVC都是SpringFramework生态系统中的一部分，但它们各自扮演着不同的角色和提供不同的功能集。理解它们之间的关系，首先需要了解SpringFramework本身。SpringFrameworkSpringFramework是一个全面的、开源的应用程序开发框架，它提供了广泛的功能来支持企业应用开发的几乎所有方面。SpringFramework的核心特性之
  • spring mvc @RequestBody String类型参数 zoyation spring-mvcspringmvc
    通过如下配置：text/html;charset=UTF-8application/json;charset=UTF-8在springmvc的Controller层使用@RequestBody接收Content-Type为application/json的数据时，默认支持Map方式和对象方式参数@RequestMapping(value="/{code}/saveUser",method=Requ
  • Java -jar 如何在后台运行项目 vincent_hahaha
    撸了今年阿里、头条和美团的面试，我有一个重要发现.......>>>说到运行jar包通常我们都会以下面的方式运行:java-jarspringboot-0.0.1-SNAPSHOT.jar这样运行的话会有一个问题，就是我们一关闭当前窗口就会停止运行项目，要想解决这个问题，就需要在后台运行。nohupjava-jarbabyshark-0.0.1-SNAPSHOT.jar >log.file 2>&
  • spring security中几大组件的作用和执行顺序 阿信在这里 javaspring
    springsecurity中几大组件的作用和执行顺序在SpringSecurity中，AuthenticationProvider、GroupPermissionEvaluator、PermissionEvaluator、AbstractAuthenticationProcessingFilter、DefaultMethodSecurityExpressionHandler和ManageSecu
  • 探索Zebra4J：构建高效企业级Web应用的微服务框架 叶准鑫Natalie
    探索Zebra4J：构建高效企业级Web应用的微服务框架ZebraZebra4J/Zebra4Js基于SpringBoot的JavaWeb/Nodejs框架项目地址:https://gitcode.com/gh_mirrors/zebra/Zebra项目介绍在当今快速发展的技术环境中，构建高效、可扩展的企业级Web应用是每个开发团队的追求。Zebra4J作为一款基于SpringBoot的全新微服务
  • 基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台 网顺技术团队 成品程序项目javavue.js汽车课程设计springboot
    基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台作者主页网顺技术团队欢迎点赞收藏⭐留言文末获取源码联系方式查看下方微信号获取联系方式承接各种定制系统精彩系列推荐精彩专栏推荐订阅不然下次找不到哟Java毕设项目精品实战案例《1000套》感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助更多的人文章目录基
  • 分布式锁和spring事务管理 暴躁的鱼 锁及事务分布式springjava
    最近开发一个小程序遇到一个需求需要实现分布式事务管理业务需求用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记一个地点，每个用户在前端点击想去按钮之后，后台接收到请求，从数据
  • Java面试笔记记录6 今天背八股了吗 java面试笔记
    1.Spring是什么？特性？有哪些模块？Spring是一个轻量级、非入侵式的控制反转Ioc和面向切面AOP的框架。特性：1.Ioc和DISpring的核心就是一个大的工厂容器，可以维护所有对象的创建和依赖关系，Spring工厂用于生成Bean，并且管理Bean的生命周期，实现高内聚低耦合的设计理念。2.AOP编程Spring提供面向切面编程，可以方便实现对程序进行权限拦截、运行监控等切面功能。3
  • sentinel 不显示项目_Sentinel相关问题记录 weixin_39840606 sentinel不显示项目
    SentinelFAQ整理Sentinel承接阿里巴巴近10年双十一大促流量的核心场景，以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。其提供丰富的应用场景支持、完备的监控能力、易用的拓展点。Note:中文文档请见此处。热点问题1、Q:dashboard不展示监控问题如何排查？dashboard是一个单独启动的控制台，引入sentinel的应用是一个客户端。它们各自有
  • Sentinel 眼泪落在琴弦 springcloudjavajava
    Sentinel（服务熔断降级限流）1.引入spring-cloud-starter-alibaba-sentinel2.下载sentinel服务器3.配置application地址信息4.在控制台调整参数【默认所以流控设置保存在内存中，重启失效】5.想实时监控需每个微服务导入actuator，并配置application暴露所有端口6.自定义sentinel流控返回数据7.配置sentinel类
  • Spring @Async 深度解读：默认线程池执行器的配置与优化 小码快撩 springjava前端
    在Spring中，@Async注解用于异步执行方法。默认情况下，@Async注解的任务是由一个线程池执行的。然而，这个默认的线程池是如何初始化的呢？本文将深入探讨这一过程，帮助你理解Spring异步任务背后的线程池执行器的初始化原理。1.@Async的基本使用首先，让我们快速回顾一下@Async的基本用法。@Async通常用于标注在需要异步执行的方法上，比如：@Servicepublicclass
  • Sentinel实时监控不展示问题 朱杰jjj sentinelsentinel
    问题官方插件Endpoint支持，可以实时统计出SpringBoot的健康状况和请求的调用信息在使用Endpoint特性之前需要在Maven中添加spring-boot-starter-actuator依赖，并在配置中允许Endpoints的访问。SpringBoot1.x中添加配置management.security.enabled=false。暴露的endpoint路径为/sentinelS
  • 36. MyBatis如何支持多数据库操作？如何配置不同的数据源？ 这孩子叫逆 Mybatis笔记mybatis数据库
    在许多企业级应用中，可能需要访问多个数据库。MyBatis可以通过配置多个数据源和动态切换数据源来支持多数据库操作。下面介绍如何在MyBatis中配置和使用多个数据源。1.多数据源的基本配置1.1配置多个数据源要支持多个数据源，首先需要在Spring或SpringBoot中配置不同的数据源。假设我们要连接两个数据库db1和db2，可以通过以下步骤进行配置。SpringBoot示例：applicat
  • SpringBoot整合ES搜索引擎 实现网站热搜词及热度计算 码踏云端 springbootElasticsearchspringbootelasticsearch后端热搜词热度计算java
    博主简介：历代文学网（PC端可以访问：https://literature.sinhy.com/#/literature?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
  • Spring Security静态资源过滤（11） 小黑屋说YYDS spring
    在一个实际项目中，并非所有的请求都需要经过SpringSecurity过滤器，有一些特殊的请求，例如静态资源等，一般来说并不需要经过SpringSecurity过滤器链，用户如果访问这些静态资源，直接返回对应的资源即可。回顾关于WebSecurity的讲解，提到它里边维护了一个ignoredRequests变量,该变量，记录的就是所有需要被忽略的请求，这些被忽略的请求将不再经过SpringSecu
  • Spring Security定义多个过滤器链（10） 小黑屋说YYDS spring
    在SpringSecurity中可以同时存在多个过滤器链，一个WebSecurityConfigurerAdapter的实例就可以配置一条过滤器链。我们来看如下一个案例：@ConfigurationpublicclassSecurityConfig{@BeanUserDetailsServiceus(){InMemoryUserDetailsManagerusers=newInMemoryUser
  • java 技术 架构 相关文档 圣心 java架构开发语言
    在Java中，有许多不同的技术和架构，这里我将列举一些常见的Java技术和架构，并提供一些相关的文档资源。SpringFrameworkSpring是一个开源的Java/JavaEE全功能框架，以Apache许可证形式发布，提供了一种实现企业级应用的方法。官方文档：SpringFrameworkSpringBootSpringBoot是Spring的一个子项目，旨在简化创建生产级的Spring应用
  • SpringSecurity初学总结 weixin_66442229 spring
    springSecurity安全框架基于Java的安全框架主要有:SpringSecurity和Shiro介绍基础概念安全框架是对用户访问权限的控制,保证应用的安全性。其主要的工作是用户认证和用户授权|鉴权主要应用于Spring的企业应用系统,提供声明式的安全访问控制解决方案。它提供了一组可以在Spring应用上下文中配置的Bean能很好的结合Spring的DI依赖注入和AOP面向切面编程功能应用
  • java获取applicationcontext,SpringBoot获取ApplicationContext的3种方式 花儿街参考
    ApplicationContext是什么？简单来说就是Spring中的容器，可以用来获取容器中的各种bean组件，注册监听事件，加载资源文件等功能。ApplicationContext获取的几种方式1直接使用Autowired注入@ComponentpublicclassBook1{@AutowiredprivateApplicationContextapplicationContext;pub
  • SpringBoot 设置传入参数非必要 loveLifeLoveCoding springbootspringbootjavaspring
    查看RequestParam源码packageorg.springframework.web.bind.annotation;importjava.lang.annotation.Documented;importjava.lang.annotation.ElementType;importjava.lang.annotation.Retention;importjava.lang.annotat
  • Spring4.1新特性——Spring MVC增强 jinnianshilongnian spring 4.1
    目录 Spring4.1新特性——综述 Spring4.1新特性——Spring核心部分及其他 Spring4.1新特性——Spring缓存框架增强 Spring4.1新特性——异步调用和事件机制的异常处理 Spring4.1新特性——数据库集成测试脚本初始化 Spring4.1新特性——Spring MVC增强 Spring4.1新特性——页面自动化测试框架Spring MVC T
  • mysql 性能查询优化 annan211 javasql优化mysql应用服务器
    1 时间到底花在哪了？ mysql在执行查询的时候需要执行一系列的子任务，这些子任务包含了整个查询周期最重要的阶段，这其中包含了大量为了 检索数据列到存储引擎的调用以及调用后的数据处理，包括排序、分组等。在完成这些任务的时候，查询需要在不同的地方 花费时间，包括网络、cpu计算、生成统计信息和执行计划、锁等待等。尤其是向底层存储引擎检索数据的调用操作。这些调用需要在内存操
  • windows系统配置 cherishLC windows
    删除Hiberfil.sys ：使用命令powercfg -h off 关闭休眠功能即可： http://jingyan.baidu.com/article/f3ad7d0fc0992e09c2345b51.html 类似的还有pagefile.sys msconfig 配置启动项 shutdown 定时关机 ipconfig 查看网络配置 ipconfig /flushdns
  • 人体的排毒时间 Array_06 工作
    ======================== ||  人体的排毒时间是什么时候？|| ======================== 转载于： http://zhidao.baidu.com/link?url=ibaGlicVslAQhVdWWVevU4TMjhiKaNBWCpZ1NS6igCQ78EkNJZFsEjCjl3T5EdXU9SaPg04bh8MbY1bR
  • ZooKeeper cugfy zookeeper
    Zookeeper是一个高性能，分布式的，开源分布式应用协调服务。它提供了简单原始的功能，分布式应用可以基于它实现更高级的服务，比如同步， 配置管理，集群管理，名空间。它被设计为易于编程，使用文件系统目录树作为数据模型。服务端跑在java上，提供java和C的客户端API。 Zookeeper是Google的Chubby一个开源的实现，是高有效和可靠的协同工作系统，Zookeeper能够用来lea
  • 网络爬虫的乱码处理 随意而生 爬虫网络
    下边简单总结下关于网络爬虫的乱码处理。注意，这里不仅是中文乱码，还包括一些如日文、韩文 、俄文、藏文之类的乱码处理，因为他们的解决方式 是一致的，故在此统一说明。     网络爬虫，有两种选择，一是选择nutch、hetriex，二是自写爬虫，两者在处理乱码时，原理是一致的，但前者处理乱码时，要看懂源码后进行修改才可以，所以要废劲一些；而后者更自由方便，可以在编码处理
  • Xcode常用快捷键 张亚雄 xcode
    一、总结的常用命令：     隐藏xcode command+h     退出xcode command+q     关闭窗口 command+w     关闭所有窗口 command+option+w     关闭当前
  • mongoDB索引操作 adminjun mongodb索引
    一、索引基础：    MongoDB的索引几乎与传统的关系型数据库一模一样，这其中也包括一些基本的优化技巧。下面是创建索引的命令：    > db.test.ensureIndex({"username":1})    可以通过下面的名称查看索引是否已经成功建立： &nbs
  • 成都软件园实习那些话 aijuans 成都 软件园 实习
    无聊之中，翻了一下日志，发现上一篇经历是很久以前的事了，悔过~~ 　　断断续续离开了学校快一年了，习惯了那里一天天的幼稚、成长的环境，到这里有点与世隔绝的感觉。不过还好，那是刚到这里时的想法，现在感觉在这挺好，不管怎么样，最要感谢的还是老师能给这么好的一次催化成长的机会，在这里确实看到了好多好多能想到或想不到的东西。 　　都说在外面和学校相比最明显的差距就是与人相处比较困难，因为在外面每个人都
  • Linux下FTP服务器安装及配置 ayaoxinchao linuxFTP服务器vsftp
    检测是否安装了FTP [root@localhost ~]# rpm -q vsftpd 如果未安装：package vsftpd is not installed  安装了则显示：vsftpd-2.0.5-28.el5累死的版本信息   安装FTP 运行yum install vsftpd命令，如[root@localhost ~]# yum install vsf
  • 使用mongo-java-driver获取文档id和查找文档 BigBird2012 driver
    注：本文所有代码都使用的mongo-java-driver实现。   在MongoDB中，一个集合（collection）在概念上就类似我们SQL数据库中的表（Table），这个集合包含了一系列文档（document）。一个DBObject对象表示我们想添加到集合（collection）中的一个文档（document），MongoDB会自动为我们创建的每个文档添加一个id，这个id在
  • JSONObject以及json串 bijian1013 jsonJSONObject
    一.JAR包简介     要使程序可以运行必须引入JSON-lib包，JSON-lib包同时依赖于以下的JAR包：     1.commons-lang-2.0.jar     2.commons-beanutils-1.7.0.jar     3.commons-collections-3.1.jar &n
  • [Zookeeper学习笔记之三]Zookeeper实例创建和会话建立的异步特性 bit1129 zookeeper
    为了说明问题，看个简单的代码，   import org.apache.zookeeper.*; import java.io.IOException; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ThreadLocal
  • 【Scala十二】Scala核心六：Trait bit1129 scala
    Traits are a fundamental unit of code reuse in Scala. A trait encapsulates method and field definitions, which can then be reused by mixing them into classes. Unlike class inheritance, in which each c
  • weblogic version 10.3破解 ronin47 weblogic
    版本：WebLogic Server 10.3 说明：%DOMAIN_HOME%：指WebLogic Server 域(Domain）目录 例如我的做测试的域的根目录 DOMAIN_HOME=D:/Weblogic/Middleware/user_projects/domains/base_domain 1.为了保证操作安全，备份%DOMAIN_HOME%/security/Defa
  • 求第n个斐波那契数 BrokenDreams
            今天看到群友发的一个问题：写一个小程序打印第n个斐波那契数。         自己试了下，搞了好久。。。基础要加强了。           &nbs
  • 读《研磨设计模式》-代码笔记-访问者模式-Visitor bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ import java.util.ArrayList; import java.util.List; interface IVisitor { //第二次分派，Visitor调用Element void visitConcret
  • MatConvNet的excise 3改为网络配置文件形式 cherishLC matlab
    MatConvNet为vlFeat作者写的matlab下的卷积神经网络工具包，可以使用GPU。 主页： http://www.vlfeat.org/matconvnet/ 教程： http://www.robots.ox.ac.uk/~vgg/practicals/cnn/index.html 注意：需要下载新版的MatConvNet替换掉教程中工具包中的matconvnet： http
  • ZK Timeout再讨论 chenchao051 zookeepertimeouthbase
    http://crazyjvm.iteye.com/blog/1693757 文中提到相关超时问题，但是又出现了一个问题，我把min和max都设置成了180000，但是仍然出现了以下的异常信息： Client session timed out, have not heard from server in 154339ms for sessionid 0x13a3f7732340003
  • CASE WHEN 用法介绍 daizj sqlgroup bycase when
    CASE WHEN 用法介绍 1. CASE WHEN 表达式有两种形式 --简单Case函数  CASE sex  WHEN '1' THEN '男'  WHEN '2' THEN '女'  ELSE '其他' END  --Case搜索函数  CASE WHEN sex = '1' THEN
  • PHP技巧汇总:提高PHP性能的53个技巧 dcj3sjt126com PHP
    PHP技巧汇总:提高PHP性能的53个技巧　　用单引号代替双引号来包含字符串，这样做会更快一些。因为PHP会在双引号包围的字符串中搜寻变量，　　单引号则不会，注意：只有echo能这么做，它是一种可以把多个字符串当作参数的函数译注：　　PHP手册中说echo是语言结构，不是真正的函数，故把函数加上了双引号)。　　1、如果能将类的方法定义成static，就尽量定义成static，它的速度会提升将近4倍
  • Yii框架中CGridView的使用方法以及详细示例 dcj3sjt126com yii
    CGridView显示一个数据项的列表中的一个表。 表中的每一行代表一个数据项的数据,和一个列通常代表一个属性的物品(一些列可能对应于复杂的表达式的属性或静态文本)。　　CGridView既支持排序和分页的数据项。排序和分页可以在AJAX模式或正常的页面请求。使用CGridView的一个好处是,当用户浏览器禁用JavaScript,排序和分页自动退化普通页面请求和仍然正常运行。 实例代码如下：
  • Maven项目打包成可执行Jar文件 dyy_gusi assembly
    Maven项目打包成可执行Jar文件 在使用Maven完成项目以后，如果是需要打包成可执行的Jar文件，我们通过eclipse的导出很麻烦，还得指定入口文件的位置，还得说明依赖的jar包，既然都使用Maven了，很重要的一个目的就是让这些繁琐的操作简单。我们可以通过插件完成这项工作，使用assembly插件。具体使用方式如下： 1、在项目中加入插件的依赖： <plugin>
  • php常见错误 geeksun PHP
    1.  kevent() reported that connect() failed (61: Connection refused) while connecting to upstream, client: 127.0.0.1, server: localhost, request: "GET / HTTP/1.1", upstream: "fastc
  • 修改linux的用户名 hongtoushizi linuxchange password
    Change Linux Username 更改Linux用户名，需要修改4个系统的文件： /etc/passwd /etc/shadow /etc/group /etc/gshadow 古老/传统的方法是使用vi去直接修改，但是这有安全隐患（具体可自己搜一下），所以后来改成使用这些命令去代替： vipw vipw -s vigr vigr -s   具体的操作顺
  • 第五章 常用Lua开发库1-redis、mysql、http客户端 jinnianshilongnian nginxlua
    对于开发来说需要有好的生态开发库来辅助我们快速开发，而Lua中也有大多数我们需要的第三方开发库如Redis、Memcached、Mysql、Http客户端、JSON、模板引擎等。 一些常见的Lua库可以在github上搜索，https://github.com/search?utf8=%E2%9C%93&q=lua+resty。   Redis客户端 lua-resty-r
  • zkClient 监控机制实现 liyonghui160com zkClient 监控机制实现
             直接使用zk的api实现业务功能比较繁琐。因为要处理session loss，session expire等异常，在发生这些异常后进行重连。又因为ZK的watcher是一次性的，如果要基于wather实现发布/订阅模式，还要自己包装一下，将一次性订阅包装成持久订阅。另外如果要使用抽象级别更高的功能，比如分布式锁，leader选举
  • 在Mysql 众多表中查找一个表名或者字段名的 SQL 语句 pda158 mysql
    在Mysql 众多表中查找一个表名或者字段名的 SQL 语句： 　　方法一：SELECT table_name, column_name from information_schema.columns WHERE column_name LIKE 'Name'; 　　方法二：SELECT column_name from information_schema.colum
  • 程序员对英语的依赖 Smile.zeng 英语程序猿
    1、程序员最基本的技能，至少要能写得出代码，当我们还在为建立类的时候思考用什么单词发牢骚的时候，英语与别人的差距就直接表现出来咯。 2、程序员最起码能认识开发工具里的英语单词，不然怎么知道使用这些开发工具。 3、进阶一点，就是能读懂别人的代码，有利于我们学习人家的思路和技术。 4、写的程序至少能有一定的可读性，至少要人别人能懂吧... 以上一些问题，充分说明了英语对程序猿的重要性。骚年
  • Oracle学习笔记(8) 使用PLSQL编写触发器 vipbooks oraclesql编程活动Access
        时间过得真快啊，转眼就到了Oracle学习笔记的最后个章节了，通过前面七章的学习大家应该对Oracle编程有了一定了了解了吧，这东东如果一段时间不用很快就会忘记了，所以我会把自己学习过的东西做好详细的笔记，用到的时候可以随时查找，马上上手！希望这些笔记能对大家有些帮助！     这是第八章的学习笔记，学习完第七章的子程序和包之后
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他