mock项目中nest执行过程:
import { NestFactory } from '@nestjs/core'
import { Module, Req, Injectable, NestMiddleware, NestInterceptor, ExecutionContext, Res, Header, CallHandler, Controller, Get, MiddlewareConsumer, NestModule } from '@nestjs/common'
import { AsyncLocalStorage } from 'async_hooks'
import { Observable, throwError } from 'rxjs'
import { catchError, tap, finalize } from "rxjs/operators"
import { APP_INTERCEPTOR } from '@nestjs/core'
import { Request, Response } from 'express'
// 模拟异步操作链数据存储
@Injectable()
class ClsService {
als: AsyncLocalStorage<Record<string, unknown>>
constructor() {
this.als = new AsyncLocalStorage()
}
get(key: string) {
return this.als.getStore()?.[key]
}
set(key: string, value: unknown) {
if (this.als.getStore()) {
(this.als.getStore() as Record<string, unknown>)[key] = value
}
}
}
// 模拟中间件
@Injectable()
class ClsMiddleWare implements NestMiddleware {
constructor(private ClsService: ClsService) {
console.log('Middleware registry')
}
async use(req: Request, res: Response, next: () => void) {
const realIp = req.headers['x-real-ip'] as string || '0.0.0.0'
console.log('Middleware executed, IP:', realIp)
console.log('Middleware enter', this.ClsService.als.getStore())
this.ClsService.als.run({ ip: realIp }, () => {
next()
setTimeout(() => {
console.log('Middleware timeout', this.ClsService.als.getStore())
}, 10)
console.log('Middleware exit 1', this.ClsService.als.getStore())
})
console.log('Middleware exit', this.ClsService.als.getStore())
}
}
// 模拟拦截器
@Injectable()
class LoggingInterceptor implements NestInterceptor {
constructor(private ClsService: ClsService) {
console.log('Interceptor registry')
}
intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
console.log('Interceptor executed')
return next.handle().pipe(
tap((result) => {
let req = context.switchToHttp().getRequest() as Request
let res = context.switchToHttp().getResponse()
let cl = (res as Response).get("content-length")
console.log("sync===", cl, res.get("content-length"), res.headersSent, result)
setTimeout(() => {
console.log("===async===", cl, res.get("content-length"), res.headersSent, result)
}, 0)
}),
catchError((error) => {
// console.log("interceptor", error)
return throwError(() => error)
}),
finalize(() => {
// console.log("entry finalize===")
})
)
}
}
// 模拟控制器
@Controller('example')
class ExampleController {
constructor() { }
@Get("")
test() {
console.log('Controller method executed')
return { message: 'this is nest return' }
}
@Get("express")
express(@Req() req: Request,
@Res() res: Response
) {
console.log('Controller method executed')
res.send({
message: "this is express send"
})
}
@Get("/stream")
getExample(@Req() req: Request,
@Res() res: Response
) {
console.log('Controller method executed')
let i = 1
res.contentType("application/octet-stream")
setInterval(() => {
res.write(Buffer.from("abcdefg"))
if (i++ > 10) {
// stream.close()
res.end()
}
}, 1000)
}
}
// 应用模块
@Module({
imports: [],
controllers: [ExampleController],
providers: [
ClsService,
{
provide: APP_INTERCEPTOR,
useClass: LoggingInterceptor,
},
],
})
export class AppModule implements NestModule {
configure(consumer: MiddlewareConsumer) {
consumer
.apply(ClsMiddleWare)
.forRoutes('*') // 应用到所有路由
}
}
// 启动应用
async function bootstrap() {
const app = await NestFactory.create(AppModule)
await app.listen(3000)
}
bootstrap()
此时访问:http://localhost:3000/example
此时控制台输出的内容为:
Middleware executed, IP: 0.0.0.0
Middleware enter undefined
Middleware exit 1 { ip: '0.0.0.0' }
Middleware exit undefined
Interceptor executed
Controller method executed
sync=== undefined undefined false { message: 'this is nest return' }
===async=== undefined 33 true { message: 'this is nest return' }
Middleware timeout { ip: '0.0.0.0' }
这里可以得到4个信息
- 在宏任务0的异步阶段响应头已经发送
- 在未发送时是无法获取content-length的,发送后可获取到
- get(“content-length”)获取的是快照
- 无论在哪个阶段,使用return的方式返回的数据在interceptor中是可以获取的
接下来访问:http://localhost:3000/example/express
此时控制台输出的内容为:
Middleware executed, IP: 0.0.0.0
Middleware enter undefined
Middleware exit 1 { ip: '0.0.0.0' }
Middleware exit undefined
Interceptor executed
Controller method executed
sync=== 34 34 true undefined
===async=== 34 34 true undefined
Middleware timeout { ip: '0.0.0.0' }
可以看到直接send的情况,同步时已经将响应发送完毕了,此时同步异步都可以拿到headers
接下来访问:http://localhost:3000/example/stream
此时控制台输出的内容为:
Middleware executed, IP: 0.0.0.0
Middleware enter undefined
Middleware exit 1 { ip: '0.0.0.0' }
Middleware exit undefined
Interceptor executed
Controller method executed
sync=== undefined undefined false undefined
===async=== undefined undefined false undefined
Middleware timeout { ip: '0.0.0.0' }
可以看到直接send的情况,无论是同步还是延时0的宏任务都是拿不到数据的
此时在interceptor中增加:
res.on("finish", () => {
console.log("===response finished", cl, res.get("content-length"), res.headersSent, result)
})
此时的控制台输出为:
Middleware executed, IP: 0.0.0.0
Middleware enter undefined
Middleware exit 1 { ip: '0.0.0.0' }
Middleware exit undefined
Interceptor executed
Controller method executed
sync=== undefined undefined false undefined
===async=== undefined undefined false undefined
Middleware timeout { ip: '0.0.0.0' }
===response finished undefined undefined true undefined
可以看到面对数据流的情况,即使是发送完成也无法获取到content-length 这种情况目前可以暂不考虑。
目前得到的结论是,如果想稳定拿到contentLength,最好是监听finish事件,即
res.on("finish", () => {
console.log("===response finished", res.get("content-length"))
})
// 可以优化为:
res.once("finish", () => {
console.log("===response finished", res.get("content-length"))
})
鉴于闭包的形式可能引起的内存泄漏的问题,所以最终采用计算result的方式
let res = context.switchToHttp().getResponse()
let contentLength = res.get("content-length")
if (!contentLength && result) {
try {
contentLength = Buffer.from(JSON.stringify(result)).length ?? 0
} catch (error) {
contentLength ??= 0
}
}