如何用JavaScript实现一个支持智能路由的中间件框架？

App

Framework

Router

Middleware

App

class App {
    constructor() {
        this.middlewares = [];
        this.routes = {}; // 存储路由，键为方法+路径模式
    }

    // 注册全局中间件
    use(middleware) {
        this.middlewares.push(middleware);
    }

    // 注册特定HTTP方法的路由
    _registerRoute(method, path, handler) {
        if (!this.routes[method]) {
            this.routes[method] = [];
        }
        // 这里存储路径模式和对应的处理函数
        // 后续会用到更智能的匹配方式
        this.routes[method].push({ path, handler });
    }

    get(path, handler) { this._registerRoute('GET', path, handler); }
    post(path, handler) { this._registerRoute('POST', path, handler); }
    // ... 其他HTTP方法

    // 处理请求的核心逻辑
    async handleRequest(req, res) {
        let currentMiddlewareIndex = 0;
        const next = async (err) => {
            if (err) {
                // 错误处理逻辑，可以传递给专门的错误中间件
                console.error("Middleware error:", err);
                res.statusCode = 500;
                res.end("Internal Server Error");
                return;
            }

            if (currentMiddlewareIndex < this.middlewares.length) {
                const middleware = this.middlewares[currentMiddlewareIndex++];
                try {
                    await middleware(req, res, next);
                } catch (e) {
                    await next(e); // 捕获同步错误并传递给错误处理
                }
            } else {
                // 全局中间件执行完毕，开始路由匹配
                await this._matchAndExecuteRoute(req, res, next);
            }
        };
        await next(); // 启动中间件链
    }

    // 智能路由匹配和执行
    async _matchAndExecuteRoute(req, res, next) {
        const method = req.method.toUpperCase();
        const url = new URL(req.url, `http://${req.headers.host}`); // 方便解析路径和查询参数
        const path = url.pathname;

        const routesForMethod = this.routes[method] || [];

        for (const route of routesForMethod) {
            // 这里的智能匹配是关键
            const match = this._matchPath(route.path, path);
            if (match) {
                req.params = match.params; // 将提取的参数挂载到req对象上
                req.query = Object.fromEntries(url.searchParams); // 挂载查询参数

                // 执行路由对应的处理函数
                try {
                    await route.handler(req, res, next);
                    return; // 找到并处理了路由，就结束
                } catch (e) {
                    await next(e); // 路由处理函数中的错误
                    return;
                }
            }
        }

        // 如果没有匹配的路由
        res.statusCode = 404;
        res.end("Not Found");
    }

    // 路径匹配逻辑，支持动态参数
    _matchPath(routePath, requestPath) {
        // 将路径转换为正则表达式，例如 /users/:id => /^\/users\/([^\/]+)$/
        const paramNames = [];
        const regexPath = routePath.replace(/:(\w+)/g, (match, paramName) => {
            paramNames.push(paramName);
            return '([^/]+)'; // 匹配任何非斜杠字符
        });

        const regex = new RegExp(`^${regexPath}$`);
        const match = requestPath.match(regex);

        if (match) {
            const params = {};
            for (let i = 0; i < paramNames.length; i++) {
                params[paramNames[i]] = match[i + 1];
            }
            return { params };
        }
        return null;
    }

    // 启动服务器（简化版）
    listen(port, callback) {
        const http = require('http');
        const server = http.createServer((req, res) => this.handleRequest(req, res));
        server.listen(port, callback);
    }
}

// 示例用法
const app = new App();

// 全局日志中间件
app.use(async (req, res, next) => {
    console.log(`[${new Date().toISOString()}] ${req.method} ${req.url}`);
    await next(); // 调用下一个中间件或路由
});

// 身份验证中间件 (假设一个简单的例子)
app.use(async (req, res, next) => {
    if (req.url.startsWith('/admin') && !req.headers.authorization) {
        res.statusCode = 401;
        res.end("Unauthorized");
        return;
    }
    await next();
});

// 路由定义
app.get('/', async (req, res) => {
    res.end('Hello World!');
});

app.get('/users/:id', async (req, res) => {
    const userId = req.params.id;
    const queryName = req.query.name || 'Guest';
    res.end(`User ID: ${userId}, Query Name: ${queryName}`);
});

app.post('/data', async (req, res) => {
    let body = '';
    req.on('data', chunk => body += chunk.toString());
    req.on('end', () => {
        res.end(`Received data: ${body}`);
    });
});

app.listen(3000, () => {
    console.log('Server running on port 3000');
});

App

_matchPath

/users/:id

_matchAndExecuteRoute

req

/users/123

123

split('/')

indexOf

req

res

next

req

res

next

req.params

req.params.id

/users/:id

/files/*.pdf

/api/data