Springboot集成WebSocket 指定用户主动推送消息

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.WebSocketSession;
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.web.socket.config.annotation.WebSocketTransportRegistration;
import org.springframework.web.socket.handler.WebSocketHandlerDecorator;
import org.springframework.web.socket.handler.WebSocketHandlerDecoratorFactory;


@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig extends AbstractWebSocketMessageBrokerConfigurer {
    private Logger logger = LoggerFactory.getLogger(WebSocketConfig.class);

    @Override
    public void registerStompEndpoints(StompEndpointRegistry stompEndpointRegistry) {
        // 客户端与服务器端建立连接的点
        stompEndpointRegistry.addEndpoint("/socket").setAllowedOrigins("*").withSockJS();
    }
    @Override
    public void configureMessageBroker(MessageBrokerRegistry messageBrokerRegistry) {
        //注册一个Stomp 协议的endpoint,并指定 SockJS协议,允许跨域
        messageBrokerRegistry.enableSimpleBroker("/topic","/queue");
    }

    @Bean
    public STOMPConnectEventListener STOMPConnectEventListener(){
        return new STOMPConnectEventListener();
    }

    @Override
    public void configureWebSocketTransport(final WebSocketTransportRegistration registration) {
        registration.addDecoratorFactory(new WebSocketHandlerDecoratorFactory() {

            @Override
            public WebSocketHandler decorate(WebSocketHandler handler) {
                return new WebSocketHandlerDecorator(handler) {

                    public void afterConnectionEstablished(final WebSocketSession session) throws Exception {
                        // 客户端与服务器端建立连接后，此处记录谁上线了
                        //String username = session.getPrincipal().getName();
                        //logger.info("online: " + username);
                        logger.info("WebSocketSession: "+session.getId());
                        super.afterConnectionEstablished(session);
                    }
                    public void afterConnectionClosed(WebSocketSession session, CloseStatus closeStatus)
                            throws Exception {
                        // 客户端与服务器端断开连接后，此处记录谁下线了
                        //String username = session.getPrincipal().getName();
                        //logger.info("offline: " + username);
                        logger.info("WebSocketSession: "+session.getId()+" closeStatus: "+closeStatus.getCode());
                        super.afterConnectionClosed(session, closeStatus);
                        for(int i=0;i<stompWs.size();i++){
                            StompBean s=stompWs.get(i);
                            if(s.getSessionId().equals(session.getId())){
                                StompBean remove = stompWs.remove(i);
                                logger.info("remove: "+remove.getSessionId());
                            }
                        }
                    }
                };
            }
        });
        super.configureWebSocketTransport(registration);
    }
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationListener;
import org.springframework.messaging.simp.stomp.StompHeaderAccessor;
import org.springframework.web.socket.messaging.SessionConnectEvent;

import java.util.ArrayList;
import java.util.List;

/**
 * STOMP监听类
 * 用于session注册 以及key值获取
 */
public class STOMPConnectEventListener  implements ApplicationListener<SessionConnectEvent> {
    private Logger logger = LoggerFactory.getLogger(STOMPConnectEventListener.class);
    public static List<StompBean> stompWs=new ArrayList<>();

    @Override
    public void onApplicationEvent(SessionConnectEvent event) {
        StompHeaderAccessor sha = StompHeaderAccessor.wrap(event.getMessage());
        //login get from browser
        String agentId;
        if(sha.getNativeHeader("login")!=null){
            agentId = sha.getNativeHeader("login").get(0);
            logger.info("agentId: "+agentId);
            String sessionId = sha.getSessionId();
            logger.info("sessionId: "+sessionId);

            StompBean stompBean=new StompBean();
            stompBean.setAgentId(agentId);
            stompBean.setSessionId(sessionId);
            stompWs.add(stompBean);
        }
    }
}

public class StompBean {
    //当前登录账号
    private String agentId;
    //当前websocket连接sessionid
    private String sessionId;

    public String getAgentId() {
        return agentId;
    }

    public void setAgentId(String agentId) {
        this.agentId = agentId;
    }

    public String getSessionId() {
        return sessionId;
    }

    public void setSessionId(String sessionId) {
        this.sessionId = sessionId;
    }
}

@Service
public class MessageSendImpl implements IMessageSendService {
    private static final Logger logger = LoggerFactory.getLogger(MessageSendImpl.class);
    @Autowired
    private SimpMessagingTemplate template;

    //@Autowired
    //private IUserService userService;


    public static MessageSendImpl messageSendImpl;

    @PostConstruct
    public void init() {
        messageSendImpl = this;
    }
    
    public String sendMessage(JSONObject message){
        SocketResponse response=new SocketResponse();
        response.setResponseMessage(message);
        logger.info("webSocket获取消息："+message.toString());
        for(StompBean s:stompWs){
           String accountNumber = s.getAgentId();
           String sessionId = s.getSessionId();
           //FindUserAccountReq findUserAccountReq=new FindUserAccountReq();
           //findUserAccountReq.setAccountNumber(accountNumber);
           //FindUserAccountResp userAccount = userService.findUserAccount(findUserAccountReq);
           //User user=userAccount.getUser();
           //List<Role> roleList = user.getRoleList();
           //Organization org = user.getOrg();
           template.convertAndSendToUser(sessionId, "/queue/msg", response, createHeaders(sessionId));
           logger.info("webSocket推送消息："+message.toString());
           return "000000"; 
         }
    }
    private MessageHeaders createHeaders(String sessionId) {
        SimpMessageHeaderAccessor headerAccessor = SimpMessageHeaderAccessor.create(SimpMessageType.MESSAGE);
        headerAccessor.setSessionId(sessionId);
        headerAccessor.setLeaveMutable(true);
        return headerAccessor.getMessageHeaders();
    }
//    // 群聊天
//    public void all(Principal principal, String message) {
//        // 参数说明 principal 当前登录的用户， message 客户端发送过来的内容
//        // principal.getName() 可获得当前用户的username
//
//        // 发送消息给订阅 "/topic/notice" 且在线的用户
//        ChatMessage chatMessage = createMessage(principal.getName(), message);
//        template.convertAndSend("/topic/notice", JSON.toJSONString(chatMessage));
//    }
}

前端页面vue

testSockJS () {
      //204
      const websocket = new SockJS('http://localhost:8080/socket')
      this.websocket = websocket
      this.stompClient = Stomp.over(this.websocket)
      this.stompClient.debug = () => { };
      this.stompClient.connect(
        { login: window.localStorage.getItem('accountNumber') },//账号
        frame => {
          Message.success('设备通信通道已连接!');
          this.stompClient.subscribe('/user/queue/msg', tick => {
            const resRec = JSON.parse(tick.body)
          })  
        },
        error => {
          console.log(error)
          this.$confirm('设备通信通道已断开，是否重新连接?', '提示', {
            confirmButtonText: '重新连接',
            cancelButtonText: '取消连接',
            type: 'warning',
            center: true
          }).then(() => {
            this.testSockJS()
          }).catch(() => {

          });
        }

      )
    }