// build.gradle.kts
dependencies {
    implementation("org.springframework.boot:spring-boot-starter-websocket")
    implementation("com.fasterxml.jackson.module:jackson-module-kotlin") // JSON 支持
}

@Configuration
@EnableWebSocket
class WebSocketConfig : WebSocketConfigurer {

    @Autowired
    lateinit var myWebSocketHandler: MyWebSocketHandler

    @Autowired
    lateinit var handshakeInterceptor: AuthHandshakeInterceptor

    override fun registerWebSocketHandlers(registry: WebSocketHandlerRegistry) {
        registry.addHandler(myWebSocketHandler, "/ws")
            .addInterceptors(handshakeInterceptor)
            .setAllowedOrigins("*") // 生產(chǎn)環(huán)境應(yīng)限制域名
    }
}

@Component
class MyWebSocketHandler : TextWebSocketHandler() {

    private val sessions = ConcurrentHashMap<String, WebSocketSession>()
    private val logger = LoggerFactory.getLogger(this::class.java)

    // 連接建立
    override fun afterConnectionEstablished(session: WebSocketSession) {
        val userId = session.attributes["userId"] as? String
        userId?.let {
            sessions[it] = session
            logger.info("User $it connected, total: ${sessions.size}")
        } ?: run {
            session.close(CloseStatus.BAD_DATA)
        }
    }

    // 處理文本消息
    override fun handleTextMessage(session: WebSocketSession, message: TextMessage) {
        val payload = message.payload
        logger.debug("Received message: $payload")
        
        // 示例：廣播消息
        sessions.values.forEach { 
            it.sendMessage(TextMessage("Broadcast: $payload"))
        }
    }

    // 連接關(guān)閉
    override fun afterConnectionClosed(session: WebSocketSession, status: CloseStatus) {
        sessions.values.remove(session)
        logger.info("Connection closed: ${status.reason}")
    }

    // 主動(dòng)推送方法
    fun sendToUser(userId: String, message: String) {
        sessions[userId]?.sendMessage(TextMessage(message))
    }
}

@Component
class AuthHandshakeInterceptor : HandshakeInterceptor {

    override fun beforeHandshake(
        request: ServerHttpRequest,
        response: ServerHttpResponse,
        wsHandler: WebSocketHandler,
        attributes: MutableMap<String, Any>
    ): Boolean {
        // 1. 校驗(yàn) Token
        val token = request.uri.query?.split("token=")?.get(1)
        if (!validateToken(token)) {
            response.statusCode = HttpStatus.UNAUTHORIZED
            return false
        }

        // 2. 獲取用戶信息
        val userId = parseUserIdFromToken(token)
        attributes["userId"] = userId
        
        // 3. 記錄握手日志
        logHandshake(request.remoteAddress?.hostName)
        return true
    }

    private fun validateToken(token: String?): Boolean {
        // 實(shí)現(xiàn) JWT 校驗(yàn)邏輯
        return token?.startsWith("valid_") == true
    }
}

const socket = new WebSocket(`ws://${location.host}/ws?token=valid_123`);

socket.onmessage = (event) => {
  console.log('Received:', event.data);
};

// 發(fā)送心跳包保持連接
setInterval(() => {
  socket.send(JSON.stringify({ type: "heartbeat" }));
}, 30000);

class WebSocketClient(url: String) : WebSocketListener() {
    private val client = OkHttpClient()
    private var ws: WebSocket? = null

    init {
        val request = Request.Builder().url(url).build()
        ws = client.newWebSocket(request, this)
    }

    override fun onMessage(webSocket: WebSocket, text: String) {
        println("Received: $text")
    }

    fun sendMessage(msg: String) {
        ws?.send(msg)
    }
}

@Bean
fun webSocketContainer(): ServletServerContainerFactoryBean {
    return ServletServerContainerFactoryBean().apply {
        setMaxTextMessageBufferSize(8192)
        setMaxBinaryMessageBufferSize(8192)
        setAsyncSendTimeout(30000L) // 30秒異步發(fā)送超時(shí)
    }
}

@Configuration
@EnableRedisRepositories
class RedisPubSubConfig {

    @Bean
    fun redisTemplate(connectionFactory: RedisConnectionFactory): RedisTemplate<String, String> {
        return RedisTemplate<String, String>().apply {
            setConnectionFactory(connectionFactory)
        }
    }

    @Bean
    fun topicListenerAdapter(handler: MessageListener): ChannelTopic {
        return ChannelTopic("websocket-messages")
    }
}

@RestController
class WebSocketMetricsController(
    private val handler: MyWebSocketHandler
) {

    @GetMapping("/metrics/websocket")
    fun getMetrics(): Map<String, Any> {
        return mapOf(
            "activeConnections" to handler.getSessionCount(),
            "lastMessageTime" to handler.getLastActivity()
        )
    }
}

<logger name="org.springframework.web.socket" level="DEBUG"/>
<logger name="com.example.websocket" level="TRACE"/>