import org.springframework.messaging.simp.annotation.SendToUser; //导入依赖的package包/类
@ApiMethod(description = "Create a new lobby.")
@MessageMapping("/lobby/create")
@SendToUser("/queue/lobby/joined")
public Lobby createGame(@Validated CreateGameAction action, Principal principal) {
    checkThatUserIsNotInAGame(principal, "cannot create another game");

    Player gameOwner = playerRepository.find(principal.getName());
    Lobby lobby = lobbyRepository.create(action.getGameName(), gameOwner);

    logger.info("Game '{}' ({}) created by {} ({})", lobby.getName(), lobby.getId(), gameOwner.getDisplayName(),
            gameOwner.getUsername());

    // notify everyone that a new game exists
    template.convertAndSend("/topic/games", Collections.singletonList(lobby));
    return lobby;
}
 

import org.springframework.messaging.simp.annotation.SendToUser; //导入依赖的package包/类
@MessageExceptionHandler(Exception.class)
@SendToUser("${appverse.frontfacade.websocket.exceptionHandler.path:/queue/errors}")
public ResponseDataVO handleError(Exception exception) {
    ResponseDataVO data = new ResponseDataVO();
    ErrorVO error = new ErrorVO();

    Long code = 500L;
    if(exception instanceof AbstractException) {
        if (((AbstractException) exception).getCode() != null) {
            code = ((AbstractException) exception).getCode();
        }
    }
    error.setCode(code);
    error.setMessage(exception.getMessage());
    data.setErrorVO(error);
    return data;
}
 

import org.springframework.messaging.simp.annotation.SendToUser; //导入依赖的package包/类
/**
 * direct message handler that receives a join message from a device. When a device joins, a session is attempted to
 * be found within a tolerated geo-proximity. if one is found, the device is added to it and returned, if not, a
 * new session is created.
 *
 * @param   j   a stringified JoinMessage sent from the device seeking to join a session
 * @return      stringified JoinResponse
 *
 * @see     JoinMessage
 * @see     JoinResponse
 */
@MessageMapping("/join")
@SendToUser("/queue/device")
public String join(JoinMessage j) {
    String joinType = j.getType().toString();
    switch(joinType){
        case "enter":
            break;
        case "exit":
            Session session = (Session) this.sessionService.get(j);
            String uuid = session.getUuid().toString();
            //Return join
            String joinResponse = gson.toJson(new JoinResponse(session.getApplicationId(), uuid, session.getDevices(), session.getRoom()), JoinResponse.class);
            if(logger.isDebugEnabled())
                logger.debug(String.format("JOIN RESPONSE: %s", joinResponse));
            return joinResponse;
        default:
            logger.error(String.format("Detected SyncType %s not supported", joinType));
    }
    return null;
}
 

import org.springframework.messaging.simp.annotation.SendToUser; //导入依赖的package包/类
/**
 * Direct message handler that receives pair message from a device. When device joins, session is found or a new
 * pair session is created.
 *
 * @param p     Stringified PairMessage sent from device seeking to pair up with another device
 * @return      Stringified PairResponse
 *
 * @see         PairResponse
 * @see         PairMessage
 */
@MessageMapping("/pair")
@SendToUser("/queue/device")
public String pair(PairMessage p){
    String pairType = p.getType().toString();
    switch(pairType){
        case "enter":
            break;
        case "exit":
            Session session = this.sessionService.pair(p);
            String uuid = session.getUuid().toString();
            // Return pair
            String pairResponse = gson.toJson(new PairResponse(session.getApplicationId(), uuid,session.getDevices()),PairResponse.class);
            if(logger.isDebugEnabled()){
                logger.debug(String.format("PAIR RESPONSE: %s", pairResponse));
            }
            return pairResponse;
        default:
            logger.error(String.format("Detected SyncType %s not supported", pairType));
    }
    return null;
}
 

import org.springframework.messaging.simp.annotation.SendToUser; //导入依赖的package包/类
@Override
public boolean supportsReturnType(MethodParameter returnType) {
	if (returnType.getMethodAnnotation(SendTo.class) != null ||
			returnType.getMethodAnnotation(SendToUser.class) != null) {
		return true;
	}
	return (!this.annotationRequired);
}
 

import org.springframework.messaging.simp.annotation.SendToUser; //导入依赖的package包/类
@ApiMethod(description = "Creates/updates the player's name (for the user's session)")
@MessageMapping("/chooseName")
@SendToUser("/queue/nameChoice")
public Player chooseName(@Validated ChooseNameAction action, Principal principal) {
    String username = principal.getName();
    Player player = playerRepository.createOrUpdate(username, action.getPlayerName());

    logger.info("Player '{}' chose the name '{}'", username, player.getDisplayName());
    return player;
}
 

