Zugreifen auf HttpSession von HttpServletRequest in einem Web Socket @ServerEndpoint

Vorwort

Es ist unklar, ob Sie wollen, sind die HttpServletRequestdie HttpSession oder-Eigenschaften aus der HttpSession. Meine Antwort wird zeigen, wie man die HttpSession oder individuelle Eigenschaften.

Habe ich weggelassen null und index bounds-checks für die Kürze.

Sicherheitshinweise

Ist es schwierig. Die Antwort von Martin Andersson ist nicht korrekt, weil die gleiche Instanz von ServerEndpointConfig.Configurator verwendet wird, für jede Verbindung, daher existiert eine race condition. Während die ärzte sagen, dass Die "Umsetzung erstellt eine neue Instanz der Konfigurator pro logischen Endpunkt," die Skillung nicht klar zu definieren eine "logische Endpunkt." Basierend auf dem Kontext des ganzen Orte, die phrase ist verwendet, es scheint zu bedeuten, die Bindung einer Klasse, Konfigurator, den Pfad und sonstige Optionen, D. H., eine ServerEndpointConfigdas ist klar verteilt. Trotzdem können Sie leicht sehen, ob eine Implementierung mithilfe der gleichen Instanz von drucken aus seiner toString() innerhalb modifyHandshake(...).

Mehr überraschend, die Antwort von Joakim Erdfelt auch nicht zuverlässig funktioniert. Der text des JSR 356 selbst nicht erwähnt EndpointConfig.getUserProperties() ist es nur in der JavaDoc, und nirgends scheint es, angegeben werden, was seine genaue Beziehung zu Session.getUserProperties(). In der Praxis werden einige Implementierungen (z.B. Glassfish) wieder den gleichen Map Instanz für alle Aufrufe ServerEndpointConfig.getUserProperties() während andere (z.B. Tomcat 8) nicht. Sie können überprüfen, indem Sie drucken sich die Karte Inhalte, bevor Sie es ändern innerhalb modifyHandshake(...).

Um zu überprüfen, kopierte ich den code direkt aus den anderen Antworten und dann wird es getestet, gegen ein Multithread-client, den ich schrieb. In beiden Fällen, die ich beobachtet habe die falsche Sitzung im Zusammenhang mit der Endpunkt-Instanz.

Skizzieren von Lösungen

Habe ich zwei Lösungen entwickelt, die habe ich schon überprüft, funktionieren ordnungsgemäß, wenn Sie getestet gegen ein Multithread-client. Es gibt zwei wesentliche tricks.

Erste, verwenden Sie einen filter mit dem gleichen Pfad wie die WebSocket. Dadurch erhalten Sie Zugriff auf die HttpServletRequest und HttpSession. Es gibt Ihnen auch eine chance, um eine Sitzung zu erstellen, wenn es nicht bereits vorhanden ist (obwohl in diesem Fall die Verwendung einer HTTP-Sitzung an alle, scheint zweifelhaft).

Zweitens finden Sie einige Eigenschaften, die existieren, sowohl in der WebSocket - Session und HttpServletRequest oder HttpSession. Es stellt sich heraus, es gibt zwei Kandidaten: getUserPrincipal() und getRequestParameterMap(). Ich werde Ihnen zeigen, wie Sie Missbrauch sowohl von Ihnen 🙂

Lösung mit User Principal

Die einfachste Art und Weise zu nutzen, ist Session.getUserPrincipal() und HttpServletRequest.getUserPrincipal(). Der Nachteil ist, das könnte stören mit anderen legitimen Nutzungen dieser Eigenschaft, so verwenden Sie es nur, wenn Sie bereit sind, für diese Implikationen.

Wenn Sie möchten, speichern Sie einfach eine Zeichenfolge, wie beispielsweise eine Benutzer-ID, das ist eigentlich nicht zu viel von einem Missbrauch, obwohl Sie vermutlich sollte setzen Sie in einige container managed Weise statt überschreiben Sie den wrapper, so dass ich Ihnen zeigen werde. Trotzdem würden Sie tun, indem Sie einfach überschreiben Principal.getName(). Dann brauchen Sie nicht einmal zu Gießen es in die Endpoint. Aber wenn Sie Magen können Sie auch passieren die ganze HttpSession Objekt wie folgt.

