How to use

getUser

method

in

org.springframework.messaging.simp.user.SimpUserRegistry

@Override
@Nullable
public SimpUser getUser(String userName) {
  // Prefer remote registries due to cross-server SessionLookup
  for (UserRegistrySnapshot registry : this.remoteRegistries.values()) {
    SimpUser user = registry.getUserMap().get(userName);
    if (user != null) {
      return user;
    }
  }
  return this.localRegistry.getUser(userName);
}

@Test
public void getUserFromLocalRegistry() throws Exception {
  SimpUser user = Mockito.mock(SimpUser.class);
  Set<SimpUser> users = Collections.singleton(user);
  when(this.localRegistry.getUsers()).thenReturn(users);
  when(this.localRegistry.getUserCount()).thenReturn(1);
  when(this.localRegistry.getUser("joe")).thenReturn(user);
  assertEquals(1, this.registry.getUserCount());
  assertSame(user, this.registry.getUser("joe"));
}

@Test  // SPR-13800
public void getSessionsWhenUserIsConnectedToMultipleServers() throws Exception {
  // Add user to local registry
  TestSimpUser localUser = new TestSimpUser("joe");
  TestSimpSession localSession = new TestSimpSession("sess123");
  localUser.addSessions(localSession);
  when(this.localRegistry.getUser("joe")).thenReturn(localUser);
  // Prepare broadcast message from remote server
  TestSimpUser remoteUser = new TestSimpUser("joe");
  TestSimpSession remoteSession = new TestSimpSession("sess456");
  remoteUser.addSessions(remoteSession);
  SimpUserRegistry remoteRegistry = mock(SimpUserRegistry.class);
  when(remoteRegistry.getUsers()).thenReturn(Collections.singleton(remoteUser));
  Object remoteRegistryDto = new MultiServerUserRegistry(remoteRegistry).getLocalRegistryDto();
  Message<?> message = this.converter.toMessage(remoteRegistryDto, null);
  // Add remote registry
  this.registry.addRemoteRegistryDto(message, this.converter, 20000);
  assertEquals(1, this.registry.getUserCount());
  SimpUser user = this.registry.getUsers().iterator().next();
  assertTrue(user.hasSessions());
  assertEquals(2, user.getSessions().size());
  assertThat(user.getSessions(), containsInAnyOrder(localSession, remoteSession));
  assertSame(localSession, user.getSession("sess123"));
  assertEquals(remoteSession, user.getSession("sess456"));
  user = this.registry.getUser("joe");
  assertEquals(2, user.getSessions().size());
  assertThat(user.getSessions(), containsInAnyOrder(localSession, remoteSession));
  assertSame(localSession, user.getSession("sess123"));
  assertEquals(remoteSession, user.getSession("sess456"));
}

private Set<String> getSessionIdsByUser(String userName, @Nullable String sessionId) {
  Set<String> sessionIds;
  SimpUser user = this.userRegistry.getUser(userName);
  if (user != null) {
    if (sessionId != null && user.getSession(sessionId) != null) {
      sessionIds = Collections.singleton(sessionId);
    }
    else {
      Set<SimpSession> sessions = user.getSessions();
      sessionIds = new HashSet<>(sessions.size());
      for (SimpSession session : sessions) {
        sessionIds.add(session.getId());
      }
    }
  }
  else {
    sessionIds = Collections.emptySet();
  }
  return sessionIds;
}

public Map<String, SimpSession> findSessions(String userName) {
  Map<String, SimpSession> map = new HashMap<>(4);
  SimpUser user = localRegistry.getUser(userName);
  if (user != null) {
    for (SimpSession session : user.getSessions()) {
      map.put(session.getId(), session);
    }
  }
  for (UserRegistrySnapshot registry : remoteRegistries.values()) {
    TransferSimpUser transferUser = registry.getUserMap().get(userName);
    if (transferUser != null) {
      transferUser.addSessions(map);
    }
  }
  return map;
}

@Before
public void setup() {
  TestSimpUser simpUser = new TestSimpUser("joe");
  simpUser.addSessions(new TestSimpSession("123"));
  this.registry = mock(SimpUserRegistry.class);
  when(this.registry.getUser("joe")).thenReturn(simpUser);
  this.resolver = new DefaultUserDestinationResolver(this.registry);
}

