Amalan pembangunan Java Websocket: cara mengendalikan sambungan serentak berskala besar

Java Websocket ialah protokol yang digunakan untuk mewujudkan komunikasi dua hala masa nyata antara pelayar web dan pelayan web. Dalam aplikasi Internet hari ini, masa nyata menjadi semakin penting, dan salah satu senario yang memerlukan komunikasi masa nyata ialah sembang sosial. Dalam senario sembang, sambungan serentak berskala besar perlu dikendalikan. Dan Java Websocket adalah pilihan yang sangat baik.

Dalam artikel ini, kami akan memperkenalkan cara menggunakan Java Websocket untuk mengendalikan sambungan serentak berskala besar melalui contoh kod.

Mari kita lihat idea biasa dahulu. Dalam Java Websocket, Servlet dan WebSocketEndpoint Java EE sering digunakan. Dalam beberapa contoh mudah, kami akan menggunakan kelas ini, tetapi apabila bilangan sambungan meningkat, menggunakan kelas ini secara langsung boleh menyebabkan kesesakan prestasi dengan mudah dan kami perlu menggunakan beberapa alat yang lebih cekap untuk mengendalikan sambungan.

Di sini, kami akan menggunakan perpustakaan netty-socketio daripada JavaTreasureChest untuk mengendalikan sambungan Java Websocket. Netty ialah rangka kerja pengaturcaraan rangkaian berprestasi tinggi, dan SocketIO ialah protokol untuk melaksanakan aplikasi masa nyata.

Contoh Kod

Pertama, kita perlu menambah kebergantungan perpustakaan netty-socketio. Dalam projek Maven, kita boleh menambah kebergantungan berikut dalam fail pom.xml:

<dependency>
    <groupId>com.corundumstudio.socketio</groupId>
    <artifactId>netty-socketio</artifactId>
    <version>1.7.17</version>
</dependency>

Seterusnya, kita perlu melaksanakan kelas Java sebagai pelayan WebSocket dan mendengar permintaan sambungan. Kod sampel adalah seperti berikut:

import com.corundumstudio.socketio.*;
import com.corundumstudio.socketio.listener.*;

public class WebSocketServer {
    public static void main(String[] args) {
        // 创建配置对象
        Configuration config = new Configuration();
        config.setHostname("localhost");
        config.setPort(9092);

        // 创建SocketIO服务器
        SocketIOServer server = new SocketIOServer(config);

        // 添加连接事件监听器
        server.addConnectListener(new ConnectListener() {
            @Override
            public void onConnect(SocketIOClient client) {
                System.out.println("连接成功：" + client.getSessionId().toString());
            }
        });

        // 启动服务器
        server.start();

        // 等待连接关闭
        System.in.read();
        server.stop();
    }
}

Dalam kod ini, kami menggunakan kelas SocketIOServer dalam perpustakaan SocketIO untuk mencipta pelayan WebSocket. Apabila sambungan berjaya, mesej kejayaan sambungan akan dicetak.

Seterusnya, kita perlu mendaftarkan pendengar dengan pelayan supaya ia boleh diproses apabila klien menyambung. Kodnya adalah seperti berikut:

// 添加事件监听器
server.addEventListener("client_msg", String.class, new DataListener<String>() {
    @Override
    public void onData(SocketIOClient client, String data, AckRequest ackRequest) {
        System.out.println("收到消息：" + data + "，sessionId=" + client.getSessionId());
    }
});

Dalam coretan kod ini, kami mendaftarkan acara yang dipanggil "client_msg" dan menambah DataListener untuk mengendalikan mesej yang diterima.

Kadangkala, kami juga mungkin perlu mengesahkan sambungan. Pustaka SocketIO menyediakan antara muka AuthorizationListener, yang boleh kami laksanakan untuk mengendalikan pengesahan. Kod sampel adalah seperti berikut:

// 添加身份验证监听器
server.addAuthorizationListener(new AuthorizationListener() {
    @Override
    public boolean isAuthorized(HandshakeData handshakeData) {
        // 验证用户是否具有连接权限
        return true;
    }
});

Dalam coretan kod ini, kami telah menambah AuthorizationListener untuk mengendalikan permintaan pengesahan. Logik di sini adalah untuk mengesahkan semua sambungan.

Akhir sekali, kita perlu memulakan pelayan WebSocket dan menunggu sambungan ditutup. Kodnya adalah seperti berikut:

// 启动服务器
server.start();

// 等待连接关闭
System.in.read();
server.stop();

Ini adalah pelaksanaan pelayan Java Websocket yang mudah, tetapi ia tidak dapat mengendalikan sambungan serentak berskala besar. Dalam bahagian seterusnya, kami akan membincangkan cara menggunakan perpustakaan netty-socketio untuk mengendalikan sambungan serentak berskala besar.

Gunakan ruang nama dan bilik untuk mengendalikan sambungan serentak

Untuk mengendalikan sejumlah besar sambungan serentak, kita perlu mengumpulkan sambungan. Dalam perpustakaan netty-socketio, kita boleh menggunakan ruang nama dan ruang untuk mengumpulkan. Ruang nama ialah saluran logik yang mengandungi sekumpulan bilik. Bilik ialah bilik yang mengandungi sekumpulan pengguna.

Penggunaan khusus adalah seperti berikut:

// 创建SocketIO服务器
SocketIOServer server = new SocketIOServer(config);

// 创建namespace
SocketIONamespace chatNamespace = server.addNamespace("/chat");