PrincipalWithSession.java

package example1;

import java.security.Principal;
import javax.servlet.http.HttpSession;

public class PrincipalWithSession implements Principal {
    private final HttpSession session;

    public PrincipalWithSession(HttpSession session) {
        this.session = session;
    }

    public HttpSession getSession() {
        return session;
    }

    @Override
    public String getName() {
        return ""; //whatever is appropriate for your app, e.g., user ID
    }
}

WebSocketFilter.java

package example1;

import java.io.IOException;
import java.security.Principal;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;

@WebFilter("/example1")
public class WebSocketFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        final PrincipalWithSession p = new PrincipalWithSession(httpRequest.getSession());
        HttpServletRequestWrapper wrappedRequest = new HttpServletRequestWrapper(httpRequest) {
            @Override
            public Principal getUserPrincipal() {
                return p;
            }
        };
        chain.doFilter(wrappedRequest, response);
    }

    public void init(FilterConfig config) throws ServletException { }
    public void destroy() { }
}

WebSocketEndpoint.java

package example1;

import javax.servlet.http.HttpSession;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;

@ServerEndpoint("/example1")
public class WebSocketEndpoint {
    private HttpSession httpSession;

    @OnOpen
    public void onOpen(Session webSocketSession) {
        httpSession = ((PrincipalWithSession) webSocketSession.getUserPrincipal()).getSession();
    }

    @OnMessage
    public String demo(String msg) {
        return msg + "; (example 1) session ID " + httpSession.getId();
    }
}

Lösung Mittels Des Request-Parameter

Die zweite option verwendet Session.getRequestParameterMap() und HttpServletRequest.getParameterMap(). Beachten Sie, dass es verwendet ServerEndpointConfig.getUserProperties() aber es ist sicher in diesem Fall, weil wir uns immer setzen, die dasselbe Objekt in der Karte anzeigen, so, ob es freigegeben ist, macht keinen Unterschied. Die einzigartige session-id übergeben wird, nicht über die user-Parameter, sondern durch die request-Parameter, die ist einmalig pro Anfrage.

Diese Lösung ist etwas weniger hacky, weil es nicht stört mit dem user principal-Eigenschaft. Beachten Sie, dass wenn Sie brauchen, um passieren die tatsächlichen request-Parameter zusätzlich zu den ein, der eingefügt wurde, können Sie das leicht tun: starten Sie einfach mit der vorhandenen request-parameter-map anstatt eine neue leere wie hier gezeigt. Aber achten Sie darauf, dass der Benutzer kann nicht fälschen die speziellen parameter Hinzugefügt, die in den filter, indem Sie die Versorgung Ihrer eigenen request-parameter mit demselben Namen in der aktuellen HTTP Anfrage.

SessionTracker.java

/* A simple, typical, general-purpose servlet session tracker */
package example2;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

@WebListener
public class SessionTracker implements ServletContextListener, HttpSessionListener {
    private final ConcurrentMap<String, HttpSession> sessions = new ConcurrentHashMap<>();

    @Override
    public void contextInitialized(ServletContextEvent event) {
        event.getServletContext().setAttribute(getClass().getName(), this);
    }

    @Override
    public void contextDestroyed(ServletContextEvent event) {
    }

    @Override
    public void sessionCreated(HttpSessionEvent event) {
        sessions.put(event.getSession().getId(), event.getSession());
    }

    @Override
    public void sessionDestroyed(HttpSessionEvent event) {
        sessions.remove(event.getSession().getId());
    }

    public HttpSession getSessionById(String id) {
        return sessions.get(id);
    }
}

WebSocketFilter.java

package example2;

import java.io.IOException;
import java.util.Collections;
import java.util.Map;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;

@WebFilter("/example2")
public class WebSocketFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        final Map<String, String[]> fakedParams = Collections.singletonMap("sessionId",
                new String[] { httpRequest.getSession().getId() });
        HttpServletRequestWrapper wrappedRequest = new HttpServletRequestWrapper(httpRequest) {
            @Override
            public Map<String, String[]> getParameterMap() {
                return fakedParams;
            }
        };
        chain.doFilter(wrappedRequest, response);
    }

    @Override
    public void init(FilterConfig config) throws ServletException { }
    @Override
    public void destroy() { }
}