@Test
public void handleMessageEncodedUserName() {
  String userName = "http://joe.openid.example.org/";
  TestSimpUser simpUser = new TestSimpUser(userName);
  simpUser.addSessions(new TestSimpSession("openid123"));
  when(this.registry.getUser(userName)).thenReturn(simpUser);
  String destination = "/user/" + StringUtils.replace(userName, "/", "%2F") + "/queue/foo";
  Message<?> message = createMessage(SimpMessageType.MESSAGE, new TestPrincipal("joe"), null, destination);
  UserDestinationResult actual = this.resolver.resolveDestination(message);
  assertEquals(1, actual.getTargetDestinations().size());
  assertEquals("/queue/foo-useropenid123", actual.getTargetDestinations().iterator().next());
}

@Test // SPR-11325
public void handleSubscribeOneUserMultipleSessions() {
  TestSimpUser simpUser = new TestSimpUser("joe");
  simpUser.addSessions(new TestSimpSession("123"), new TestSimpSession("456"));
  when(this.registry.getUser("joe")).thenReturn(simpUser);
  TestPrincipal user = new TestPrincipal("joe");
  Message<?> message = createMessage(SimpMessageType.SUBSCRIBE, user, "456", "/user/queue/foo");
  UserDestinationResult actual = this.resolver.resolveDestination(message);
  assertEquals(1, actual.getTargetDestinations().size());
  assertEquals("/queue/foo-user456", actual.getTargetDestinations().iterator().next());
}

@Test
public void handleMessage() {
  TestSimpUser simpUser = new TestSimpUser("joe");
  simpUser.addSessions(new TestSimpSession("123"));
  when(this.registry.getUser("joe")).thenReturn(simpUser);
  given(this.brokerChannel.send(Mockito.any(Message.class))).willReturn(true);
  this.handler.handleMessage(createWith(SimpMessageType.MESSAGE, "joe", "123", "/user/joe/queue/foo"));
  ArgumentCaptor<Message> captor = ArgumentCaptor.forClass(Message.class);
  Mockito.verify(this.brokerChannel).send(captor.capture());
  SimpMessageHeaderAccessor accessor = SimpMessageHeaderAccessor.wrap(captor.getValue());
  assertEquals("/queue/foo-user123", accessor.getDestination());
  assertEquals("/user/queue/foo", accessor.getFirstNativeHeader(ORIGINAL_DESTINATION));
}

@Test
public void handleMessageFromBrokerWithActiveSession() {
  TestSimpUser simpUser = new TestSimpUser("joe");
  simpUser.addSessions(new TestSimpSession("123"));
  when(this.registry.getUser("joe")).thenReturn(simpUser);
  this.handler.setBroadcastDestination("/topic/unresolved");
  given(this.brokerChannel.send(Mockito.any(Message.class))).willReturn(true);
  StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.MESSAGE);
  accessor.setSessionId("system123");
  accessor.setDestination("/topic/unresolved");
  accessor.setNativeHeader(ORIGINAL_DESTINATION, "/user/joe/queue/foo");
  accessor.setNativeHeader("customHeader", "customHeaderValue");
  accessor.setLeaveMutable(true);
  byte[] payload = "payload".getBytes(StandardCharsets.UTF_8);
  this.handler.handleMessage(MessageBuilder.createMessage(payload, accessor.getMessageHeaders()));
  ArgumentCaptor<Message> captor = ArgumentCaptor.forClass(Message.class);
  Mockito.verify(this.brokerChannel).send(captor.capture());
  assertNotNull(captor.getValue());
  SimpMessageHeaderAccessor headers = SimpMessageHeaderAccessor.wrap(captor.getValue());
  assertEquals("/queue/foo-user123", headers.getDestination());
  assertEquals("/user/queue/foo", headers.getFirstNativeHeader(ORIGINAL_DESTINATION));
  assertEquals("customHeaderValue", headers.getFirstNativeHeader("customHeader"));
  assertArrayEquals(payload, (byte[]) captor.getValue().getPayload());
}

@Test // SPR-12444
public void handleMessageToOtherUser() {
  TestSimpUser otherSimpUser = new TestSimpUser("anna");
  otherSimpUser.addSessions(new TestSimpSession("456"));
  when(this.registry.getUser("anna")).thenReturn(otherSimpUser);
  TestPrincipal user = new TestPrincipal("joe");
  TestPrincipal otherUser = new TestPrincipal("anna");
  String sourceDestination = "/user/anna/queue/foo";
  Message<?> message = createMessage(SimpMessageType.MESSAGE, user, "456", sourceDestination);
  UserDestinationResult actual = this.resolver.resolveDestination(message);
  assertEquals(sourceDestination, actual.getSourceDestination());
  assertEquals(1, actual.getTargetDestinations().size());
  assertEquals("/queue/foo-user456", actual.getTargetDestinations().iterator().next());
  assertEquals("/user/queue/foo", actual.getSubscribeDestination());
  assertEquals(otherUser.getName(), actual.getUser());
}

