Mengendalikan Ralat WebSocket dengan Baik

const ws = new WebSocket("ws://localhost:8080/my-ws");

ws.onopen = () => {
  console.log("Connected!");
};

ws.onmessage = (event) => {
  console.log(`Received: ${event.data}`);
};

ws.onerror = (error) => {
  console.error("WebSocket Error: ", error);
  // This is a generic error, often followed by onclose
};

ws.onclose = (event) => {
  if (event.wasClean) {
    console.log(`Closed cleanly, code=${event.code}, reason=${event.reason}`);
  } else {
    console.error(`Connection died, code=${event.code}, reason=${event.reason}`);
    // Handle unexpected closure, e.g., attempt reconnect
  }
};

// To trigger an error, try connecting to a non-existent port or URL.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.handler.annotation.MessageExceptionHandler;
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.handler.annotation.SendTo;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.stereotype.Controller;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;

@SpringBootApplication
public class ErrorHandlingApp {
    public static void main(String[] args) {
        SpringApplication.run(ErrorHandlingApp.class, args);
    }
}

@Configuration
@EnableWebSocketMessageBroker
class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
    @Override
    public void configureMessageBroker(MessageBrokerRegistry config) {
        config.enableSimpleBroker("/topic");
        config.setApplicationDestinationPrefixes("/app");
    }

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/ws").withSockJS();
    }
}

@Controller
class ChatController {
    @MessageMapping("/hello")
    @SendTo("/topic/greetings")
    public String greeting(String message) throws Exception {
        if (message.contains("error")) {
            throw new IllegalArgumentException("Message contains 'error' keyword!");
        }
        return "Hello, " + message + "!";
    }

    @MessageExceptionHandler
    @SendTo("/topic/errors")
    public String handleIllegalArgumentException(IllegalArgumentException ex) {
        return "Error: " + ex.getMessage();
    }
}

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
import org.springframework.web.socket.handler.TextWebSocketHandler;
import org.springframework.web.socket.handler.WebSocketHandlerDecorator;
import org.springframework.web.socket.handler.WebSocketHandlerDecoratorFactory;

@SpringBootApplication
@EnableWebSocket
public class DecoratorApp implements WebSocketConfigurer {
    public static void main(String[] args) {
        SpringApplication.run(DecoratorApp.class, args);
    }

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(myHandler(), "/ws-decorator").setAllowedOrigins("*");
    }

    public WebSocketHandler myHandler() {
        return new TextWebSocketHandler() {
            @Override
            public void afterConnectionEstablished(WebSocketSession session) throws Exception {
                System.out.println("Handler: Connection established for " + session.getId());
            }
            @Override
            public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
                System.out.println("Handler: Connection closed for " + session.getId() + " with status " + status);
            }
        };
    }

    @org.springframework.context.annotation.Bean
    public WebSocketHandlerDecoratorFactory decoratorFactory() {
        return (handler) -> new WebSocketHandlerDecorator(handler) {
            @Override
            public void afterConnectionEstablished(WebSocketSession session) throws Exception {
                System.out.println("Decorator: Client connected: " + session.getId());
                super.afterConnectionEstablished(session);
            }
            @Override
            public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
                System.err.println("Decorator: Transport error for session " + session.getId() + ": " + exception.getMessage());
                // You could send a generic error message to the client here if session is still open
                super.handleTransportError(session, exception);
            }
            @Override
            public void afterConnectionClosed(WebSocketSession session, CloseStatus closeStatus) throws Exception {
                System.out.println("Decorator: Client disconnected: " + session.getId() + ", Status: " + closeStatus.getCode());
                super.afterConnectionClosed(session, closeStatus);
            }
        };
    }
}