spring websocket + rabbitmq stomp: Wie kann ich alle Online-Benutzer und trennen einige Benutzer verbinden?

Question

Wenn spring store Benutzer websocket Sitzung, wie kann es bekommen, wenn ich someHandler Sitzung in eine Karte zu setzen, dass die Größe der Karte vielleicht ich größer als 10w +, glaube nicht, es ist gut

SessionHandler.java

package hello; 

import org.slf4j.Logger; 
import org.slf4j.LoggerFactory; 
import org.springframework.stereotype.Service; 
import org.springframework.web.socket.WebSocketSession; 

import java.io.IOException; 
import java.util.Map; 
import java.util.concurrent.ConcurrentHashMap; 
import java.util.concurrent.Executors; 
import java.util.concurrent.ScheduledExecutorService; 
import java.util.concurrent.TimeUnit; 

@Service 
public class SessionHandler { 
    private static final Logger LOGGER = LoggerFactory.getLogger(SessionHandler.class); 
    private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor(); 

    private final Map<String, WebSocketSession> sessionMap = new ConcurrentHashMap<>(); 

    public SessionHandler() { 
     scheduler.scheduleAtFixedRate(new Runnable() { 
      @Override 
      public void run() { 
       sessionMap.keySet().forEach(k -> { 
        try { 
         sessionMap.get(k).close(); 
         sessionMap.remove(k); 
        } catch (IOException e) { 
         LOGGER.error("Error while closing websocket session: {}", e); 
        } 
       }); 
      } 
     }, 10, 10, TimeUnit.SECONDS); 
    } 

    public void register(WebSocketSession session) { 
     sessionMap.put(session.getId(), session); 
    } 

} 

wie folgt aus:. https://github.com/isaranchuk/spring-websocket-disconnect/blob/master/src/main/java/hello/SessionHandler.java

Answer 1

Implementieren der HandshakeInte r wie unten.

public class HttpSessionIdHandshakeInterceptor implements HandshakeInterceptor { 

    public boolean beforeHandshake(ServerHttpRequest request, 
      ServerHttpResponse response, 
      WebSocketHandler wsHandler, 
      Map<String, Object> attributes) 
       throws Exception { 
     if (request instanceof ServletServerHttpRequest) { 
      ServletServerHttpRequest servletRequest = (ServletServerHttpRequest) request; 
      HttpSession session = servletRequest.getServletRequest().getSession(false); 
      if (session != null) { 
       attributes.put(SESSION_ATTR, session.getId()); 
      } 
     } 
     return true; 
    } 

    public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response, 
           WebSocketHandler wsHandler, Exception ex) { 
    } 
} 

Dann Zum Endpunkt hinzufügen.

public class WebSocketConfig extends 
     AbstractWebSocketMessageBrokerConfigurer { 

public void registerStompEndpoints(StompEndpointRegistry registry) { 
    registry.addEndpoint("/portfolio") 
      .withSockJS() 
      .setInterceptors(new HttpSessionIdHandshakeInterceptor()); 

} 

... }

Als nächstes können wir eine ChannelInterceptorAdapter erstellen, die die Session-ID verwendet die zuletzt zugegriffen Zeit mit Spring Session zu aktualisieren. Zum Beispiel:

@Bean public ChannelInterceptorAdapter sessionContextChannelInterceptorAdapter() { 
return new ChannelInterceptorAdapter() { 
    @Override 
    public Message<?> preSend(Message<?> message, MessageChannel channel) { 
     Map<String, Object> sessionHeaders = SimpMessageHeaderAccessor.getSessionAttributes(message.getHeaders()); 
     String sessionId = (String) sessionHeaders.get(SESSION_ATTR); 
     if (sessionId != null) { 
      Session session = sessionRepository.getSession(sessionId); 
      if (session != null) { 
       sessionRepository.save(session); 
      } 
     } 
     return super.preSend(message, channel); 
    } 
}; 

}