【Node.js】Web开发框架

个人主页：Guiat
归属专栏：node.js

正文

1. Node.js Web框架概述

Node.js的生态系统提供了多种Web开发框架，它们各自具有不同的特点和适用场景。这些框架帮助开发者快速构建高性能、可维护的Web应用程序。

1.1 Web框架的作用

• 简化HTTP服务器的创建
• 提供路由管理
• 集成中间件系统
• 统一错误处理
• 提供模板引擎支持
• 简化API开发
• 改善应用程序结构

1.2 Node.js主要Web框架生态

1.3 框架选择考虑因素

mindmaproot((Web框架选择))性能需求高并发应用低延迟资源消耗开发效率开发速度学习曲线社区支持项目复杂度小型项目中型应用企业级应用团队技能TypeScript经验现有框架经验架构偏好生态系统中间件ORM支持插件丰富度应用类型REST APIGraphQL实时应用静态网站

2. Express.js

2.1 Express.js概述

Express.js是Node.js最流行的Web框架，提供了简单而灵活的API，适用于各种Web应用和API开发。

2.2 基本用法

2.2.1 安装Express

npm install express

2.2.2 创建基本服务器

const express = require('express');
const app = express();
const port = 3000;// 路由处理
app.get('/', (req, res) => {res.send('Hello World!');
});// 启动服务器
app.listen(port, () => {console.log(`服务器运行在 http://localhost:${port}`);
});

2.3 路由

// 基本路由
app.get('/users', (req, res) => {res.json([{ name: 'John' }, { name: 'Jane' }]);
});app.post('/users', (req, res) => {// 创建用户res.status(201).json({ success: true });
});// 参数路由
app.get('/users/:id', (req, res) => {const userId = req.params.id;res.json({ id: userId, name: 'John Doe' });
});// 路由模块化
const usersRoutes = express.Router();usersRoutes.get('/', (req, res) => { /* ... */ });
usersRoutes.post('/', (req, res) => { /* ... */ });
usersRoutes.get('/:id', (req, res) => { /* ... */ });app.use('/api/users', usersRoutes);

2.4 中间件

// 内置中间件
app.use(express.json()); // 解析JSON请求体
app.use(express.urlencoded({ extended: true })); // 解析URL编码的请求体
app.use(express.static('public')); // 提供静态文件// 自定义中间件
app.use((req, res, next) => {console.log(`${req.method} ${req.url} at ${new Date()}`);next(); // 继续下一个中间件
});// 路由特定中间件
const authenticate = (req, res, next) => {const token = req.headers.authorization;if (!token) {return res.status(401).json({ error: '未授权' });}// 验证token...next();
};app.get('/protected', authenticate, (req, res) => {res.json({ message: '受保护的数据' });
});// 错误处理中间件
app.use((err, req, res, next) => {console.error(err.stack);res.status(500).json({ error: '服务器内部错误' });
});

2.5 请求和响应

// 请求对象(req)
app.get('/example', (req, res) => {console.log(req.query);     // 查询参数console.log(req.params);    // 路由参数console.log(req.body);      // 请求体console.log(req.headers);   // 请求头console.log(req.cookies);   // Cookies (需要cookie-parser)console.log(req.ip);        // 客户端IPconsole.log(req.path);      // 请求路径console.log(req.method);    // HTTP方法// 响应对象(res)res.status(200);            // 设置状态码res.set('Content-Type', 'application/json'); // 设置响应头res.cookie('name', 'value', { maxAge: 900000 }); // 设置cookieres.json({ data: 'JSON响应' }); // 发送JSON响应res.send('文本响应');       // 发送通用响应res.sendFile('/path/to/file.pdf'); // 发送文件res.download('/report.pdf'); // 下载文件res.redirect('/new-page'); // 重定向res.render('template', { title: '模板渲染' }); // 渲染模板
});

2.6 完整的Express应用结构