import org.springframework.messaging.simp.annotation.SendToUser; //导入依赖的package包/类
@ApiMethod(description = "Join an existing lobby.")
@MessageMapping("/lobby/join")
@SendToUser("/queue/lobby/joined")
public Lobby joinGame(@Validated JoinGameAction action, Principal principal) {
    checkThatUserIsNotInAGame(principal, "cannot join another game");

    Lobby lobby = lobbyRepository.find(action.getGameId());
    Player newPlayer = playerRepository.find(principal.getName());
    lobby.addPlayer(newPlayer);

    logger.info("Player '{}' ({}) joined game {}", newPlayer.getDisplayName(), newPlayer.getUsername(),
            lobby.getName());
    lobbyController.sendLobbyUpdateToPlayers(lobby);
    return lobby;
}
 

import org.springframework.messaging.simp.annotation.SendToUser; //导入依赖的package包/类
@MessageExceptionHandler
@SendToUser("/queue/errors")
public UIError handleUserInputError(UserInputException exception) {
    logger.error("Incorrect user input: " + exception.getMessage());
    String messageKey = exception.getMessageResourceKey();
    String message = messageSource.getMessage(messageKey, exception.getParams(), messageKey, Locale.US);
    return new UIError(messageKey, message, ErrorType.USER_INPUT);
}
 

import org.springframework.messaging.simp.annotation.SendToUser; //导入依赖的package包/类
@MessageExceptionHandler
@SendToUser("/queue/errors")
public UIError handleValidationError(MethodArgumentNotValidException exception) {
    logger.error("Invalid input", exception);
    UIError uiError = new UIError(ERROR_CODE_VALIDATION, ERROR_MSG_VALIDATION, ErrorType.VALIDATION);

    BindingResult result = exception.getBindingResult();
    if (result != null) {
        List<ObjectError> errors = result.getAllErrors();
        uiError.addDetails(errors);
    }
    return uiError;
}
 

import org.springframework.messaging.simp.annotation.SendToUser; //导入依赖的package包/类
/**
 * direct-message handler to send messaging errors to a device in session
 *
 * @param   exception   the exception that was thrown by the messaging error
 * @return              String, the message sent back to the device containing the error
 */
@MessageExceptionHandler
@SendToUser("/queue/errors")
public String handleException(Throwable exception) {
    logger.error("Handling exception: ", exception);
    return exception.getMessage();
}
 

import org.springframework.messaging.simp.annotation.SendToUser; //导入依赖的package包/类
@ApiOperation("WebSocket单播：客户端接收一对一消息的主题应该是“/user/” + 用户Id + “/message” ")
@SendToUser("/message")
public SocketMessage sendToUser(SocketMessage message){
    return message;
}
 

import org.springframework.messaging.simp.annotation.SendToUser; //导入依赖的package包/类
@MessageMapping("/ws-auth")
@SendToUser(value = "/queue/ws-auth", broadcast = false)
public Person authenticatedUser(Principal principal) {
    return new Person(new PersonalData(principal.getName(), principal.getName()));
}
 

import org.springframework.messaging.simp.annotation.SendToUser; //导入依赖的package包/类
@Override
public boolean supportsReturnType(MethodParameter returnType) {
	return (returnType.getMethodAnnotation(SubscribeMapping.class) != null &&
			returnType.getMethodAnnotation(SendTo.class) == null &&
			returnType.getMethodAnnotation(SendToUser.class) == null);
}
 

import org.springframework.messaging.simp.annotation.SendToUser; //导入依赖的package包/类
@SendToUser
public String handleAndSendToUserDefaultDestination() {
	return PAYLOAD;
}
 

import org.springframework.messaging.simp.annotation.SendToUser; //导入依赖的package包/类
@SendToUser(broadcast = false)
public String handleAndSendToUserDefaultDestinationSingleSession() {
	return PAYLOAD;
}
 

import org.springframework.messaging.simp.annotation.SendToUser; //导入依赖的package包/类
@SendToUser({"/dest1", "/dest2"})
public String handleAndSendToUser() {
	return PAYLOAD;
}
 

import org.springframework.messaging.simp.annotation.SendToUser; //导入依赖的package包/类
@SendToUser(destinations = { "/dest1", "/dest2" }, broadcast = false)
public String handleAndSendToUserSingleSession() {
	return PAYLOAD;
}
 

import org.springframework.messaging.simp.annotation.SendToUser; //导入依赖的package包/类
@MessageExceptionHandler
@SendToUser("/queue/error")
public String handleException(IllegalArgumentException ex) {
	return "Got error: " + ex.getMessage();
}
 

import org.springframework.messaging.simp.annotation.SendToUser; //导入依赖的package包/类
@MessageExceptionHandler
@SendToUser("/queue/errors")
public UIError handleConversionError(MessageConversionException exception) {
    logger.error("Error interpreting the message", exception);
    return new UIError(ERROR_CODE_CONVERSION, ERROR_MSG_CONVERSION, ErrorType.VALIDATION);
}
 

import org.springframework.messaging.simp.annotation.SendToUser; //导入依赖的package包/类
@MessageExceptionHandler
@SendToUser("/queue/errors")
public UIError handleApiError(ApiMisuseException exception) {
    logger.error("Invalid API input", exception);
    return new UIError(exception.getClass().getSimpleName(), exception.getMessage(), ErrorType.CLIENT);
}