Spring MVC能否从非Controller类修改URL？Go游戏客户端转Web咨询

Great question! Moving from a JavaFX desktop app to a Spring MVC web app means shifting from a desktop UI thread model to a browser-based HTTP/real-time communication model. Let’s break down your options clearly:

First: Why You Can’t Directly Modify URLs/Views from a Non-Controller Class #

In Spring MVC, web navigation and view rendering are tightly tied to HTTP request-response cycles. Non-controller classes (like your existing Socket connection thread) don’t have access to HttpServletRequest or HttpServletResponse objects, which are required to trigger redirects or view changes. Unlike JavaFX’s Platform.runLater (which directly updates the desktop UI thread), web apps separate backend logic from frontend UI—your Spring backend can’t directly manipulate the browser’s URL or DOM; it has to communicate changes to the frontend instead.

Feasible Solutions to Bridge Your Socket Thread and Web UI #

1. Replace Raw Sockets with WebSockets (Best for Real-Time Games) #

Since your Go game needs real-time updates, Spring WebSocket is the ideal replacement for your raw TCP Socket setup. WebSockets are a web-standard long connection protocol that lets your backend push messages directly to the frontend, which can then handle URL/View changes on its own.

Example Implementation:

Backend WebSocket Endpoint:

@ServerEndpoint("/game-websocket/{playerId}")
public class GameWebSocket {
    private Session session;
    private static final Map<String, GameWebSocket> activePlayers = new ConcurrentHashMap<>();

    @OnOpen
    public void onOpen(Session session, @PathParam("playerId") String playerId) {
        this.session = session;
        activePlayers.put(playerId, this);
    }

    // Modified from your original processCommands method
    private void processServerMessages() throws ClassNotFoundException, IOException {
        while (inputStream != null && keepRunning) {
            ServerMessage serverMessage = (ServerMessage) inputStream.readObject();
            
            // Push message directly to the frontend via WebSocket
            session.getBasicRemote().sendText(JSON.toJSONString(serverMessage));
            
            if (serverMessage instanceof EndGame) {
                keepRunning = false;
                // Send a final message to trigger frontend navigation
                session.getBasicRemote().sendText(JSON.toJSONString(new EndGamePayload(serverMessage.getWinner())));
            }
        }
        socket.close();
    }

    @OnClose
    public void onClose() {
        activePlayers.values().remove(this);
    }
}

Frontend JavaScript:

const playerId = /* Get current player ID from session/URL */;
const socket = new WebSocket(`ws://localhost:8080/game-websocket/${playerId}`);

socket.onmessage = (event) => {
    const message = JSON.parse(event.data);
    if (message.type === 'EndGame') {
        // Modify URL and redirect to results page
        window.location.href = `/game-result?winner=${message.winner}`;
    } else if (message.type === 'Move') {
        // Update the chessboard view directly in the browser
        updateChessboard(message.moveCoordinates);
    }
};

2. Use Spring Application Events to Communicate with Controllers #

If you need to keep your existing Socket logic (not recommended for real-time games), you can use Spring’s event system to pass messages from your Socket thread to a controller, which then notifies the frontend.

Example Implementation:

Custom Game Event:

public class GameMessageEvent extends ApplicationEvent {
    private final ServerMessage serverMessage;

    public GameMessageEvent(Object source, ServerMessage serverMessage) {
        super(source);
        this.serverMessage = serverMessage;
    }

    public ServerMessage getServerMessage() {
        return serverMessage;
    }
}

Socket Thread as a Spring Bean:

@Component
public class GameClientConnection {
    @Autowired
    private ApplicationEventPublisher eventPublisher;

    private void processCommands() throws ClassNotFoundException, IOException {
        while (inputStream != null && keepRunning) {
            ServerMessage serverMessage = (ServerMessage) inputStream.readObject();
            // Publish event to notify the controller
            eventPublisher.publishEvent(new GameMessageEvent(this, serverMessage));
            
            if (serverMessage instanceof EndGame) keepRunning = false;
        }
        socket.close();
    }
}

Controller to Listen for Events:

@Controller
public class GameStateController {
    // Track game states per user (use Spring Session for production)
    private final Map<String, ServerMessage> userGameStates = new ConcurrentHashMap<>();

    @EventListener
    public void handleGameMessage(GameMessageEvent event) {
        String userId = getCurrentUserIdFromSession();
        userGameStates.put(userId, event.getServerMessage());
    }

    // Frontend polls this endpoint for updates
    @GetMapping("/game-state")
    @ResponseBody
    public ServerMessage getCurrentGameState() {
        String userId = getCurrentUserIdFromSession();
        return userGameStates.getOrDefault(userId, null);
    }
}

Frontend Polling:

// Poll every second for game updates
setInterval(() => {
    fetch('/game-state')
        .then(res => res.json())
        .then(message => {
            if (message?.type === 'EndGame') {
                window.location.href = `/game-result?winner=${message.winner}`;
            } else if (message?.type === 'Move') {
                updateChessboard(message.moveCoordinates);
            }
        });
}, 1000);

Optimal Recommendation #

Use WebSockets—it’s the most efficient and natural fit for real-time games like Go. It eliminates the need for polling, provides instant updates, and lets the frontend handle URL/view changes directly, which aligns with web app best practices.

内容的提问来源于stack exchange，提问作者Mateusz Kochanek