project-root/
├── config/                  # 配置文件
│   ├── database.js
│   └── app.js
├── controllers/             # 控制器
│   ├── userController.js
│   └── productController.js
├── middleware/              # 中间件
│   ├── auth.js
│   └── errorHandler.js
├── models/                  # 数据模型
│   ├── User.js
│   └── Product.js
├── routes/                  # 路由
│   ├── userRoutes.js
│   └── productRoutes.js
├── public/                  # 静态资源
│   ├── css/
│   ├── js/
│   └── images/
├── views/                   # 视图模板
│   ├── layouts/
│   ├── users/
│   └── products/
├── tests/                   # 测试
│   ├── unit/
│   └── integration/
├── app.js                   # 主应用文件
├── server.js                # 服务器启动文件
├── package.json
└── .env                     # 环境变量

3. Koa.js

3.1 Koa.js概述

Koa是由Express团队开发的更轻量级、更富有表现力的Node.js Web框架，专为异步编程设计，利用async/await特性提供更简洁的中间件机制。

3.2 基本用法

3.2.1 安装Koa

npm install koa

3.2.2 创建基本服务器

const Koa = require('koa');
const app = new Koa();
const port = 3000;// 中间件
app.use(async (ctx, next) => {const start = Date.now();await next();const ms = Date.now() - start;console.log(`${ctx.method} ${ctx.url} - ${ms}ms`);
});app.use(async ctx => {ctx.body = 'Hello World';
});app.listen(port, () => {console.log(`服务器运行在 http://localhost:${port}`);
});

3.3 中间件和上下文

// 错误处理中间件
app.use(async (ctx, next) => {try {await next();} catch (err) {ctx.status = err.statusCode || 500;ctx.body = {message: err.message};ctx.app.emit('error', err, ctx);}
});// 数据解析中间件
const bodyParser = require('koa-bodyparser');
app.use(bodyParser());// 路由中间件
const Router = require('@koa/router');
const router = new Router();router.get('/', async (ctx) => {ctx.body = { message: '首页' };
});router.get('/users/:id', async (ctx) => {const userId = ctx.params.id;ctx.body = { id: userId, name: 'John Doe' };
});app.use(router.routes());
app.use(router.allowedMethods());// 上下文操作示例
app.use(async ctx => {// 请求数据console.log(ctx.request.query);  // 查询参数console.log(ctx.request.body);   // 请求体 (需要bodyParser)console.log(ctx.params);         // 路由参数 (需要路由中间件)// 响应设置ctx.status = 200;                // 状态码ctx.set('X-Custom-Header', 'value'); // 自定义响应头ctx.type = 'application/json';   // 内容类型ctx.body = { data: 'success' };  // 响应体// Cookiesctx.cookies.set('name', 'value', { maxAge: 86400000 });const cookie = ctx.cookies.get('name');
});

3.4 Koa与Express对比

4. Nest.js

4.1 Nest.js概述

Nest.js是一个用于构建高效、可靠、可扩展的服务器端应用程序的渐进式Node.js框架，它结合了面向对象编程、函数式编程和函数响应式编程的元素。

4.2 基本用法

4.2.1 安装Nest.js

npm i -g @nestjs/cli
nest new project-name

4.2.2 主要组件

