Let's talk about how the node framework Nest.js integrates Express with loose coupling!

This article will let you talk about how the node framework Nest.js integrates Express in a loosely coupled manner. I hope it will be helpful to everyone!

Nodejs provides the http module for listening to ports, processing http requests, and returning responses, which is what it mainly does.

But the api of the http module is too primitive, and it is troublesome to process request responses directly based on it, so we will encapsulate it with a library such as express.

What this layer does is to add a lot of request and response processing methods to request and response to meet the needs of various scenarios, and handle routing, and also provide middleware call chains. To facilitate the reuse of some code, this middleware call chain is called the onion model.

#But this layer does not solve the architectural problem: what to do when there are too many modules, and how to manage them? How to divide Model, View and Controller? etc.

So, when using Node.js for back-end services, we will include another layer to solve the architectural problem. The frameworks at this layer include eggjs (ant), midwayjs (Taobao), nestjs (foreign) ).

nestjs is one of the best:

##This layer The bottom layer is express, koa, etc. It just solves additional architectural problems based on those http frameworks.

And nestjs does something particularly good. It does not rely on any http platform and can be switched flexibly.

So how does nestjs achieve switching of the underlying platform?

Think about how react renders vdom to canvas, dom, and native?

Define a unified interface, and the render logic of various platforms implements these interfaces. This mode is called adapter mode.

The adapter mode is when a function implemented by a third party is used, it does not rely directly on it, but defines a layer of interfaces to allow the third party to adapt to this layer of interfaces. In this way, any solution that adapts to this layer of interfaces can be integrated, and solutions can be switched flexibly.

Nest.js provides a layer of interface (HttpServer) for the underlying http platform and defines a bunch of methods:

Because the interface of ts must implement all methods, in order to simplify it, it inherits an abstract class AbstractHttpAdapter and defines the methods that need to be implemented as abstract.

Then express or other platforms such as fastify can be connected to Nest.js as long as they inherit the adapter class and implement the abstract methods:

For example, ExpressAdapter:

or FastifyAdapter:

These logics are placed on platform-express and platform-fastify respectively In the package:

Nest.js The first line of code is to call create:

create will select a Type httpAdapter to create the service:

The default is express:

In this way, the request and response methods are called later In the end, it’s all express.

For example, in the controller, you can use the @Request decorator to inject the reqeust object, and you can call various methods of reqeust.

import { Controller, Get, Request } from '@nestjs/common';

@Controller('cats')
export class CatsController {
  @Get()
  findAll(@@Request() request: Request): string {
    return 'This action returns all cats';
  }
}

If you want to call some platform-specific methods outside of the interface, Nest.js also supports it, then use @Req to inject:

import { Controller, Get, Req } from '@nestjs/common';

@Controller('cats')
export class CatsController {
  @Get()
  findAll(@@Req() request: Request): string {
    return 'This action returns all cats';
  }
}

What is injected in this way is a specific platform For example, express's native request object can directly use all its methods.

In addition, if you really want to use the specific api of the Express platform, you can specify the corresponding type parameters when NestFactory.create, so that you can do the corresponding type prompts and checks:

But this will be coupled with a specific platform. Unless you are sure that you will not switch platforms, it is not recommended.

The http platform does this, and similarly, the websocket platform does the same:

defines a unified interface, which can be flexibly connected to socketio and websocket through adapters. Switch:

Illustration of Nest.js processing of http and websocket platforms:

Summary

Node.js provides the http module to monitor ports and process request responses, but its API is too primitive, so we will include a layer to provide more useful request and response APIs in the express layer, but This layer does not solve the architectural problem. To introduce MVC, IOC and other architectures, another layer needs to be included, using higher-level back-end frameworks such as Egg.js, Midway.js, and Nest.js, among which Nest.js is the best. .

Nest.js has made special designs to integrate with the underlying http platform. It uses the adapter mode to provide a layer of interfaces for the underlying platform to adapt, so that different http platforms can be flexibly switched. .

But it also supports the use of platform-specific APIs. For example, @Req can be used to inject the underlying request object in the controller, and the type parameters of the corresponding platform can also be passed in when creating a container.

Nest.js uses Express by default, but it is not entirely correct to say that Express is used, because you can flexibly switch to others. This is the beauty of the adapter pattern.

For more node-related knowledge, please visit: nodejs tutorial!

The above is the detailed content of Let's talk about how the node framework Nest.js integrates Express with loose coupling!. For more information, please follow other related articles on the PHP Chinese website!