// 设置连接事件监听器
chatNamespace.addConnectListener(new ConnectListener() {
    @Override
    public void onConnect(SocketIOClient client) {
        // 加入默认房间
        client.joinRoom("default");
    }
});

// 设置事件监听器
chatNamespace.addEventListener("client_msg", String.class, new DataListener<String>() {
    @Override
    public void onData(SocketIOClient client, String data, AckRequest ackRequest) {
        String sessionId = client.getSessionId().toString();
        System.out.println("收到消息：" + data + "，sessionId=" + sessionId);
        
        // 广播消息到房间的所有用户
        chatNamespace.getRoomOperations("default").sendEvent("server_msg", sessionId + ":" + data);
    }
});

// 启动服务器
server.start();

Dalam coretan kod ini, kami menggunakan ruang nama dan bilik untuk mengendalikan sambungan. Mula-mula, kami mencipta saluran logik yang dipanggil "sembang" dan menambah bilik lalai. Seterusnya, apabila mengendalikan sambungan pelanggan, kami menambah sambungan ke bilik lalai.

Apabila menerima mesej daripada pelanggan, kami menyiarkan mesej itu kepada semua pengguna dalam bilik lalai. Kaedah getRoomOperations digunakan di sini untuk mendapatkan objek operasi di dalam bilik.

Dengan cara ini, kami boleh mengendalikan sambungan serentak berskala besar dengan menggunakan ruang nama dan bilik.

Pengoptimuman Prestasi

Untuk memastikan prestasi di bawah sambungan serentak berskala besar, kami perlu melakukan pengoptimuman prestasi. Di sini kami menyenaraikan beberapa kaedah pengoptimuman biasa.

1. Gunakan kumpulan benang

Apabila bilangan sambungan serentak meningkat, kita boleh menggunakan kumpulan benang untuk meningkatkan prestasi. Dalam netty-socketio, kita boleh mencipta kumpulan benang dengan:

// 创建配置对象
Configuration config = new Configuration();
...
// 创建线程池
config.setWorkerThreads(100);

2. Caching sambungan pangkalan data

Dalam operasi pangkalan data, kita boleh cache sambungan untuk mengelakkan penciptaan sambungan yang kerap. Dalam netty-socketio, kita boleh cache sambungan pangkalan data dalam ConnectListener dan menggunakannya dalam DataListener. Kod sampel adalah seperti berikut:

chatNamespace.addConnectListener(new ConnectListener() {
    @Override
    public void onConnect(SocketIOClient client) {
        // 加入默认房间
        client.joinRoom("default");
        // 缓存数据库连接
        client.set("conn", getDBConnection());
    }
});

chatNamespace.addEventListener("client_msg", String.class, new DataListener<String>() {
    @Override
    public void onData(SocketIOClient client, String data, AckRequest ackRequest) {
        String sessionId = client.getSessionId().toString();
        System.out.println("收到消息：" + data + "，sessionId=" + sessionId);

        // 使用缓存的数据库连接
        Connection conn = (Connection)client.get("conn");
        ...
    }
});

Di sini kami menggunakan kaedah set SocketIOClient untuk cache sambungan pangkalan data dan menggunakannya dalam DataListener.

3. Gunakan baris gilir mesej cache

Apabila jumlah mesej serentak adalah besar, kami boleh menyimpan mesej dalam baris gilir mesej cache dan menunggu pemprosesan seterusnya. Ini boleh mengurangkan tekanan serentak serta-merta. Kod sampel adalah seperti berikut:

private Queue<String> messageQueue = new ConcurrentLinkedDeque<>();

chatNamespace.addEventListener("client_msg", String.class, new DataListener<String>() {
    @Override
    public void onData(SocketIOClient client, String data, AckRequest ackRequest) {
        String sessionId = client.getSessionId().toString();
        System.out.println("收到消息：" + data + "，sessionId=" + sessionId);

        // 将消息放入缓存队列
        messageQueue.offer(sessionId + ":" + data);
    }
});

// 消息处理线程
new Thread(new Runnable() {
    @Override
    public void run() {
        while (true) {
            try {
                // 从队列取出消息并处理
                String message = messageQueue.poll();
                processMessage(message);
            
                // 睡眠1秒
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}).start();

Di sini kami mentakrifkan baris gilir ConcurrentLinkedDeque untuk menyimpan mesej. Dalam DataListener, letakkan mesej ke dalam baris gilir. Dalam urutan pemprosesan, mesej diambil dari baris gilir dan diproses. Ambil perhatian bahawa masa tidur benang perlu ditetapkan di sini untuk mengelakkan penggunaan CPU yang berlebihan.

Ringkasan

Dalam artikel ini, kami memperkenalkan cara menggunakan netty-socketio untuk mengendalikan sambungan serentak berskala besar. Menggunakan ruang nama dan bilik untuk mengumpulkan sambungan dan mengoptimumkan prestasi boleh membantu kami mengendalikan sejumlah besar sambungan dalam senario komunikasi segerak.

Selain itu, perlu diingatkan bahawa protokol WebSocket biasanya digunakan untuk melaksanakan sambungan panjang dalam senario komunikasi masa nyata, tetapi ia juga mungkin mempunyai risiko keselamatan. Oleh itu, dalam aplikasi praktikal, kita perlu menggunakannya dengan berhati-hati dan mempertimbangkan keselamatan.

Atas ialah kandungan terperinci Amalan pembangunan Java Websocket: cara mengendalikan sambungan serentak berskala besar. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!