// 控制器 (users.controller.ts)
import { Controller, Get, Post, Body, Param, UseGuards } from '@nestjs/common';
import { UsersService } from './users.service';
import { CreateUserDto } from './dto/create-user.dto';
import { AuthGuard } from '../auth/auth.guard';@Controller('users')
export class UsersController {constructor(private readonly usersService: UsersService) {}@Get()findAll() {return this.usersService.findAll();}@Get(':id')findOne(@Param('id') id: string) {return this.usersService.findOne(+id);}@Post()@UseGuards(AuthGuard)create(@Body() createUserDto: CreateUserDto) {return this.usersService.create(createUserDto);}
}// 服务 (users.service.ts)
import { Injectable } from '@nestjs/common';
import { CreateUserDto } from './dto/create-user.dto';
import { User } from './entities/user.entity';@Injectable()
export class UsersService {private readonly users: User[] = [];create(createUserDto: CreateUserDto): User {const user = { id: this.users.length + 1, ...createUserDto };this.users.push(user);return user;}findAll(): User[] {return this.users;}findOne(id: number): User {return this.users.find(user => user.id === id);}
}// 模块 (users.module.ts)
import { Module } from '@nestjs/common';
import { UsersController } from './users.controller';
import { UsersService } from './users.service';@Module({controllers: [UsersController],providers: [UsersService],exports: [UsersService]
})
export class UsersModule {}// 主模块 (app.module.ts)
import { Module } from '@nestjs/common';
import { UsersModule } from './users/users.module';
import { AuthModule } from './auth/auth.module';@Module({imports: [UsersModule, AuthModule],
})
export class AppModule {}

4.3 依赖注入

// 定义提供者
@Injectable()
export class CatsService {private readonly cats: Cat[] = [];create(cat: Cat) {this.cats.push(cat);}findAll(): Cat[] {return this.cats;}
}// 注册提供者
@Module({controllers: [CatsController],providers: [CatsService],
})
export class CatsModule {}// 消费依赖
@Controller('cats')
export class CatsController {constructor(private readonly catsService: CatsService) {}@Get()findAll() {return this.catsService.findAll();}
}

4.4 中间件、守卫和拦截器

