中间件

什么是中间件

中间件 (Middleware) 是在路由处理程序之前调用的函数。中间件函数可以访问请求和响应对象，以及应用程序请求响应周期中的 next() 中间件函数。

中间件函数可以执行以下任务：

• 执行任何代码
• 对请求和响应对象进行更改
• 结束请求 - 响应周期
• 调用堆栈中的下一个中间件函数
• 如果当前的中间件函数没有结束请求 - 响应周期，它必须调用 next() 将控制传递给下一个中间件函数。否则，请求将被挂起。

普通中间件

让我们创建一个简单的普通中间件，它只是记录进入和离开中间件函数的日志消息。

使用下面的命令创建一个中间件：

nest g middleware logging --flat

中间件内容如下：

// src/logging.middleware.ts

import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response } from 'express';

@Injectable()
export class LoggingMiddleware implements NestMiddleware {
    use(req: Request, res: Response, next: () => void) {
        console.log('请求前');
        next();
        console.log('请求后');
    }
}

在 app.module.ts 中注册中间件：

// src/app.module.ts

import { MiddlewareConsumer, Module, NestModule } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { LoggingMiddleware } from './logging.middleware';

@Module({
    imports: [],
    controllers: [AppController],
    providers: [AppService],
})
export class AppModule implements NestModule {
    configure(consumer: MiddlewareConsumer) {
        consumer.apply(LoggingMiddleware).forRoutes('*');
    }
}

局部中间件

在 forRoutes 中设置中间件的路由路径、控制器、请求路径和方法，在 exclude 中设置排除的路径、请求路径：

// src/app.module.ts

import { MiddlewareConsumer, Module, NestModule } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { LoggingMiddleware } from './logging.middleware';
import { UserController } from './user/user.controller';
import { UserService } from './user/user.service';

@Module({
    imports: [],
    controllers: [AppController, UserController],
    providers: [AppService, UserService],
})
export class AppModule implements NestModule {
    configure(consumer: MiddlewareConsumer) {
        consumer
            .apply(LoggingMiddleware)
            .exclude('/user/test')
            .forRoutes('/user');
    }
}

或：

// src/app.module.ts

import {
    MiddlewareConsumer,
    Module,
    NestModule,
    RequestMethod,
} from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { LoggingMiddleware } from './logging.middleware';
import { UserController } from './user/user.controller';
import { UserService } from './user/user.service';

@Module({
    imports: [],
    controllers: [AppController, UserController],
    providers: [AppService, UserService],
})
export class AppModule implements NestModule {
    configure(consumer: MiddlewareConsumer) {
        consumer
            .apply(LoggingMiddleware)
            .exclude({ path: 'user', method: RequestMethod.POST })
            .forRoutes(UserController);
    }
}

或：

// src/app.module.ts

import {
    MiddlewareConsumer,
    Module,
    NestModule,
    RequestMethod,
} from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { LoggingMiddleware } from './logging.middleware';

@Module({
    imports: [],
    controllers: [AppController],
    providers: [AppService],
})
export class AppModule implements NestModule {
    configure(consumer: MiddlewareConsumer) {
        consumer
            .apply(LoggingMiddleware)
            .forRoutes({ path: 'user', method: RequestMethod.GET });
    }
}

全局中间件

全局中间件是应用到每个路由的处理程序。

在 app.module.ts 中注册全局中间件：

// src/app.module.ts

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { LoggingMiddleware } from './logging.middleware';

async function bootstrap() {
    const app = await NestFactory.create(AppModule);
    app.use(new LoggingMiddleware().use);
    await app.listen(3000);
}
bootstrap();