Java Spring Websocket STOMP：发送接收帧

我有一个基于Spring及其SimpleBroker实现的Websocket stomp服务器（不使用外部代理）

我想启用STOMP接收消息

---

如何配置代码以自动发送这些信息？

在STOMP协议的Spring集成测试中，我们有以下代码：

    //SimpleBrokerMessageHandler doesn't support RECEIPT frame, hence we emulate it this way
    @Bean
    public ApplicationListener<SessionSubscribeEvent> webSocketEventListener(
            final AbstractSubscribableChannel clientOutboundChannel) {
        return event -> {
            Message<byte[]> message = event.getMessage();
            StompHeaderAccessor stompHeaderAccessor = StompHeaderAccessor.wrap(message);
            if (stompHeaderAccessor.getReceipt() != null) {
                stompHeaderAccessor.setHeader("stompCommand", StompCommand.RECEIPT);
                stompHeaderAccessor.setReceiptId(stompHeaderAccessor.getReceipt());
                clientOutboundChannel.send(
                        MessageBuilder.createMessage(new byte[0], stompHeaderAccessor.getMessageHeaders()));
            }
        };
    }

//SimpleBrokerMessageHandler不支持接收帧，因此我们以这种方式模拟它
@豆子
公共应用程序列表器webSocketEventListener(
最终摘要SubscriptableChannel客户端OutboundChannel）{
返回事件->{
Message Message=event.getMessage（）；
StompHeaderAccessor StompHeaderAccessor=StompHeaderAccessor.wrap（消息）；
if（stompHeaderAccessor.getReceivement（）！=null）{
stompHeaderAccessor.setHeader（“stompCommand”，stompCommand.Receive）；
stompHeaderAccessor.setReceiptId（stompHeaderAccessor.getReceiptId（））；
clientOutboundChannel.send(
MessageBuilder.createMessage（新字节[0]，stompHeaderAccessor.getMessageHeaders（））；
}
};
}

---

Artem Bilan提供的答案仅适用于订阅帧。这是另一个捕获任何带有接收头的传入帧的方法。只有带有@EnableWebSocketMessageBroker注释的类需要扩展，其他类（如带有@Controller注释的类）保持不变

import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.Map;
import java.util.List;
import java.util.HashMap;
import java.util.ArrayList;

import org.springframework.context.annotation.Configuration;
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;
import org.springframework.messaging.simp.config.SimpleBrokerRegistration;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageHeaders;
import org.springframework.messaging.support.ChannelInterceptorAdapter;
import org.springframework.messaging.support.GenericMessage;
import org.springframework.messaging.simp.config.ChannelRegistration;
import org.springframework.messaging.simp.SimpMessageType;
import org.springframework.messaging.simp.stomp.StompCommand;
import org.springframework.messaging.MessageChannel;
import org.springframework.beans.factory.annotation.Autowired;

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig extends AbstractWebSocketMessageBrokerConfigurer {

    private static final Logger LOGGER = Logger.getLogger( WebSocketConfig.class.getName() );
    private MessageChannel outChannel;

    @Override
    public void configureClientInboundChannel(ChannelRegistration registration) {
        registration.interceptors( new InboundMessageInterceptor() );
    }

    @Override
    public void configureClientOutboundChannel(ChannelRegistration registration) {
        registration.interceptors( new OutboundMessageInterceptor() );
    }

    @Override
    public void configureMessageBroker(MessageBrokerRegistry config) {
// prefixes are application-dependent
        config.enableSimpleBroker("/topic");
        config.setApplicationDestinationPrefixes("/app");
    }

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


    class InboundMessageInterceptor extends ChannelInterceptorAdapter {

        @SuppressWarnings("unchecked")
        public Message preSend(Message message, MessageChannel channel) {
            LOGGER.log( Level.SEVERE, "preSend: "+message );
            GenericMessage genericMessage = (GenericMessage)message;
            MessageHeaders headers = genericMessage.getHeaders();
            String simpSessionId = (String)headers.get( "simpSessionId" );
            if( ( SimpMessageType.MESSAGE.equals( headers.get( "simpMessageType" ) ) &&
                  StompCommand.SEND.equals( headers.get( "stompCommand" ) ) ) ||
                ( SimpMessageType.SUBSCRIBE.equals( headers.get( "simpMessageType" ) ) &&
                  StompCommand.SUBSCRIBE.equals( headers.get( "stompCommand" ) ) ) &&
                ( simpSessionId != null ) ) {
                Map<String,List<String>> nativeHeaders = (Map<String,List<String>>)headers.get( "nativeHeaders" );
                if( nativeHeaders != null ) {
                    List<String> receiptList = nativeHeaders.get( "receipt" );
                    if( receiptList != null ) {
                        String rid = (String)receiptList.get(0);
                        LOGGER.log( Level.SEVERE, "receipt requested: "+rid );
                        sendReceipt( rid, simpSessionId );
                    }
                }
            }
            return message;
        }

        private void sendReceipt( String rid, String simpSessionId ) {
            if( outChannel != null ) {
                HashMap<String,Object> rcptHeaders = new HashMap<String,Object>();
                rcptHeaders.put( "simpMessageType", SimpMessageType.OTHER );
                rcptHeaders.put( "stompCommand", StompCommand.RECEIPT );
                rcptHeaders.put( "simpSessionId", simpSessionId );
                HashMap<String,List<String>> nativeHeaders = new HashMap<String,List<String>>();
                ArrayList<String> receiptElements = new ArrayList<String>();
                receiptElements.add( rid );
                nativeHeaders.put( "receipt-id", receiptElements );
                rcptHeaders.put( "nativeHeaders",nativeHeaders );
                GenericMessage<byte[]> rcptMsg = new GenericMessage<byte[]>( new byte[0],new MessageHeaders( rcptHeaders ) );
                outChannel.send( rcptMsg );
            } else
                LOGGER.log( Level.SEVERE, "receipt NOT sent" );
        }
    }

    class OutboundMessageInterceptor extends ChannelInterceptorAdapter {
        public void postSend(Message message,
            MessageChannel channel,
            boolean sent) {
            LOGGER.log( Level.SEVERE, "postSend: "+message );
            outChannel = channel;
        }
    }
}

import java.util.logging.Level；
导入java.util.logging.Logger；
导入java.util.Map；
导入java.util.List；
导入java.util.HashMap；
导入java.util.ArrayList；
导入org.springframework.context.annotation.Configuration；
导入org.springframework.messaging.simp.config.MessageBrokerRegistry；
导入org.springframework.web.socket.config.annotation.AbstractWebSocketMessageBrokerConfigure；
导入org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker；
导入org.springframework.web.socket.config.annotation.StompEndpointRegistry；
导入org.springframework.messaging.simp.config.SimpleBrokerRegistration；
导入org.springframework.messaging.Message；
导入org.springframework.messaging.MessageHeaders；
导入org.springframework.messaging.support.ChannelInterceptorAdapter；
导入org.springframework.messaging.support.GenericMessage；
导入org.springframework.messaging.simp.config.ChannelRegistration；
导入org.springframework.messaging.simp.SimpMessageType；
导入org.springframework.messaging.simp.stomp.StompCommand；
导入org.springframework.messaging.MessageChannel；
导入org.springframework.beans.factory.annotation.Autowired；
@配置
@EnableWebSocketMessageBroker
公共类WebSocketConfig扩展了AbstractWebSocketMessageBrokerConfiger{
私有静态最终记录器Logger=Logger.getLogger（WebSocketConfig.class.getName（））；
专用消息通道；
@凌驾
公共无效配置ClientInBoundChannel（通道注册）{
registration.interceptors（新的InboundMessageInterceptor（））；
}
@凌驾
公共无效配置ClientOutboundChannel（通道注册）{
registration.interceptors（新的OutboundMessageInterceptor（））；
}
@凌驾
public void配置MessageBroker（MessageBrokerRegistry配置）{
//前缀依赖于应用程序
config.enableSimpleBroker（“/topic”）；
config.setApplicationDestinationPrefixes（“/app”）；
}
@凌驾
公共无效注册表TompendPoints（StompEndpointRegistry注册表）{
注册表。添加点（“/注”）；
}
类InboundMessageInterceptor扩展ChannelInterceptorAdapter{
@抑制警告（“未选中”）
公共消息呈现（消息消息、消息通道）{
LOGGER.log（Level.severy，“pressend:+消息”）；
GenericMessage GenericMessage=（GenericMessage）消息；
MessageHeaders=genericMessage.getHeaders（）；
String simpSessionId=（String）headers.get（“simpSessionId”）；
if（（SimpMessageType.MESSAGE.equals（headers.get（“SimpMessageType”））&&
StompCommand.SEND.equals（headers.get（“StompCommand”））||
（SimpMessageType.SUBSCRIBE.equals（headers.get（“SimpMessageType”））&&
StompCommand.SUBSCRIBE.equals（headers.get（“StompCommand”））&&
（simpSessionId！=null））{
Map nativeHeaders=（Map）headers.get（“nativeHeaders”）；
if（nativeHeaders！=null）{
List receiptList=nativeHeaders.get（“收据”）；
if（receiptList！=null）{
String rid=（String）receiptList.get（0）；
LOGGER.log（严重级别，“请求接收：+rid”）；
SendReceive（rid、simpSessionId）；
}
}
}
返回消息；
}
私有void SendReceive（字符串rid、字符串simpSessionId）{
如果（输出通道！=null）{
HashMap rcptHeaders=新HashMap（）；
rcptHeaders.put（“simpMessageType”，simpMessageType.OTHER）；
rcptHeaders.put（“stompCommand”，stompCommand.receive）；
rcptHeaders.put（“simpSessionId”，simpSessionId）；
HashMap nativeHeaders=新HashMap（）；
ArrayList receiptElements=新的ArrayList（）；
receiptElements.add（rid）；
nativeHeaders.put（“收据id”，receiptElements）；
rcptHeaders.put（“nativeHeaders”，nativeHeaders）；
GenericMessage rcptMsg=新的GenericMessage（新字节[0]，新的MessageHeaders（rcptHeaders））；
发送（rcptMsg）；
}否则
LOGGER.log（严重级别，“未发送收据”）；
}
}
类OutboundMessageI
@Component
public class SubscribeListener implements ApplicationListener<SessionSubscribeEvent> {
    @Autowired
    AbstractSubscribableChannel clientOutboundChannel;

    @Override
    public void onApplicationEvent(SessionSubscribeEvent event) {
        Message<byte[]> message = event.getMessage();
        StompHeaderAccessor stompHeaderAccessor = StompHeaderAccessor.wrap(message);

        if (stompHeaderAccessor.getReceipt() != null) {
            StompHeaderAccessor receipt = StompHeaderAccessor.create(StompCommand.RECEIPT);
            receipt.setReceiptId(stompHeaderAccessor.getReceipt());    
            receipt.setSessionId(stompHeaderAccessor.getSessionId());
            clientOutboundChannel.send(MessageBuilder.createMessage(new byte[0], receipt.getMessageHeaders()));
        }
    }
}

@Configuration
static class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    private MessageChannel outChannel;

    @Autowired
    public WebSocketConfig(MessageChannel clientOutboundChannel) {
        this.outChannel = clientOutboundChannel;
    }

    @Override
    public void configureClientInboundChannel(ChannelRegistration registration) {

        registration.interceptors(new ExecutorChannelInterceptor() {

            @Override
            public void afterMessageHandled(Message<?> inMessage,
                    MessageChannel inChannel, MessageHandler handler, Exception ex) {

                StompHeaderAccessor inAccessor = StompHeaderAccessor.wrap(inMessage);
                String receipt = inAccessor.getReceipt();
                if (StringUtils.isEmpty(receipt)) {
                    return;
                }

                StompHeaderAccessor outAccessor = StompHeaderAccessor.create(StompCommand.RECEIPT);
                outAccessor.setSessionId(inAccessor.getSessionId());
                outAccessor.setReceiptId(receipt);
                outAccessor.setLeaveMutable(true);

                Message<byte[]> outMessage =
                        MessageBuilder.createMessage(new byte[0], outAccessor.getMessageHeaders());

                outChannel.send(outMessage);
            }
        });
    }
}