0Pricing
WebSockets & Real-Time Systems with Spring · レッスン

接続ライフサイクルの管理

接続の開始、終了、予期しない切断など、WebSocket接続のライフサイクルを管理します。

「接続ライフサイクルの管理」はCoddyKit上の無料WebSockets & Real-Time Systems with Springレッスンです。 これはレッスン2/4です。 下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。 これはWebSockets & Real-Time Systems with Spring学習パスの一部であり、ウェブとCoddyKitアプリ全体で進捗が同期されます。 WebSockets & Real-Time Systems with Springコースには全4レッスンが含まれています。

このレッスンの一部はまだ翻訳されておらず、英語で表示されています。

WebSocket Connection Lifecycle

Every WebSocket connection goes through a lifecycle: it opens, stays active for messaging, and eventually closes. Managing these stages is crucial for building robust real-time applications.

Proper lifecycle management helps ensure resources are used efficiently and that your application responds gracefully to various connection events.

The Initial Handshake

Before a WebSocket connection is established, an initial HTTP handshake occurs. The client sends an HTTP request with an Upgrade header, asking to switch protocols.

If the server agrees, it responds with a 101 Switching Protocols status, and the connection transitions from HTTP to WebSocket.

Client-Side Connection

On the client side, typically in a web browser, you initiate a WebSocket connection using JavaScript. The WebSocket constructor creates a new connection to the specified URL.

This example shows how to connect and log messages when the connection opens or encounters an error.

const socket = new WebSocket("ws://localhost:8080/lifecycle");

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

socket.onerror = (error) => {
  console.error("WebSocket Error:", error);
};

Server-Side: Handling New Connections

In Spring, you can use the @OnOpen annotation to define a method that executes when a new WebSocket connection is established. This is your entry point for handling new clients.

The Session object provides details about the client connection.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;

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

    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }
}

@ServerEndpoint("/lifecycle")
@Component
class LifecycleHandler {
    @OnOpen
    public void onOpen(Session session) {
        System.out.println("Client connected: " + session.getId());
    }
}

Gracefully Closing Connections

A connection can be closed intentionally by either the client or the server. This is called a 'graceful' closure. It's important to close connections properly to release server resources and inform clients.

A close message usually includes a status code and a reason for closure, helping both ends understand why the connection ended.

Client-Side Disconnect

Clients can close a WebSocket connection using the close() method. You can optionally provide a status code and a reason message.

The onclose event listener is triggered when the connection is closed, allowing you to perform cleanup or UI updates.

socket.onclose = (event) => {
  if (event.wasClean) {
    console.log(`Closed cleanly, code=${event.code}, reason=${event.reason}`);
  } else {
    console.log('Connection died unexpectedly');
  }
};

// To close the connection explicitly:
socket.close(1000, "Client leaving");

Server-Side: Handling Disconnections

The @OnClose annotation in Spring allows you to define a method that executes when a WebSocket connection is closed. This is where you can clean up resources associated with that session.

The CloseReason parameter provides details about why the connection was terminated.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;
import javax.websocket.OnOpen;
import javax.websocket.OnClose;
import javax.websocket.Session;
import javax.websocket.CloseReason;
import javax.websocket.server.ServerEndpoint;

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

    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }
}

@ServerEndpoint("/lifecycle")
@Component
class LifecycleHandler {
    @OnOpen
    public void onOpen(Session session) {
        System.out.println("Client connected: " + session.getId());
    }

    @OnClose
    public void onClose(Session session, CloseReason reason) {
        System.out.println("Client disconnected: " + session.getId() + " - Reason: " + reason.getReasonPhrase());
    }
}

Handling Unexpected Disconnections & Errors

Sometimes connections don't close gracefully. Network issues, client crashes, or server errors can lead to abrupt disconnections. These are 'unclean' closures.

It's vital to have mechanisms to detect and respond to these unexpected events to maintain application stability and user experience.

Server-Side: Error Handling

The @OnError annotation handles exceptions that occur during a WebSocket session. This could be due to issues like message processing errors or underlying network problems.

Implementing an @OnError handler ensures your server can log errors and potentially close the affected session gracefully, preventing resource leaks.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;
import javax.websocket.OnOpen;
import javax.websocket.OnClose;
import javax.websocket.OnError;
import javax.websocket.Session;
import javax.websocket.CloseReason;
import javax.websocket.server.ServerEndpoint;

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

    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }
}

@ServerEndpoint("/lifecycle")
@Component
class LifecycleHandler {
    @OnOpen
    public void onOpen(Session session) {
        System.out.println("Client connected: " + session.getId());
    }

    @OnClose
    public void onClose(Session session, CloseReason reason) {
        System.out.println("Client disconnected: " + session.getId() + " - Reason: " + reason.getReasonPhrase());
    }

    @OnError
    public void onError(Session session, Throwable throwable) {
        System.err.println("Error on session " + session.getId() + ": " + throwable.getMessage());
    }
}

Detecting Liveness with Heartbeats

When a connection drops unexpectedly (e.g., network cable pulled), neither side might immediately know. Heartbeat mechanisms, often using WebSocket ping/pong frames, help detect unresponsive peers.

By sending periodic pings and expecting pongs, you can determine if a connection is still alive and close it if no response is received.

Lifecycle Management Check

Managing the various stages of a WebSocket connection is key to building reliable real-time applications. Let's test your understanding of Spring's lifecycle annotations.

Recap: Connection Management

In this lesson, you've learned about the crucial aspects of WebSocket connection lifecycle management. We covered:

  • The initial HTTP handshake.
  • How clients and servers open connections (@OnOpen).
  • Graceful client and server disconnections (@OnClose).
  • Handling unexpected errors during a session (@OnError).
  • The role of heartbeats in detecting unresponsive connections.

Mastering these concepts is fundamental for developing robust and resilient real-time applications with WebSockets and Spring.

よくある質問

「接続ライフサイクルの管理」レッスンは無料ですか？

はい。「接続ライフサイクルの管理」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、WebSockets & Real-Time Systems with Springコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 WebSockets & Real-Time Systems with Springコースには全4レッスンが含まれています。

「接続ライフサイクルの管理」で何を学びますか？

接続の開始、終了、予期しない切断など、WebSocket接続のライフサイクルを管理します。 ブラウザで直接実行するハンズオンコードでWebSockets & Real-Time Systems with Springを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。

WebSockets & Real-Time Systems with Springを始めるのに経験は必要ですか？

事前経験は必要ありません。CoddyKitのWebSockets & Real-Time Systems with Springは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。 これはレッスン2/4です。

「接続ライフサイクルの管理」レッスンにはどのくらい時間がかかりますか？

ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。

このWebSockets & Real-Time Systems with Springレッスンでコードを書いて実行できますか？

はい。すべてのWebSockets & Real-Time Systems with Springレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。

このコースのすべてのレッスン

  1. WebSocketエラーの適切な処理
  2. 接続ライフサイクルの管理
  3. 再試行とフォールバック
  4. ハートビートとPing/Pongキープアライブ
← WebSockets & Real-Time Systems with Springに戻る