WebSocketEndpoint.java

package example2;

import javax.servlet.http.HttpSession;
import javax.websocket.EndpointConfig;
import javax.websocket.HandshakeResponse;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.HandshakeRequest;
import javax.websocket.server.ServerEndpoint;
import javax.websocket.server.ServerEndpointConfig;

@ServerEndpoint(value = "/example2", configurator = WebSocketEndpoint.Configurator.class)
public class WebSocketEndpoint {
    private HttpSession httpSession;

    @OnOpen
    public void onOpen(Session webSocketSession, EndpointConfig config) {
        String sessionId = webSocketSession.getRequestParameterMap().get("sessionId").get(0);
        SessionTracker tracker =
                (SessionTracker) config.getUserProperties().get(SessionTracker.class.getName());
        httpSession = tracker.getSessionById(sessionId);
    }

    @OnMessage
    public String demo(String msg) {
        return msg + "; (example 2) session ID " + httpSession.getId();
    }

    public static class Configurator extends ServerEndpointConfig.Configurator {
        @Override
        public void modifyHandshake(ServerEndpointConfig sec, HandshakeRequest request,
                HandshakeResponse response) {
            Object tracker = ((HttpSession) request.getHttpSession()).getServletContext().getAttribute(
                    SessionTracker.class.getName());
            //This is safe to do because it's the same instance of SessionTracker all the time
            sec.getUserProperties().put(SessionTracker.class.getName(), tracker);
            super.modifyHandshake(sec, request, response);
        }
    }
}

Lösung für Einzelne Eigenschaften

Wenn Sie nur bestimmte Eigenschaften aus der HttpSession und nicht die ganze HttpSession selbst, wie sagen, eine Benutzer-ID, dann könnten Sie tun, Weg mit der ganzen SessionTracker business und nur die erforderlichen Parameter in die Karte, die Sie nach Ihrer Außerkraftsetzung des HttpServletRequestWrapper.getParameterMap(). Dann können Sie auch loszuwerden, die Gewohnheit Configurator; Ihre Eigenschaften werden bequem von Session.getRequestParameterMap() im Endpunkt.

WebSocketFilter.java

package example5;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;

@WebFilter("/example5")
public class WebSocketFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        final Map<String, String[]> props = new HashMap<>();
        //Add properties of interest from session; session ID
        //is just for example
        props.put("sessionId", new String[] { httpRequest.getSession().getId() });
        HttpServletRequestWrapper wrappedRequest = new HttpServletRequestWrapper(httpRequest) {
            @Override
            public Map<String, String[]> getParameterMap() {
                return props;
            }
        };
        chain.doFilter(wrappedRequest, response);
    }

    @Override
    public void destroy() {
    }

    @Override
    public void init(FilterConfig arg0) throws ServletException {
    }
}

WebSocketEndpoint.java

package example5;

import java.util.List;
import java.util.Map;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;

@ServerEndpoint("/example5")
public class WebSocketEndpoint {
    private Map<String, List<String>> params;

    @OnOpen
    public void onOpen(Session session) {
        params = session.getRequestParameterMap();
    }

    @OnMessage
    public String demo(String msg) {
        return msg + "; (example 5) session ID " + params.get("sessionId").get(0);
    }
}

InformationsquelleAutor der Antwort Chad N B

Alle oben genannten Antworten zu Lesen lohnt, aber keiner von Ihnen löst OP ' s (und mein) problem.

Können Sie den Zugriff HttpSession, wenn ein WS Endpunkt ist die Eröffnung und übergabe an neu geschaffenen end-point-Instanz, aber niemand garantiert es existiert HttpSession Instanz!

Also müssen wir Schritt 0, bevor diese hacken (ich hasse JSR 365 Implementierung des WebSocket -).
Websocket - httpSession wird null zurückgegeben

InformationsquelleAutor der Antwort 9dan

Der einzige Weg, der funktioniert in allen Anwendungen, Servern verwenden ThreadLocal. Siehe:

https://java.net/jira/browse/WEBSOCKET_SPEC-235

InformationsquelleAutor der Antwort Ryan