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

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

一、创建服务器

利用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方法，如果要添加其他方法，可以效仿。