@Override
@Nullable
public SimpUser getUser(String userName) {
  // Prefer remote registries due to cross-server SessionLookup
  for (UserRegistrySnapshot registry : this.remoteRegistries.values()) {
    SimpUser user = registry.getUserMap().get(userName);
    if (user != null) {
      return user;
    }
  }
  return this.localRegistry.getUser(userName);
}

public Map<String, SimpSession> findSessions(String userName) {
  Map<String, SimpSession> map = new HashMap<>(4);
  SimpUser user = localRegistry.getUser(userName);
  if (user != null) {
    for (SimpSession session : user.getSessions()) {
      map.put(session.getId(), session);
    }
  }
  for (UserRegistrySnapshot registry : remoteRegistries.values()) {
    TransferSimpUser transferUser = registry.getUserMap().get(userName);
    if (transferUser != null) {
      transferUser.addSessions(map);
    }
  }
  return map;
}

private Set<String> getSessionIdsByUser(String userName, @Nullable String sessionId) {
  Set<String> sessionIds;
  SimpUser user = this.userRegistry.getUser(userName);
  if (user != null) {
    if (sessionId != null && user.getSession(sessionId) != null) {
      sessionIds = Collections.singleton(sessionId);
    }
    else {
      Set<SimpSession> sessions = user.getSessions();
      sessionIds = new HashSet<>(sessions.size());
      for (SimpSession session : sessions) {
        sessionIds.add(session.getId());
      }
    }
  }
  else {
    sessionIds = Collections.emptySet();
  }
  return sessionIds;
}

@Override
@Nullable
public SimpUser getUser(String userName) {
  // Prefer remote registries due to cross-server SessionLookup
  for (UserRegistrySnapshot registry : this.remoteRegistries.values()) {
    SimpUser user = registry.getUserMap().get(userName);
    if (user != null) {
      return user;
    }
  }
  return this.localRegistry.getUser(userName);
}

@Override
@Nullable
public SimpUser getUser(String userName) {
  // Prefer remote registries due to cross-server SessionLookup
  for (UserRegistrySnapshot registry : this.remoteRegistries.values()) {
    SimpUser user = registry.getUserMap().get(userName);
    if (user != null) {
      return user;
    }
  }
  return this.localRegistry.getUser(userName);
}

public Map<String, SimpSession> findSessions(String userName) {
  Map<String, SimpSession> map = new HashMap<>(4);
  SimpUser user = localRegistry.getUser(userName);
  if (user != null) {
    for (SimpSession session : user.getSessions()) {
      map.put(session.getId(), session);
    }
  }
  for (UserRegistrySnapshot registry : remoteRegistries.values()) {
    TransferSimpUser transferUser = registry.getUserMap().get(userName);
    if (transferUser != null) {
      transferUser.addSessions(map);
    }
  }
  return map;
}

public Map<String, SimpSession> findSessions(String userName) {
  Map<String, SimpSession> map = new HashMap<>(4);
  SimpUser user = localRegistry.getUser(userName);
  if (user != null) {
    for (SimpSession session : user.getSessions()) {
      map.put(session.getId(), session);
    }
  }
  for (UserRegistrySnapshot registry : remoteRegistries.values()) {
    TransferSimpUser transferUser = registry.getUserMap().get(userName);
    if (transferUser != null) {
      transferUser.addSessions(map);
    }
  }
  return map;
}

private Set<String> getSessionIdsByUser(String userName, @Nullable String sessionId) {
  Set<String> sessionIds;
  SimpUser user = this.userRegistry.getUser(userName);
  if (user != null) {
    if (sessionId != null && user.getSession(sessionId) != null) {
      sessionIds = Collections.singleton(sessionId);
    }
    else {
      Set<SimpSession> sessions = user.getSessions();
      sessionIds = new HashSet<>(sessions.size());
      for (SimpSession session : sessions) {
        sessionIds.add(session.getId());
      }
    }
  }
  else {
    sessionIds = Collections.emptySet();
  }
  return sessionIds;
}

private Set<String> getSessionIdsByUser(String userName, @Nullable String sessionId) {
  Set<String> sessionIds;
  SimpUser user = this.userRegistry.getUser(userName);
  if (user != null) {
    if (sessionId != null && user.getSession(sessionId) != null) {
      sessionIds = Collections.singleton(sessionId);
    }
    else {
      Set<SimpSession> sessions = user.getSessions();
      sessionIds = new HashSet<>(sessions.size());
      for (SimpSession session : sessions) {
        sessionIds.add(session.getId());
      }
    }
  }
  else {
    sessionIds = Collections.emptySet();
  }
  return sessionIds;
}