详解一个基于套接字实现长连接的express

逻辑: 首先把routerurl目录下的函数初始化缓存起来，通过router.request调用缓存起来的函数，这个函数实际上是register.set方法，主要是开始运行函数链，通过register.next 运行下一个函数。

函数流 main.js --> router.request --> register.set --> register.next --> sock.write

main.js

'use strict';
const routerurl = 'router'; // 当前目录下的router地址
const router = require('./net/router'); // 初始化路由
const net = require('net');
const port = '3000';
router.init(routerurl);
const app = sock => {
  sock.on('data', function (data) {
    try {
      router.request(data, sock);
    } catch (error) {
      console.log(error)
    }
  });

  sock.on('error', (err) => {
    console.log(err)
  })

  // 为这个socket实例添加一个"close"事件处理函数
  sock.on('close', function (data) {
    console.log('clone')
  })
}
const server = net.createserver(app);

server.listen(port, () => {
  console.log(`startu in env ${process.env.node_env || 'development'} on port ${port}`);
});

server.on('error', (err) => {
  console.log(err)
})

路由加载:

router.js文件

const fs = require('fs');
const _ = require('lodash');
var path = require("path");
var root_path = path.resolve(__dirname);
class router {
  constructor() {
    this.routemap = {};
  }
  /**
   * 通过routerurl来匹配目录下的文件，加载进来
   * @param {*} routerurl
   */
  init(routerurl) {
    let files = fs.readdirsync(path.join(root_path, `../${routerurl}`));
    return _.reduce(files, (config, file) => {
      let svc = require(path.join(root_path, `../${routerurl}/${file}`));
      this.routemap = {
        [file.split('.')[0]]: svc.get()
      };
    }, {})
  }
  /**
   * 通过url匹配加载的router， 其他字段可自定义，url这里的逻辑也可改成配置文件进行配置，类似于protobuf
   * @param {*} data {url, body}
   * @param {*} sock
   */
  request(data, sock) {
    try {
      this.routemap[result.url.split('/')[1]][result.url.replace(`/${result.url.split('/')[1]}`, '')](data, sock);
    } catch (error) {
      sock.write(error);
    }
  }
}

module.exports = new router();

中间件:

register.js文件

const next = require('./next');

class register {
  constructor() {
    this._init = {};
  }
  <!-- 初始化router函数，开始运行函数链 -->
  set(url, ...handlers) {

    this._init[url] = async (data, sock) => {
      try {
        let next = new next(handlers);
        next.run(data, sock);  
      } catch (error) {
        sock.write(error);
      }
    };
  }
  <!-- 获取初始化的router函数 -->
  get() {
    return this._init;
  }
}

module.exports = new register();

nest.js文件

class next {
  constructor(stack) {
    this.index = 0;
    this.stack = stack;
    this.data = null;
    this.sock = null;
  }
  <!-- 运行中间件 -->
  run(data, sock) {
    this.data = data;
    this.sock = sock;
    this.stack[this.index](data, sock, this.next.bind(this));
  }
  <!-- 调到下一个中间件，若带参数就跳到第arguments[0]步 -->
  next() {
    if (arguments[0] && arguments[0] === +arguments[0] && +arguments[0] < this.stack.length) {
      this.index = +arguments[0];
      return this.run(data, this.sock);
    }
    this.index++;
    this.run(this.data, this.sock);
  }
}

module.exports = next;

注册文件

const init = require('../net/register');

init.set('/test',
  (data, sock, next) => {
    next()
  },
  async (data, sock) => {
    try {
      sock.write(test);
    } catch (e) {
      sock.write(e);
    }
  });

总结：这个项目只是用来歇息express的思想，要用在实际开发中还需要断线重连，优化连接，异常处理等功能。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。