node静态文件服务器端实现与扩展

以前刚开始学node的时候写过几个小项目练手，但都是一开始就用到了express框架，这段时间重学node基础，想到如何用node实现一个类似于express的框架，于是就想从静态文件服务器开始实现一部分功能，实现了基本的文件服务器后我还继续扩展了路由逻辑处理的功能，用于简易服务器后台的实现与搭建

注：本篇主要是记述性质文章，用于自我总结
github地址：https://github.com/kindboy/node-file-server
博客地址：我的博客

一、创建服务器

利用http模块的createServer创建一个服务器，就是这么简单, 如下为app.js启动文件的配置

const config = require('./config');
const router = require('./router/router');
const handle = require('./handle');

const http = require('http');

var httpServer = http.createServer(onRequest);
httpServer.listen(config.port || 8888);
httpServer.on('error', (err) => {
    console.log(err);
});

function onRequest(request, response) {
    console.log('request received');

    router(request, response, handle);
}

.config为配置文件，用于导出配置信息，便于配置信息的统一修改，定义了服务器的端口位置，和支持的MINE类型（可自行扩展）

module.exports = {
    port: 8888,
    ip: '127.0.0.1',
    mine: {
        html: 'text/html',
        js: 'text/javascript',
        css: 'text/css',
        gif: 'image/gif',
        jpg: 'image/jpeg',
        png: 'image/png',
        ico: 'image/icon',
        txt: 'text/plain',
        json: 'application/json',
        xml: 'text/xml',
        pdf: 'application/pdf',
        default: 'application/octet-stream'
    }
};

二、路由的实现

路由模块主要用于解析请求URL中的路径，并对不同的路径实施不用的处理逻辑。

用到的模块：url 解析请求URL返回Object对象
path 处理路径

首先，我们先要实现一个根据path获取MINE类型的方法

var getFileMine = (pathname) => {
    let extname = path.extname(pathname).substr(1);
    let mineType = config.mine;
    if (mineType.hasOwnProperty(extname)) {
        return mineType[extname];
    } else {
        return false;
    }
};

核心处理逻辑就是，首先检查请求URL的文件MINE类型，如果是我们配置文件config.js 中定义的类型之一，则调用routerHandle模块（稍后会讲）的文件读取功能去读取并返回对应的请求文件；若URL没有MINE类型的后缀名，则默认为调用路由处理方法，根据handle.js中配置的handle对象的方法处理；若在handle对象中没有对应的路由处理方法，则返回404 Not Found.

完整的实现代码为：

const url = require('url');
const path = require('path');

const routerHandle = require('./routerHandle');
const config = require('../config');

module.exports = (function() {

    /*
    * 获取请求文件MINE类型
    * @param pathname  文件路径
    * @return  | false 文件MINE类型或false
    *
    */
    var getFileMine = (pathname) => {
        let extname = path.extname(pathname).substr(1);
        let mineType = config.mine;
        if (mineType.hasOwnProperty(extname)) {
            return mineType[extname];
        } else {
            return false;
        }
    };

    return function(request, response, handle) {
        let pathname = url.parse(request.url).pathname;
        let mine = getFileMine(pathname);

        pathname = decodeURI(pathname);
        if(mine) {
            routerHandle.static(request, response, pathname, mine);
        } else if (typeof handle[pathname] === 'function') {
            handle[pathname](request, response);
        } else {
            response.writeHead(404, {'Content-Type': 'text/plain'});
            response.write('404 Not Found');
            response.end();
        }
    };
})();

三、路由handle的实现

最后就是对于不同的路由调用不用等handle来处理了，这里我在routerHandle.js中定义了一个static方法专门用来处理静态文件的读取返回操作

exports.static = (request, response, pathname, mine) => {
    pathname = path.join('./static', path.normalize(pathname.replace(/\.\./g, '')));

    let promise = new Promise((resolve, reject) => {
        fs.exists(pathname, (exists) => {
            if(!exists) {
                reject();
            } else {
                resolve();
            }
        });
    });
    
    promise.then(() => {
        response.writeHead(200, {'Content-Type': mine});
        let readStream = fs.createReadStream(pathname);
        readStream.on('error', (err) => {
            serverException(response); //自定义方法，处理500错误
        });
        readStream.pipe(response);
    }).catch(() => {
        notFoundException(response); //自定义方法，处理404错误
    });
    
};

然后，为了提高兼容性，我对于 '/' 路径的请求做了一个重定向处理，默认访问 ./static 文件夹下的index.html文件

exports.start = (request, response) => {
    let redirect = 'http://' + request.headers.host + '/index.html';
    response.writeHead(301, { 'location': redirect});
    response.end();
};  

至此，一个基本的静态文件服务器就已经实现了。

对于，自定义路由，在handle.js文件中require自己新建的路由文件（建议放在router文件夹下），并通过handle对象注册自定义路由文件中自定义的功能（如：handle['/test'] = myRouter.myTest;）

const routerHandle = require('./router/routerHandle');
const myRouter = require('./router/myRouter');
// 1. 添加自定义模块 

let handle = {};
handle['/'] = routerHandle.start;
// 2. 为自定义模块定义路由
handle['/test'] = myRouter.myTest;

module.exports = handle;

以上代码，我新建了一个myRouter.js文件用于放置自定义的路由方法，并通过handle对象扩展这一路由文件下的myTest方法，如果要添加其他方法，可以效仿。