Nodejs 静态文件服务器代码整理

Node.js 静态文件服务器代码整理

staticServer.js 文件

const http = require('http');
const url = require('url');
const path = require('path');
const fs = require('fs');
const mime = require('./mime').types;
const config = require('./config');
const zlib = require('zlib');
const utils = require('./utils');

http.createServer((request, response) => {
    const uri = url.parse(request.url).pathname;
    const filename = path.join(__dirname + '/static', uri);

    const compressHandle = (raw, compressMatched, statusCode, reasonPhrase) => {
        let stream = raw;
        const acceptEncoding = request.headers['accept-encoding'] || "";

        if (compressMatched && acceptEncoding.includes('gzip')) {
            response.setHeader("Content-Encoding", "gzip");
            stream = raw.pipe(zlib.createGzip());
        } else if (compressMatched && acceptEncoding.includes('deflate')) {
            response.setHeader("Content-Encoding", "deflate");
            stream = raw.pipe(zlib.createDeflate());
        }

        response.writeHead(statusCode, reasonPhrase);
        stream.pipe(response);
    };

    fs.exists(filename, exists => {
        if (!exists) {
            response.writeHead(404, {"Content-Type": "text/plain"});
            response.write("404 Not Found\n");
            response.end();
            return;
        }

        const ext = path.extname(filename);
        const contentType = mime[ext.slice(1)] || 'text/plain';
        response.setHeader('Content-Type', contentType);

        fs.stat(filename, (err, stat) => {
            const lastModified = stat.mtime.toUTCString();
            const ifModifiedSince = "If-Modified-Since".toLowerCase();

            response.setHeader("Last-Modified", lastModified);
            response.setHeader("Server", "Node/V2");

            if (ext.match(config.Expires.fileMatch)) {
                const expires = new Date();
                expires.setTime(expires.getTime() + config.Expires.maxAge * 1000);
                response.setHeader("Expires", expires.toUTCString());
                response.setHeader("Cache-Control", `max-age=${config.Expires.maxAge}`);
            }

            if (request.headers[ifModifiedSince] === lastModified) {
                response.writeHead(304, 'Not Modified');
                response.end();
                return;
            }

            const compressMatched = ext.match(config.Compress.match);

            if (request.headers["range"]) {
                const range = utils.parseRange(request.headers["range"], stat.size);
                if (range) {
                    response.setHeader("Content-Range", `bytes ${range.start}-${range.end}/${stat.size}`);
                    response.setHeader("Content-Length", range.end - range.start + 1);
                    const raw = fs.createReadStream(filename, {start: range.start, end: range.end});
                    compressHandle(raw, compressMatched, 206, "Partial Content");
                } else {
                    response.removeHeader("Content-Length");
                    response.writeHead(416, "Request Range Not Satisfiable");
                    response.end();
                }
            } else {
                const raw = fs.createReadStream(filename);
                compressHandle(raw, compressMatched, 200, "OK");
            }
        });
    });
}).listen(8000);

console.log('Server running at http://localhost:8000/');

config.js 文件

module.exports = {
    Expires: {
        fileMatch: /^(gif|png|jpg|js|css)$/i,
        maxAge: 60 * 60 * 24 * 365
    },
    Compress: {
        match: /css|js|html/i
    }
};

utils.js 文件

module.exports = {
    parseRange: (str, size) => {
        if (str.includes(',')) {
            return;
        }

        const range = str.split("-");
        const start = parseInt(range[0], 10);
        const end = parseInt(range[1], 10);

        if (isNaN(start)) {
            start = size - end;
            end = size - 1;
        } else if (isNaN(end)) {
            end = size - 1;
        }

        if (isNaN(start) || isNaN(end) || start > end || end > size) {
            return;
        }

        return { start, end };
    },
    types: {
        "css": "text/css",
        "gif": "image/gif",
        "html": "text/html",
        "ico": "image/x-icon",
        "jpeg": "image/jpeg",
        "jpg": "image/jpeg",
        "js": "text/javascript",
        "json": "application/json",
        "pdf": "application/pdf",
        "png": "image/png",
        "txt": "text/plain",
        "xml": "text/xml",
        "swf": "application/x-shockwave-flash",
        "wav": "audio/x-wav",
        "wma": "audio/x-ms-wma",
        "wmv": "video/x-ms-wmv",
        "svg": "image/svg+xml"
    }
};

以上代码展示了如何使用 Node.js 创建一个简单的静态文件服务器，并支持文件缓存、压缩以及范围请求。所有的配置和辅助函数都放在单独的文件中，以保持代码的整洁和可维护性。