// 中间件
@Injectable()
export class LoggerMiddleware implements NestMiddleware {use(req: Request, res: Response, next: Function) {console.log(`Request... ${req.method} ${req.url}`);next();}
}// 使用中间件
@Module({imports: [UsersModule],
})
export class AppModule implements NestModule {configure(consumer: MiddlewareConsumer) {consumer.apply(LoggerMiddleware).forRoutes('users');}
}// 守卫
@Injectable()
export class AuthGuard implements CanActivate {canActivate(context: ExecutionContext,): boolean | Promise<boolean> | Observable<boolean> {const request = context.switchToHttp().getRequest();// 验证逻辑return isAuthorized(request);}
}// 拦截器
@Injectable()
export class TransformInterceptor implements NestInterceptor {intercept(context: ExecutionContext, next: CallHandler): Observable<any> {console.log('Before...');return next.handle().pipe(map(data => {console.log('After...');return { data, timestamp: new Date().toISOString() };}),);}
}// 管道
@Injectable()
export class ValidationPipe implements PipeTransform {transform(value: any, metadata: ArgumentMetadata) {// 数据验证和转换逻辑return validatedValue;}
}

5. Fastify

5.1 Fastify概述

Fastify是一个专注于性能和低开销的快速Web框架，提供了一套精简API，适合构建高性能的服务。

5.2 基本用法

5.2.1 安装Fastify

npm install fastify

5.2.2 创建服务器

const fastify = require('fastify')({ logger: true });
const port = 3000;// 定义路由
fastify.get('/', async (request, reply) => {return { hello: 'world' };
});// 启动服务器
const start = async () => {try {await fastify.listen({ port });fastify.log.info(`服务器运行在 ${fastify.server.address().port}`);} catch (err) {fastify.log.error(err);process.exit(1);}
};start();

5.3 Schema验证和序列化

// 定义带有Schema的路由
fastify.route({method: 'POST',url: '/users',schema: {body: {type: 'object',required: ['name', 'email'],properties: {name: { type: 'string' },email: { type: 'string', format: 'email' },age: { type: 'integer', minimum: 18 }}},response: {200: {type: 'object',properties: {id: { type: 'integer' },name: { type: 'string' },email: { type: 'string' }}}}},handler: async (request, reply) => {const { name, email, age } = request.body;// 处理创建用户的逻辑const user = { id: 1, name, email };return user;}
});

5.4 插件系统

// 定义插件
const myPlugin = async (fastify, options) => {// 注册钩子fastify.addHook('onRequest', async (request, reply) => {request.log.info('请求已接收');});// 注册路由fastify.get('/plugin-route', async (request, reply) => {return { message: '这是插件路由' };});// 装饰fastify实例fastify.decorate('utility', function() {return 'utility value';});// 装饰请求fastify.decorateRequest('customProp', 'custom value');
};// 注册插件
fastify.register(myPlugin, { pluginOption: 'value' });// 使用插件功能
fastify.get('/use-plugin', async (request, reply) => {console.log(fastify.utility());console.log(request.customProp);return { success: true };
});

5.5 与Express和Koa性能对比

bartitle Node.js框架性能对比(请求/秒)"Express" : 12000"Koa" : 15000"Fastify" : 30000"Bare Node.js" : 35000

6. Next.js

6.1 Next.js概述

Next.js是一个React框架，用于构建服务器渲染、静态生成和客户端渲染的React应用。它提供了现代Web应用所需的所有功能，如路由、图像优化、API路由等。

6.2 基本用法

6.2.1 创建Next.js应用

npx create-next-app my-next-app
# 或
yarn create next-app my-next-app

6.2.2 页面和路由

// pages/index.js - 主页
import Head from 'next/head';export default function Home() {return (<div><Head><title>Next.js应用</title><meta name="description" content="我的Next.js应用" /></Head><main><h1>欢迎来到Next.js!</h1></main></div>);
}// pages/users/[id].js - 动态路由
import { useRouter } from 'next/router';export default function User() {const router = useRouter();const { id } = router.query;return (<div><h1>用户: {id}</h1></div>);
}// pages/about.js - 静态页面
export default function About() {return (<div><h1>关于我们</h1><p>这是关于页面的内容</p></div>);
}

6.3 数据获取方法

// 服务器端渲染示例 (SSR)
export async function getServerSideProps(context) {// 从服务器获取数据const res = await fetch('https://api.example.com/data');const data = await res.json();// 将数据传递给页面组件return {props: { data }, // 作为props传递给页面};
}// 静态生成示例 (SSG)
export async function getStaticProps() {// 在构建时获取数据const res = await fetch('https://api.example.com/static-data');const data = await res.json();return {props: { data },revalidate: 60, // 增量静态再生成 (ISR) - 每60秒更新};
}// 静态路径示例
export async function getStaticPaths() {// 获取所有可能的路径const res = await fetch('https://api.example.com/users');const users = await res.json();// 为每个用户生成路径const paths = users.map((user) => ({params: { id: user.id.toString() },}));return {paths,fallback: 'blocking', // 或 true 或 false};
}

6.4 API路由

// pages/api/hello.js
export default function handler(req, res) {res.status(200).json({ message: 'Hello World!' });
}// pages/api/users/[id].js - 动态API路由
export default function handler(req, res) {const { id } = req.query;const { method } = req;switch (method) {case 'GET':// 获取用户res.status(200).json({ id, name: 'John Doe' });break;case 'PUT':// 更新用户res.status(200).json({ id, ...req.body });break;case 'DELETE':// 删除用户res.status(200).json({ id, deleted: true });break;default:res.setHeader('Allow', ['GET', 'PUT', 'DELETE']);res.status(405).end(`Method ${method} Not Allowed`);}
}

6.5 中间件和布局

// middleware.js (Next.js 12+)
import { NextResponse } from 'next/server';export function middleware(request) {// 检查身份验证const token = request.cookies.get('token');if (!token && request.nextUrl.pathname.startsWith('/dashboard')) {return NextResponse.redirect(new URL('/login', request.url));}return NextResponse.next();
}// _app.js - 全局布局
import '../styles/globals.css';
import Layout from '../components/Layout';function MyApp({ Component, pageProps }) {// 如果页面有自定义布局，使用它，否则使用默认布局const getLayout = Component.getLayout || ((page) => <Layout>{page}</Layout>);return getLayout(<Component {...pageProps} />);
}export default MyApp;// components/Layout.js
export default function Layout({ children }) {return (<><header>网站头部</header><main>{children}</main><footer>网站底部</footer></>);
}

7. Hapi.js

7.1 Hapi.js概述

Hapi.js是一个功能丰富的框架，专注于配置而非代码，旨在帮助开发者构建可扩展的API和服务。

7.2 基本用法

7.2.1 安装Hapi

npm install @hapi/hapi

7.2.2 创建服务器

const Hapi = require('@hapi/hapi');const init = async () => {const server = Hapi.server({port: 3000,host: 'localhost'});// 定义路由server.route({method: 'GET',path: '/',handler: (request, h) => {return 'Hello World!';}});await server.start();console.log('服务器运行在 %s', server.info.uri);
};process.on('unhandledRejection', (err) => {console.log(err);process.exit(1);
});init();

7.3 路由和处理程序

// 基本路由
server.route({method: 'GET',path: '/users/{id}',handler: (request, h) => {const id = request.params.id;return { id, name: 'John Doe' };}
});// 使用路由选项
server.route({method: 'POST',path: '/users',options: {validate: {payload: Joi.object({name: Joi.string().min(3).required(),email: Joi.string().email().required()})},auth: 'jwt',tags: ['api', 'users'],description: '创建新用户'},handler: async (request, h) => {const user = await createUser(request.payload);return h.response(user).code(201);}
});// 路由通配符和参数
server.route({method: 'GET',path: '/files/{param*}',handler: (request, h) => {const path = request.params.param || '';return `请求的文件路径: ${path}`;}
});

7.4 插件和扩展

// 定义插件
const myPlugin = {name: 'myPlugin',version: '1.0.0',register: async function (server, options) {// 添加路由server.route({method: 'GET',path: '/plugin-route',handler: (request, h) => {return { plugin: 'myPlugin' };}});// 注册扩展点server.ext('onRequest', (request, h) => {request.app.requestTime = new Date().getTime();return h.continue;});// 添加方法server.method('calculateTax', (price) => {return price * 0.2;});}
};// 注册插件
const init = async () => {const server = Hapi.server({ /* ... */ });await server.register({plugin: myPlugin,options: { /* 插件选项 */ }});// 使用插件提供的方法server.route({method: 'GET',path: '/tax/{price}',handler: (request, h) => {const price = parseFloat(request.params.price);const tax = server.methods.calculateTax(price);return { price, tax, total: price + tax };}});await server.start();
};

7.5 验证和认证

// 安装依赖
// npm install @hapi/joi @hapi/basic @hapi/jwtconst Joi = require('@hapi/joi');
const Basic = require('@hapi/basic');
const JWT = require('@hapi/jwt');const init = async () => {const server = Hapi.server({ /* ... */ });// 注册认证插件await server.register([Basic, JWT]);// 配置JWT认证策略server.auth.strategy('jwt', 'jwt', {keys: 'your-secret-key',verify: {aud: 'urn:audience:app',iss: 'urn:issuer:app',sub: false,maxAgeSec: 14400 // 4小时},validate: (artifacts, request, h) => {return {isValid: true,credentials: { user: artifacts.decoded.payload.user }};}});// 配置基本认证策略server.auth.strategy('simple', 'basic', {validate: async (request, username, password, h) => {// 验证逻辑const isValid = username === 'admin' && password === 'password';const credentials = { id: 1, name: username };return { isValid, credentials };}});// 设置默认认证策略server.auth.default('jwt');// 带有验证的路由server.route({method: 'POST',path: '/users',options: {auth: 'jwt',validate: {payload: Joi.object({name: Joi.string().min(3).max(50).required(),email: Joi.string().email().required(),age: Joi.number().integer().min(18).required()}),query: Joi.object({includeDetails: Joi.boolean().default(false)}),failAction: (request, h, err) => {throw err; // 将验证错误返回给客户端}}},handler: async (request, h) => {// 处理创建用户的逻辑return { success: true };}});await server.start();
};

8. 全栈框架: AdonisJS和Sails.js

8.1 AdonisJS概述

AdonisJS是一个全栈MVC框架，提供开箱即用的ORM、身份验证、授权等功能，类似于Laravel(PHP)和Rails(Ruby)的开发体验。

8.2 AdonisJS基本用法

8.2.1 创建AdonisJS应用

npm init adonis-ts-app@latest my-app

8.2.2 AdonisJS应用结构

my-app/
├── app/                   # 应用代码
│   ├── Controllers/       # 控制器
│   ├── Models/            # 数据模型
│   ├── Middleware/        # 中间件
│   ├── Validators/        # 验证器
│   └── Services/          # 服务
├── config/                # 配置文件
├── contracts/             # TypeScript接口定义
├── database/              # 数据库相关
│   ├── migrations/        # 数据库迁移
│   └── seeders/           # 数据种子
├── providers/             # 服务提供者
├── public/                # 静态资源
├── resources/             # 视图和其他资源
│   └── views/             # 视图模板
├── start/                 # 启动文件
│   ├── routes.ts          # 路由定义
│   ├── kernel.ts          # HTTP内核配置
│   └── events.ts          # 事件监听器
├── .env                   # 环境变量
└── server.ts              # 服务器启动文件

8.2.3 路由和控制器

// start/routes.ts
import Route from '@ioc:Adonis/Core/Route'Route.get('/', 'HomeController.index')
Route.get('/about', 'HomeController.about')Route.group(() => {Route.get('/', 'PostsController.index')Route.post('/', 'PostsController.store').middleware('auth')Route.get('/:id', 'PostsController.show')Route.put('/:id', 'PostsController.update').middleware('auth')Route.delete('/:id', 'PostsController.destroy').middleware('auth')
}).prefix('/api/posts')// app/Controllers/Http/PostsController.ts
import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'
import Post from 'App/Models/Post'export default class PostsController {public async index({ request, response }: HttpContextContract) {const page = request.input('page', 1)const limit = request.input('limit', 10)const posts = await Post.query().paginate(page, limit)return response.ok(posts)}public async store({ request, response, auth }: HttpContextContract) {const postData = request.only(['title', 'content'])const post = await Post.create({...postData,userId: auth.user!.id})return response.created(post)}public async show({ params, response }: HttpContextContract) {const post = await Post.find(params.id)if (!post) {return response.notFound({ message: '文章未找到' })}return response.ok(post)}
}

8.3 Sails.js概述

Sails.js是一个基于Express的全栈MVC框架，专注于企业级应用开发，提供了自动生成REST API、实时WebSocket等功能。

8.4 Sails.js基本用法

8.4.1 创建Sails.js应用

npm install sails -g
sails new my-sails-app
cd my-sails-app
sails lift

8.4.2 模型和API

// api/models/User.js
module.exports = {attributes: {name: {type: 'string',required: true},email: {type: 'string',required: true,unique: true,isEmail: true},posts: {collection: 'post',via: 'owner'}}
};// api/models/Post.js
module.exports = {attributes: {title: {type: 'string',required: true},content: {type: 'string'},owner: {model: 'user'}}
};// api/controllers/PostController.js
module.exports = {// 自定义动作featured: async function(req, res) {const featuredPosts = await Post.find({ isFeatured: true });return res.json(featuredPosts);},// 覆盖默认动作create: async function(req, res) {// 自定义创建逻辑try {const postData = req.body;postData.owner = req.session.userId;const newPost = await Post.create(postData).fetch();return res.status(201).json(newPost);} catch (err) {return res.serverError(err);}}
};

8.4.3 路由配置

// config/routes.js
module.exports.routes = {// 自定义REST路由'GET /api/posts/featured': 'PostController.featured',// 蓝图API路由 (自动生成)'GET /api/posts': 'PostController.find','GET /api/posts/:id': 'PostController.findOne','POST /api/posts': 'PostController.create','PATCH /api/posts/:id': 'PostController.update','DELETE /api/posts/:id': 'PostController.destroy',// 视图路由'GET /': { view: 'pages/homepage' }
};// config/blueprints.js
module.exports.blueprints = {// 启用/禁用 REST 路由rest: true,// 启用/禁用 CRUD 快捷方式shortcuts: false,// 启用/禁用 WebSocket 动作actions: false,// REST 前缀prefix: '/api'
};

9. 专业领域框架

9.1 Loopback - API框架

9.1.1 基本使用

npm install -g @loopback/cli
lb4 app my-api

// 定义模型
import {Entity, model, property} from '@loopback/repository';@model()
export class Product extends Entity {@property({type: 'number',id: true,generated: true,})id?: number;@property({type: 'string',required: true,})name: string;@property({type: 'number',required: true,})price: number;constructor(data?: Partial<Product>) {super(data);}
}// 定义存储库
import {DefaultCrudRepository} from '@loopback/repository';
import {Product} from '../models';
import {DbDataSource} from '../datasources';
import {inject} from '@loopback/core';export class ProductRepository extends DefaultCrudRepository<Product,typeof Product.prototype.id
> {constructor(@inject('datasources.db') dataSource: DbDataSource) {super(Product, dataSource);}
}// 定义控制器
import {Count,CountSchema,Filter,FilterExcludingWhere,repository,Where,
} from '@loopback/repository';
import {post,param,get,getModelSchemaRef,patch,put,del,requestBody,response,
} from '@loopback/rest';
import {Product} from '../models';
import {ProductRepository} from '../repositories';export class ProductController {constructor(@repository(ProductRepository)public productRepository : ProductRepository,) {}@post('/products')@response(200, {description: 'Product model instance',content: {'application/json': {schema: getModelSchemaRef(Product)}},})async create(@requestBody({content: {'application/json': {schema: getModelSchemaRef(Product, {title: 'NewProduct',exclude: ['id'],}),},},})product: Omit<Product, 'id'>,): Promise<Product> {return this.productRepository.create(product);}@get('/products/{id}')@response(200, {description: 'Product model instance',content: {'application/json': {schema: getModelSchemaRef(Product, {includeRelations: true}),},},})async findById(@param.path.number('id') id: number,@param.filter(Product, {exclude: 'where'}) filter?: FilterExcludingWhere<Product>): Promise<Product> {return this.productRepository.findById(id, filter);}
}

9.2 Strapi - 内容管理框架

9.2.1 基本使用

npx create-strapi-app my-project

// 自定义控制器
// ./src/api/article/controllers/custom.js
module.exports = {async featured(ctx) {try {const featuredArticles = await strapi.db.query('api::article.article').findMany({where: { featured: true },populate: ['cover', 'category', 'author'],});return featuredArticles;} catch (err) {ctx.body = err;}},
};// 自定义路由
// ./src/api/article/routes/custom.js
module.exports = {routes: [{method: 'GET',path: '/articles/featured',handler: 'custom.featured',config: {policies: [],middlewares: [],},},],
};// 生命周期钩子
// ./src/api/article/content-types/article/lifecycles.js
module.exports = {beforeCreate(event) {const { data, where, select, populate } = event.params;// 自动生成slugif (data.title && !data.slug) {data.slug = slugify(data.title, { lower: true });}},afterCreate(event) {const { result, params } = event;// 发送通知console.log(`Created article: ${result.title}`);},
};

10. 框架选择指南与比较

10.1 框架特性对比

10.2 适用场景选择

mindmaproot((选择框架))微服务FastifyNest.jsExpress企业应用Nest.jsLoopbackHapi.jsAPI开发ExpressFastifyKoaLoopback全栈应用Next.jsAdonisJSSails.js内容平台StrapiNext.js实时应用Sails.jsSocket.io + Express

结语
感谢您的阅读！期待您的一键三连！欢迎指正！