Web Socket #

WebSocket adalah protokol komunikasi yang menyediakan saluran komunikasi dua arah penuh antara klien dan server melalui koneksi TCP. Berbeda dengan HTTP, yang bersifat request-response dan stateless, WebSocket memungkinkan komunikasi terus-menerus tanpa harus membuka koneksi baru untuk setiap pesan, sehingga sangat berguna untuk aplikasi real-time seperti chat, live updates, dan game online.

Konsep WebSocket #

Handshake: Proses awal di mana klien mengirimkan permintaan WebSocket ke server, dan server merespons dengan persetujuan. Setelah handshake, koneksi WebSocket dibuka.
Frames: Data dalam WebSocket dikirim dalam bentuk frame, yang dapat berupa teks, binary, atau kontrol.
Full-Duplex Communication: Komunikasi dua arah di mana klien dan server dapat saling mengirim pesan kapan saja setelah koneksi dibuka.

WebSocket di Java #

Di Java, Anda dapat menggunakan berbagai pustaka untuk mengimplementasikan WebSocket, termasuk API WebSocket standar yang disediakan oleh Java EE (Jakarta EE) dan pustaka seperti Tyrus dan Jetty.

WebSocket dengan Java EE #

Membuat Endpoint WebSocket

Contoh Endpoint WebSocket:

import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.concurrent.CopyOnWriteArraySet;

@ServerEndpoint("/websocket")
public class WebSocketServer {
    private static final CopyOnWriteArraySet<WebSocketServer> clients = new CopyOnWriteArraySet<>();
    private Session session;

    @OnOpen
    public void onOpen(Session session) {
        this.session = session;
        clients.add(this);
        System.out.println("New connection established");
    }

    @OnMessage
    public void onMessage(String message) {
        System.out.println("Message received: " + message);
        for (WebSocketServer client : clients) {
            try {
                client.session.getBasicRemote().sendText(message);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @OnClose
    public void onClose() {
        clients.remove(this);
        System.out.println("Connection closed");
    }
}

Penjelasan:

@ServerEndpoint("/websocket"): Menandai kelas sebagai endpoint WebSocket dan menentukan URL endpoint.
@OnOpen: Menangani koneksi baru yang dibuka.
@OnMessage: Menangani pesan yang diterima dari klien.
@OnClose: Menangani penutupan koneksi.

Menjalankan Server

Untuk menjalankan endpoint WebSocket, Anda perlu mengemasnya dalam aplikasi Java EE dan men-deploy ke server seperti Apache Tomcat atau GlassFish yang mendukung WebSocket.

WebSocket dengan Spring Boot #

Spring Boot memudahkan implementasi WebSocket dengan menyediakan dukungan untuk WebSocket dalam framework-nya.

Menambahkan Dependensi Spring Boot WebSocket

Gradle:

implementation 'org.springframework.boot:spring-boot-starter-websocket'

Maven:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>

Membuat Konfigurasi WebSocket

Contoh Konfigurasi WebSocket:

import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(new WebSocketHandler(), "/websocket").setAllowedOrigins("*");
    }
}

Contoh Handler WebSocket:

import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.TextWebSocketHandler;
import org.springframework.web.socket.TextMessage;

public class WebSocketHandler extends TextWebSocketHandler {

    @Override
    public void handleTextMessage(WebSocketSession session, TextMessage message) {
        System.out.println("Received message: " + message.getPayload());
        try {
            session.sendMessage(new TextMessage("Reply: " + message.getPayload()));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Penjelasan:

@Configuration: Menandai kelas sebagai konfigurasi Spring.
@EnableWebSocket: Mengaktifkan dukungan WebSocket.
WebSocketHandler: Kelas yang menangani pesan WebSocket.
handleTextMessage(): Menangani pesan teks dari klien.

Menjalankan Aplikasi

Jalankan aplikasi Spring Boot Anda. Spring Boot akan menyediakan server WebSocket terintegrasi.

WebSocket dengan Jetty #

Jetty juga dapat digunakan untuk mengimplementasikan WebSocket dan menyediakan server web serta dukungan WebSocket.

Menambahkan Dependensi Jetty WebSocket

Gradle:

implementation 'org.eclipse.jetty:jetty-server:11.0.6'
implementation 'org.eclipse.jetty:jetty-websocket-server:11.0.6'

Maven:

<dependency>
    <groupId>org.eclipse.jetty</groupId>
    <artifactId>jetty-server</artifactId>
    <version>11.0.6</version>
</dependency>
<dependency>
    <groupId>org.eclipse.jetty</groupId>
    <artifactId>jetty-websocket-server</artifactId>
    <version>11.0.6</version>
</dependency>

Contoh Kode Jetty WebSocket:

import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.handler.HandlerCollection;
import org.eclipse.jetty.server.handler.ResourceHandler;
import org.eclipse.jetty.websocket.server.WebSocketHandler;
import org.eclipse.jetty.websocket.api.Session;
import org.eclipse.jetty.websocket.api.WebSocketAdapter;

public class JettyWebSocketExample {

    public static class EchoWebSocket extends WebSocketAdapter {
        @Override
        public void onWebSocketText(String message) {
            if (isOpen()) {
                try {
                    getRemote().sendString("Echo: " + message);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) throws Exception {
        Server server = new Server(8080);

        WebSocketHandler wsHandler = new WebSocketHandler() {
            @Override
            public void configure(WebSocketHandler.Config config) {
                config.register(EchoWebSocket.class);
            }
        };

        HandlerCollection handlers = new HandlerCollection();
        handlers.addHandler(wsHandler);

        server.setHandler(handlers);
        server.start();
        server.join();
    }
}

Penjelasan:

WebSocketHandler: Menangani konfigurasi WebSocket.
EchoWebSocket: Implementasi handler WebSocket yang mengirimkan kembali pesan yang diterima.
Server: Mewakili server Jetty.

Kesimpulan #

WebSocket adalah protokol penting untuk aplikasi yang memerlukan komunikasi real-time dua arah. Di Java, Anda dapat menggunakan beberapa teknologi untuk mengimplementasikan WebSocket:

API WebSocket Standar (Java EE): Menyediakan cara standar untuk membuat endpoint WebSocket.
Spring Boot: Menyederhanakan implementasi WebSocket dengan integrasi mudah dan konfigurasi otomatis.
Jetty: Menyediakan server dan dukungan WebSocket yang dapat di-embed dalam aplikasi.

Dengan menggunakan teknologi ini, Anda dapat membangun aplikasi yang responsif dan efisien dengan komunikasi real-time antara klien dan server.

« Socket

Web Server »