Node websocket简单封装

前言

简单封装创建、连接websocket类

代码

1. 封装创建ws类

const websocket = require('ws');
class WebSocket {
    constructor(options) {
        this.init();
        this.options = options;
    }

    init() {
        this.obj = {};
        this.options = {};
    }

    createServer(options) {
        const WS = new websocket.Server(this.options);
        WS.on('connection', (ws, req) => this.connection(ws, req))
    }

    async connection(ws, req) {
        console.log('建立连接', req.url);
        const id = req.url.split('/')[1];
        if (!id) return ws.close();
        this.obj[id] = ws;
        ws.id = id;
        this.filter();
        this.printObj();
        ws.send(JSON.stringify({data: '欢迎访问！', id: id}));

        ws.on('message', this.message);
        ws.on('close', (msg) => this.close(msg, ws.id));
    }

    async filter() {
        for(let key in this.obj) {
            if (!this.obj[key].readyState === 1) delete this.obj[key]
        }
    }

    async message(msg) {
        const message = JSON.parse(msg);
        console.log('接收消息', message);
    }

    close(msg, id) {
        console.log('关闭连接', id, msg);
    }

    send(msg, id) {
        if(id) {
            if (this.obj[id].readyState === 1) {
                this.obj[id].send(JSON.stringify(msg));
            }
        } else {
            for (let ws of Object.values(this.obj)) {
                if (ws.readyState === 1) ws.send(JSON.stringify(msg));
            }
        }
    }

    printObj() {
        console.log('---ws list---');
        for(let key in this.obj) {
            if (this.obj[key].readyState === 1) console.log(key);
        }
        console.log('----------');
    }
}

// create instance
let ws = new WebSocket({port: 3000});
try {
    ws.createServer();
    // ws.printObj();
} catch (err) {
    console.log(err);
}

2. 封装连接ws类

const ReconnectingWebSocket = require('reconnecting-websocket');
const websocket = require('ws');
const EventEmitter = require('events').EventEmitter;

class ConnectWebSocket extends EventEmitter{
    constructor(url) {
        super();
        this.url = url;
        this.init();
    }

    init() {
        this.ws = null;
    }

    connectServer(type, listener) {
        this.ws = new ReconnectingWebSocket(this.url, [], {
            maxReconnectionDelay: 5000,
            WebSocket: websocket
        });
        this.ws.addEventListener('open', this.open);
        this.ws.addEventListener('close', this.close);
        this.ws.addEventListener('message', this.message);
    }

    open() {
        console.log('连接成功');
    }

    close() {
        console.log('连接已断开');
    }

    message(msg) {
        let message = JSON.parse(msg.data);
        console.log('接受消息', message);
    }

    send(msg) {
        this.ws.send(JSON.stringify(msg));
    }
}

// create instance
let connect = new ConnectWebSocket('ws://localhost:3000/1');
connect.connectServer();
connect.send('hello ws');

总结

1. reconnecting-websocket npm包 可以在断开连接后自动尝试重新建立连接