node.js中的express路由是什么

发布时间：2022-01-10 10:59:48 作者：iii
来源：亿速云阅读：230

# Node.js中的Express路由是什么

## 引言

在现代Web开发中，路由（Routing）是构建应用程序的核心概念之一。作为Node.js最流行的Web框架，Express提供了强大而灵活的路由系统。本文将深入探讨Express路由的方方面面，从基础概念到高级用法，帮助开发者全面掌握这一关键技术。

## 目录

1. [Express框架简介](#express框架简介)
2. [路由的基本概念](#路由的基本概念)
3. [Express路由基础](#express路由基础)
4. [路由方法](#路由方法)
5. [路由路径](#路由路径)
6. [路由参数](#路由参数)
7. [路由处理程序](#路由处理程序)
8. [路由模块化](#路由模块化)
9. [路由中间件](#路由中间件)
10. [高级路由技巧](#高级路由技巧)
11. [常见路由模式](#常见路由模式)
12. [路由最佳实践](#路由最佳实践)
13. [常见问题与解决方案](#常见问题与解决方案)
14. [总结](#总结)

## Express框架简介

Express是一个基于Node.js平台的极简、灵活的Web应用开发框架，它提供了一系列强大的特性来帮助开发者快速构建各种Web应用和API。

### Express的特点：
- 轻量级且非侵入式
- 中间件架构
- 强大的路由系统
- 支持模板引擎
- 易于扩展

```javascript
const express = require('express');
const app = express();

app.get('/', (req, res) => {
  res.send('Hello World!');
});

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

路由的基本概念

路由是指确定应用程序如何响应客户端对特定端点的请求，该端点是URI（或路径）和特定的HTTP请求方法（GET、POST等）。

路由的组成要素：

HTTP方法：GET、POST、PUT、DELETE等
路径/URL模式：字符串或正则表达式
处理函数：执行当路由匹配时的逻辑

为什么路由很重要？

组织应用程序结构
实现RESTful API
处理不同的客户端请求
实现关注点分离

Express路由基础

Express中的路由是通过app对象的方法定义的，这些方法对应于HTTP方法。

基本路由语法

app.METHOD(PATH, HANDLER)

METHOD是小写的HTTP请求方法（get, post, put, delete等）
PATH是服务器上的路径
HANDLER是当路由匹配时执行的函数

示例：基本路由

// 对主页的GET请求
app.get('/', (req, res) => {
  res.send('GET request to homepage');
});

// 对主页的POST请求
app.post('/', (req, res) => {
  res.send('POST request to homepage');
});

路由方法

Express支持与所有HTTP方法对应的路由方法，以及一些特殊方法。

常见的HTTP方法路由

// GET方法
app.get('/users', (req, res) => {
  // 获取用户列表
});

// POST方法
app.post('/users', (req, res) => {
  // 创建新用户
});

// PUT方法
app.put('/users/:id', (req, res) => {
  // 更新用户信息
});

// DELETE方法
app.delete('/users/:id', (req, res) => {
  // 删除用户
});

特殊路由方法

app.all() - 处理所有HTTP方法

app.all('/secret', (req, res) => {
  // 对/secret的任何HTTP请求都会执行
});

app.route() - 创建链式路由

app.route('/book')
  .get((req, res) => {
    res.send('Get a random book');
  })
  .post((req, res) => {
    res.send('Add a book');
  })
  .put((req, res) => {
    res.send('Update the book');
  });

路由路径

路由路径可以是字符串、字符串模式或正则表达式。

字符串路径

// 匹配根路径
app.get('/', (req, res) => {
  res.send('root');
});

// 匹配/about路径
app.get('/about', (req, res) => {
  res.send('about');
});

字符串模式路径

使用?, +, *, ()等字符创建模式：

// 匹配/acd和/abcd
app.get('/ab?cd', (req, res) => {
  res.send('ab?cd');
});

// 匹配/abcd, /abbcd, /abbbcd等
app.get('/ab+cd', (req, res) => {
  res.send('ab+cd');
});

// 匹配/abcd, /abxcd, /abRANDOMcd, /ab123cd等
app.get('/ab*cd', (req, res) => {
  res.send('ab*cd');
});

正则表达式路径

// 匹配任何路径中含有'a'的路径
app.get(/a/, (req, res) => {
  res.send('/a/');
});

// 匹配butterfly和dragonfly，但不匹配butterflyman
app.get(/.*fly$/, (req, res) => {
  res.send('/.*fly$/');
});

路由参数

路由参数是URL中命名的段，用于捕获URL中指定位置的值。

基本路由参数

app.get('/users/:userId/books/:bookId', (req, res) => {
  res.send(req.params);
  // 访问/users/34/books/8989
  // 返回: { "userId": "34", "bookId": "8989" }
});

参数验证

可以使用正则表达式限制参数格式：

// userId必须是数字
app.get('/users/:userId(\\d+)', (req, res) => {
  res.send(req.params);
});

可选参数

// /flights和/flights/LAX-SFO都匹配
app.get('/flights/:from-:to?', (req, res) => {
  const { from, to } = req.params;
  if (to) {
    res.send(`Flights from ${from} to ${to}`);
  } else {
    res.send(`All flights from ${from}`);
  }
});

路由处理程序

路由处理程序可以是一个函数，也可以是多个函数组成的数组。

单个处理函数

app.get('/example', (req, res) => {
  res.send('Hello from a single handler');
});

多个处理函数

const cb0 = (req, res, next) => {
  console.log('CB0');
  next();
};

const cb1 = (req, res, next) => {
  console.log('CB1');
  next();
};

const cb2 = (req, res) => {
  res.send('Hello from C!');
};

app.get('/example', [cb0, cb1, cb2]);

混合使用

const cb0 = (req, res, next) => {
  console.log('CB0');
  next();
};

const cb1 = (req, res, next) => {
  console.log('CB1');
  next();
};

app.get('/example', [cb0, cb1], (req, res, next) => {
  console.log('response will be sent by the next function...');
  next();
}, (req, res) => {
  res.send('Hello from D!');
});

路由模块化

随着应用规模扩大，将所有路由放在主文件中会变得难以维护。Express允许使用express.Router类创建模块化的路由处理器。

创建路由模块

routes/users.js:

const express = require('express');
const router = express.Router();

// 定义用户路由
router.get('/', (req, res) => {
  res.send('User list');
});

router.get('/:id', (req, res) => {
  res.send(`User ID: ${req.params.id}`);
});

module.exports = router;

在主应用中使用路由模块

app.js:

const usersRouter = require('./routes/users');

// ...

app.use('/users', usersRouter);

路由模块的优势

代码组织更清晰
功能模块化
便于团队协作
易于维护和测试

路由中间件

中间件函数可以访问请求对象(req)、响应对象(res)和应用程序的请求-响应周期中的下一个中间件函数(next)。

应用级中间件

// 没有挂载路径的中间件，应用的每个请求都会执行该中间件
app.use((req, res, next) => {
  console.log('Time:', Date.now());
  next();
});

// 挂载至/user/:id的中间件，任何指向/user/:id的请求都会执行它
app.use('/user/:id', (req, res, next) => {
  console.log('Request Type:', req.method);
  next();
});

路由器级中间件

const router = express.Router();

// 只在router实例上工作的中间件
router.use((req, res, next) => {
  console.log('Time:', Date.now());
  next();
});

错误处理中间件

app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).send('Something broke!');
});

内置中间件

Express提供了一些有用的内置中间件： - express.static - 提供静态文件 - express.json - 解析JSON请求体 - express.urlencoded - 解析URL编码的请求体

app.use(express.static('public'));
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

高级路由技巧

路由分组

使用express.Router()实现路由分组：

// admin.js
const router = express.Router();

router.get('/', (req, res) => {
  res.send('Admin home page');
});

router.get('/users', (req, res) => {
  res.send('Admin users page');
});

module.exports = router;

// app.js
const adminRouter = require('./admin');
app.use('/admin', adminRouter);

动态加载路由

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

fs.readdirSync(__dirname)
  .filter(file => file !== 'index.js')
  .forEach(file => {
    const route = require(path.join(__dirname, file));
    app.use(`/${file.replace('.js', '')}`, route);
  });

路由缓存

对于性能敏感的应用，可以考虑缓存路由处理结果：

const cache = {};

app.get('/heavy-route', (req, res) => {
  const key = req.originalUrl;
  
  if (cache[key]) {
    return res.send(cache[key]);
  }
  
  // 模拟耗时操作
  const result = expensiveOperation();
  
  cache[key] = result;
  res.send(result);
});

路由元数据

可以为路由添加元数据，用于文档生成或权限控制：

function route(options) {
  return (target, key, descriptor) => {
    const handler = descriptor.value;
    handler.routeOptions = options;
    return descriptor;
  };
}

class UserController {
  @route({
    description: 'Get user by ID',
    permissions: ['read:user']
  })
  getUser(req, res) {
    // ...
  }
}

常见路由模式

RESTful API路由

// 用户资源
app.route('/users')
  .get((req, res) => {
    // 获取用户列表
  })
  .post((req, res) => {
    // 创建新用户
  });

app.route('/users/:userId')
  .get((req, res) => {
    // 获取特定用户
  })
  .put((req, res) => {
    // 更新用户
  })
  .delete((req, res) => {
    // 删除用户
  });

MVC模式路由

// controllers/userController.js
exports.list = (req, res) => {
  // 获取用户列表
};

exports.create = (req, res) => {
  // 创建用户
};

// routes.js
const userController = require('./controllers/userController');

app.get('/users', userController.list);
app.post('/users', userController.create);

文件系统式路由

使用工具如express-file-routing自动根据文件结构生成路由：

routes/
  ├── index.js        -> /
  ├── users/
  │   ├── index.js    -> /users
  │   └── [id].js     -> /users/:id
  └── posts/
      ├── index.js    -> /posts
      └── [slug].js   -> /posts/:slug

路由最佳实践

保持路由简洁：路由应该只负责将请求导向正确的处理程序
使用路由模块：将相关路由分组到模块中
一致的命名约定：
- 资源使用复数名词 (/users, /products)
- 动作使用动词 (/users/:id/activate)

版本控制API：

app.use('/api/v1', v1Router);
app.use('/api/v2', v2Router);

适当的错误处理： “`javascript // 404处理 app.use((req, res, next) => { res.status(404).send(“Sorry can’t find that!”); });

// 错误处理 app.use((err, req, res, next) => { console.error(err.stack); res.status(500).send(‘Something broke!’); });


6. **文档化路由**：使用工具如Swagger自动生成API文档

7. **性能考虑**：
   - 将常用路由放在前面
   - 避免复杂的路由匹配模式
   - 考虑路由缓存

8. **安全性**：
   - 验证所有输入
   - 限制路由参数格式
   - 实施适当的身份验证和授权

## 常见问题与解决方案

### 1. 路由顺序问题

**问题**：Express按顺序匹配路由，可能导致后面的路由被忽略。

**解决方案**：
- 将特定路由放在通用路由前面
- 使用`next()`正确传递控制权

```javascript
// 错误示例 - 通用路由在前
app.get('/users/:id', getUser);  // 这个会捕获/users/new
app.get('/users/new', newUser);  // 永远不会执行

// 正确顺序
app.get('/users/new', newUser);  // 特定路由在前
app.get('/users/:id', getUser);  // 通用路由在后

2. 404处理

问题：未定义的路由如何处理？

解决方案：在所有路由之后添加404处理中间件

// 在所有其他路由之后
app.use((req, res, next) => {
  res.status(404).send("Sorry can't find that!");
});

3. 路由参数验证

问题：如何验证路由参数？

解决方案： - 使用正则表达式限制参数格式 - 在路由处理程序中验证

// 使用正则表达式
app.get('/users/:id(\\d+)', (req, res) => {
  res.send(`User ID: ${req.params.id}`);
});

// 在处理器中验证
app.get('/products/:id', (req, res, next) => {
  if (!isValidProductId(req.params.id)) {
    return res.status(400).send('Invalid product ID');
  }
  next();
}, getProduct);

4. 路由冲突

问题：多个路由匹配同一路径时如何解决？

解决方案： - 明确路由优先级 - 使用更具体的路径模式 - 重构路由结构

5. 大型应用路由管理

问题：如何管理大型应用中的数百个路由？

解决方案： - 按功能模块划分路由 - 使用动态路由加载 - 实现路由自动注册 - 使用路由命名空间

总结

Express的路由系统是框架最强大的功能之一，提供了灵活而强大的URL路由机制。通过本文，我们全面探讨了：

Express路由的基础知识和核心概念
各种路由方法和路径匹配模式
路由参数的处理和验证
模块化路由的组织方式
路由中间件的使用技巧
高级路由模式和最佳实践
常见问题的解决方案

掌握Express路由是成为Node.js开发专家的关键一步。合理设计路由结构能够使应用程序更易于维护、扩展和测试。随着应用规模的增长，良好的路由设计将带来显著的长期收益。

扩展阅读

希望本文能帮助您全面理解并有效运用Express的路由系统，构建更强大、更灵活的Web应用程序。 “`

这篇文章大约6400字，全面介绍了Express路由的各个方面，从基础概念到高级用法，包含了代码示例、最佳实践和常见问题解决方案。文章采用Markdown格式，结构清晰，便于阅读和理解。