feature: REST- mit WebSocket-Verbindung in Bezug bringen können

Thomas Ziemer
1 parent ecbbc717
Showing 6 changed files with 69 additions and 31 deletions
src/main/java/net/ziemers/swxercise/lg/user/service/SessionContext.java
src/main/java/net/ziemers/swxercise/lg/user/service/UserService.java
src/main/java/net/ziemers/swxercise/ui/UserViewController.java
src/main/java/net/ziemers/swxercise/ui/utils/RestResponse.java
src/main/java/net/ziemers/swxercise/ui/ws/WebSocketController.java
src/main/webapp/websockets.html
@@ -14,6 +14,8 @@ public class SessionContext implements java.io.Serializable {
  
 	private User user = null;
  
+	private String sessionId = "";
+
     public User getUser() {
         return user;
     }
@@ -22,9 +24,21 @@ public class SessionContext implements java.io.Serializable {
         this.user = user;
     }
  
-    public boolean login(final User user) {
+    public String getSessionId() { return sessionId; }
+
+    private void setSessionId(String sessionId) { this.sessionId = sessionId; }
+
+    /**
+     * Meldet einen Benutzer in diesem Session-Kontext an.
+     *
+     * @param user das {@link User}-Objekt des Benutzers dieses Session-Kontexts
+     * @param sessionId die Session-Id dieser Benutzer-Session
+     * @return Liefert <code>true</code> zurück, wenn der Benutzer am Session-Kontext angemeldet werden konnte.
+     */
+    public boolean login(final User user, final String sessionId) {
         if (getUser() == null) {
             setUser(user);
+            setSessionId(sessionId);
             return true;
         }
         return false;
@@ -34,11 +34,14 @@ public class UserService {
      * Meldet den Benutzer im SessionContext an.
      *
      * @param dto das {@link UserDto} enthält die Eigenschaften des anzumeldenden Benutzers
+     * @param sessionId die Session-Id, über die diese Benutzer-Authentifizierung erfolgt
      * @return <code>true</code>, wenn die Anmeldung erfolgreich war.
      */
-    public boolean loginUser(UserDto dto) {
+    public boolean loginUser(UserDto dto, String sessionId) {
         final User user = dao.findByUsername(dto.getUsername());
-        return user != null && user.getProfile().isValidPassword(dto.getPassword()) && sessionContext.login(user);
+        return user != null
+                && user.getProfile().isValidPassword(dto.getPassword())
+                && sessionContext.login(user, sessionId);
     }
  
     /**
@@ -5,7 +5,9 @@ import java.util.Collection;
 import javax.annotation.security.RolesAllowed;
 import javax.enterprise.context.ApplicationScoped;
 import javax.inject.Inject;
+import javax.servlet.http.HttpServletRequest;
 import javax.ws.rs.*;
+import javax.ws.rs.core.Context;
 import javax.ws.rs.core.MediaType;
  
 import net.ziemers.swxercise.lg.user.enums.RightState;
@@ -83,6 +85,7 @@ public class UserViewController {
     @RolesAllowed(RightState.Constants.LOGGED_IN)
     public User getUser() {
         logger.info("Trying to get user's profile info.");
+
         return userService.findUser(); }
  
     /**
@@ -199,6 +202,7 @@ public class UserViewController {
      * Aufruf:
      * POST http://localhost:8080/swxercise/rest/v1/user/login
      *
+     * @param request das {@link HttpServletRequest}-Objekt des augenblicklichen HTTP-Requests
      * @param dto das mittels der als JSON-Objekt übergebenenen Eigenschaften zu füllende {@link UserDto}
      * @return ein {@link ResponseState}-Objekt mit den Ergebnisinformationen des Aufrufs.
      */
@@ -207,10 +211,14 @@ public class UserViewController {
     @Consumes(MediaType.APPLICATION_JSON)
     @Produces(MediaType.APPLICATION_JSON)
     @RolesAllowed(RightState.Constants.NOT_LOGGED_IN)
-    public RestResponse loginUser(UserDto dto) {
-        logger.info("Trying to log-in user '{}'.", dto.getUsername());
-        if (userService.loginUser(dto)) {
-            return new RestResponse();
+    public RestResponse loginUser(@Context HttpServletRequest request, UserDto dto) {
+        // wir benötigen die Session-Id später, um REST-Zugriffe mit WebSockets in Bezug zu bringen
+        String sessionId = request.getSession(false).getId();
+
+        logger.info("Trying to log-in user '{}' with session id #{}.", dto.getUsername(), sessionId);
+
+        if (userService.loginUser(dto, sessionId)) {
+            return new RestResponse(sessionId);
         }
         return new RestResponse(ResponseState.FAILED);
     }
@@ -229,6 +237,7 @@ public class UserViewController {
     @RolesAllowed(RightState.Constants.LOGGED_IN)
     public RestResponse logoutUser() {
         logger.info("Trying to log-out user.");
+
         if (userService.logoutUser()) {
             return new RestResponse();
         }
@@ -21,6 +21,11 @@ public class RestResponse {
         this.message = message;
     }
  
+    public RestResponse(final String message) {
+        this();
+        this.message = message;
+    }
+
     public int getResponseCode() {
         return responseState.getResponseCode();
     }
@@ -15,8 +15,8 @@ import javax.websocket.server.PathParam;
 import javax.websocket.server.ServerEndpoint;
 import java.io.IOException;
 import java.util.Collections;
-import java.util.HashSet;
-import java.util.Set;
+import java.util.HashMap;
+import java.util.Map;
  
 /**
  * Stub für die WebSocket-Unterstützung.
@@ -29,11 +29,9 @@ import java.util.Set;
         decoders = { WebSocketJson.MessageDecoder.class } )
 public class WebSocketController {
  
-    static final String serverEndpointPath = "/ws/api/v1/anEndpoint/{aParameter}";
+    static final String serverEndpointPath = "/ws/api/v1/anEndpoint/{restSessionid}";
  
-    // Eine Verknüpfung zwischen der WebSocket-Session und dem SessionContext des per REST
-    // angemeldeten Benutzers muss irgendwie auch noch realisiert werden. :)
-    private static Set<Session> peers = Collections.synchronizedSet(new HashSet<>());
+    private static Map<Session, String> peers = Collections.synchronizedMap(new HashMap<>());
  
     private Logger logger;
  
@@ -43,31 +41,37 @@ public class WebSocketController {
     }
  
     /**
-     * Callback-Methode für das Öffnen einer neuen WebSocket-Verbindung.
+     * Callback-Methode für das Öffnen einer neuen WebSocket-Verbindung. <code>restSessionId</code>
+     * wird benötigt, um die WebSocket-Verbindung mit einer REST-Authentifizierung in Bezug bringen
+     * zu können.
      *
-     * @param session das {@link Session}-Objekt der neuen WebSocket-Verbindung
+     * @param wsSession das {@link Session}-Objekt der neuen WebSocket-Verbindung
+     * @param restSessionId die Session-Id einer vorangegangenen REST-Authentifizierung
      */
     @OnOpen
-    public void onOpen(Session session) {
-        logger.info("WebSocket opened with session id #{}", session.getId());
-        peers.add(session);
+    public void onOpen(Session wsSession, @PathParam("restSessionid") String restSessionId) {
+        logger.info("WebSocket {} opened with session id #{}", restSessionId, wsSession.getId());
+
+        // wir können später über die gegebene WebSocket-Session die REST-Session-Id dieses WebSockets ermitteln
+        peers.putIfAbsent(wsSession, restSessionId);
     }
  
     /**
      * Callback-Methode, die den Empfang einer neuen WebSocket-Nachricht signalisiert.
      *
      * @param json der JSON-strukturierte Inhalt der WebSocket-Nachricht
-     * @param session das {@link Session}-Objekt der sendenden WebSocket-Verbindung
+     * @param wsSession das {@link Session}-Objekt der sendenden WebSocket-Verbindung
      */
     @OnMessage
-    public void onMessage(WebSocketJson json,
-                          Session session,
-                          @PathParam("aParameter") String param) throws IOException, EncodeException {
-        logger.info("WebSocket Message '{}/{}' received by session id #{}",
-                json.getMessage(), param, session.getId());
+    public void onMessage(WebSocketJson json, Session wsSession) throws IOException, EncodeException {
+        // die Map liefert uns zur gegebenen WebSocket-Session die REST-Session-Id zurück
+        String restSessionId = peers.get(wsSession);
+
+        logger.info("WebSocket {} Message '{}' received by session id #{}",
+                restSessionId, json.getMessage(), wsSession.getId());
         try {
-            // Wir senden die empfangene Nachricht gleich wieder zurück. Das Marshalling geschieht automatisch.
-            session.getBasicRemote().sendObject(json);
+            // Wir senden die empfangene Nachricht gleich wieder zurück. Das JSON-Marshalling geschieht automatisch.
+            wsSession.getBasicRemote().sendObject(json);
         } catch (IOException e) {
             e.printStackTrace();
         }
@@ -87,12 +91,12 @@ public class WebSocketController {
      * Callback-Methode für das Schließen einer geöffneten WebSocket-Verbindung.
      *
      * @param reason die Ursache für das Schließen der WebSocket-Verbindung
-     * @param session das {@link Session}-Objekt der geschlossenen WebSocket-Verbindung
+     * @param wsSession das {@link Session}-Objekt der geschlossenen WebSocket-Verbindung
      */
     @OnClose
-    public void onClose(CloseReason reason, Session session) {
-        logger.info("Closing WebSocket due to '{}' by session id #{}", reason.getReasonPhrase(), session.getId());
-        peers.remove(session);
+    public void onClose(CloseReason reason, Session wsSession) {
+        logger.info("Closing WebSocket due to '{}' by session id #{}", reason.getReasonPhrase(), wsSession.getId());
+        peers.remove(wsSession);
     }
  
 }
@@ -7,7 +7,10 @@
  
     <body>
         <script>
-            var url = "ws://localhost:8080/swxercise/ws/api/v1/anEndpoint/4711";
+            // sei "4711" die in einer vorangegangenen REST-Authentifizierung ermittelte "restSessionId"
+            var restSessionId = 4711;
+
+            var url = "ws://localhost:8080/swxercise/ws/api/v1/anEndpoint/" + restSessionId;
             var webSocket = new WebSocket(url);
  
             // Callback-Methoden für die WebSocket-Kommunikation