nestjs_NestJS入门

nestjs

介绍 (Introduction)

If you’ve worked on a Node.js application, you may have noticed that it became more difficult to maintain over time. The more you add new features to the application, the larger the codebase becomes.

如果您使用的是Node.js应用程序，则可能已经注意到，随着时间的推移，它变得越来越难以维护。您向应用程序添加新功能的次数越多，代码库就越大。

Nest.js is a server-side Node.js framework for building efficient, reliable and scalable applications. It provides backend applications a modular structure for organizing code into separate modules. It was built to eliminate disorganized codebases.

Nest.js是服务器端Node.js框架，用于构建高效，可靠和可扩展的应用程序。它为后端应用程序提供了一种模块化结构，用于将代码组织到单独的模块中。它旨在消除混乱的代码库。

Heavily inspired by Angular, Nest.js was built with TypeScript and uses Express.js under the hood, which makes it compatible with the majority of Express middleware.

Nest.js受Angular的大力启发，是使用TypeScript构建的，并在后台使用Express.js ，这使其与大多数Express中间件兼容。

In this post, you’ll create a small RESTful API that enables users to fetch, create and delete books in a bookstore.

在本文中，您将创建一个小的RESTful API，使用户能够在书店中获取，创建和删除书。

先决条件 (Prerequisites)

To complete this tutorial, you will need:

要完成本教程，您将需要：

A local development environment for Node.js. Follow How to Install Node.js and Create a Local Development Environment
Node.js的本地开发环境。遵循如何安装Node.js和创建本地开发环境

了解Nest.js的构建基块 (Understanding the Building blocks of Nest.js)

The following are the building blocks used when building Nest.js applications:

以下是构建Nest.js应用程序时使用的构建块：

Controllers
控制器
Providers
提供者
Modules
模组

We’ll start by looking at controllers. Like most web frameworks, controllers in Nest.js are responsible for handling any incoming requests and returning responses to the client side of the application. For example, if you make an API call to a particular endpoint, say /home, the controller will receive this request and based on the available resources, it will returned the appropriate response.

我们将从查看控制器开始。与大多数Web框架一样，Nest.js中的控制器负责处理所有传入请求，并将响应返回给应用程序的客户端。例如，如果您对特定端点(例如/home进行API调用，则控制器将接收到该请求，并基于可用资源，它将返回适当的响应。

Nest.js was structured in a way that the routing mechanism is able to control which controller will be responsible for handling a particular request.

Nest.js的构建方式使路由机制能够控制哪个控制器将负责处理特定请求。

To define a controller in Nest.js, create a TypeScript file and include a decorator @Controller() as shown in the following code snippet:

要在Nest.js中定义一个控制器，请创建一个TypeScript文件并包括一个装饰器@Controller() ，如以下代码片段所示：

users.controller.ts

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

@Controller('users')
export class UsersController {
 @Get()
 findAll() { 
   return 'This will return all the users';
 }
}

The prefix of users within the Controller decorator will prompt the UsersController to handle any /users GET request within an application and return the appropriate response as specified. Other HTTP request handled by the controller includes POST , PUT, DELETE as we will see later in the tutorial.

Controller装饰器中users的前缀将提示UsersController处理应用程序中的任何/users GET请求，并返回指定的适当响应。控制器处理的其他HTTP请求包括POST ， PUT ， DELETE ，我们将在本教程的后面部分看到。

Once a controller is created, it needs to be added to the module definition before Nest.js can easily recognise it. This could be the root ApplicationModule or any other module created within the application. More about this in the module section of this post.

创建控制器后，需要将其添加到模块定义中，Nest.js才能轻松识别它。这可以是根ApplicationModule或在应用程序内创建的任何其他模块。有关更多信息，请参见本文的模块部分。

Now let’s look at providers.

现在让我们看一下provider 。

As mentioned earlier, Nest.js was heavily inspired by Angular and similar to an Angular application, you can create a provider and inject it into controllers or other providers. These providers are also called services, and they’re designed to abstract any form of complexity and logic.

如前所述，Nest.js受Angular的启发很大，类似于Angular应用程序，您可以创建一个提供程序并将其注入到控制器或其他提供程序中。这些提供程序也称为服务，它们旨在抽象化任何形式的复杂性和逻辑。

A service provider in Nest.js is a JavaScript class with a special @Injectable() decorator at the top. For example, you can create a service to fetch users:

Nest.js中的服务提供者是一个JavaScript类，其顶部带有一个特殊的@Injectable()装饰器。例如，您可以创建一个服务来获取用户：

users.service.ts

import { Injectable } from '@nestjs/common';
import { User } from './interfaces/user.interface';

@Injectable()
export class UsersService {
  private readonly users: User[] = [];

  create(user: User) { 
    this.users.push(user);   }

  findAll(): User[] {
    return this.users;
  }
}

The provider created above is a class with two methods create() and findAll(), which can be used to create and return all users respectively. And to easily help with type checking an interface was used to specify the type of elements that should be received by the methods.

上面创建的提供程序是带有两个方法create()和findAll() ，可分别用于创建和返回所有用户。为了方便进行类型检查，使用了一个接口来指定方法应接收的元素的类型。

Finally, let’s look at Modules. Modules let you group related files. They are Typescript files decorated with @Module decorator. This attached decorator provides metadata that Nest makes use of to organize the application structure.

最后，让我们看一下模块。模块使您可以对相关文件进行分组。它们是用@Module装饰器装饰的Typescript文件。该附加的装饰器提供了Nest用来组织应用程序结构的元数据。

Each Nest.js application must have at least one module, usually referred to as the root module. This root module is the top-level module and usually enough for a small application. It is advisable to break a large application into multiple modules as it helps to maintain the structure of the application.

每个Nest.js应用程序必须至少具有一个模块，通常称为root模块 。这个根模块是顶层模块，通常对于一个小型应用程序就足够了。建议将大型应用程序分为多个模块，因为这有助于维护应用程序的结构。

If you have an application that manages a lot of data or functionality about users , you can group the controller, services, and other related files into a single module, like UsersModule:

如果您有一个管理有关用户的大量数据或功能的应用程序，则可以将控制器，服务和其他相关文件分组到一个模块中，例如UsersModule ：

import { Module } from '@nestjs/common';
import { UsersController } from './users.controller.ts';
import { UsersService } from './users.service.ts';

@Module({
  controllers: [UsersController],
  providers: [UsersService]
})

export class UsersModule {}

In this example, we are exported a UsersModule that contains both the UsersController and UsersService. With this in place, we can then proceed to import and use the UsersModule within the root module of the application as shown in the following code snippet:

在这个例子中，我们出口了UsersModule同时包含UsersController和UsersService 。设置好此位置之后，我们可以继续在应用程序的根模块内导入和使用UsersModule ，如以下代码片段所示：

...
import { UsersModule } from './users/users.module';

@Module({
  ...
})

export class AppModule { }

There are a few other important concepts in Nest.js:

Nest.js中还有一些其他重要概念：

DTO: Data transfer object is an object that defines how data will be sent over the network.
DTO ：数据传输对象是一个定义如何通过网络发送数据的对象。
Interfaces: TypeScript interfaces are used for type-checking and defining the types of data that can be passed to a controller or a Nest service.
接口：TypeScript接口用于类型检查和定义可以传递给控制器或Nest服务的数据类型。
Dependency injection: Dependency injection is a design pattern used to increase efficiency and modularity of applications. It is often used by the biggest frameworks to keep code clean and easier to use. Nest.js also makes use of it to basically create coupled components.
依赖注入 ：依赖注入是一种用于提高应用程序效率和模块化的设计模式。最大的框架经常使用它来保持代码的清洁和易于使用。 Nest.js也利用它来基本创建耦合组件。

With this pattern, it is very easy to manage dependencies between building blocks like controllers, providers and modules. The only thing required is to define the dependency for example a UsersService() in the constructor of a controller as shown here:

通过这种模式，管理诸如控制器，提供程序和模块之类的构建块之间的依赖性非常容易。唯一需要做的就是在控制器的构造函数中定义依赖项，例如， UsersService() ，如下所示：

...
@Controller('users')
export class UsersController {
constructor(private readonly usersService: UsersService){}
 ...
}

With some of these concepts briefly covered, you can now proceed to the next section, where you will put all the knowledge gained so far in this post into use as you will learn how to seamlessly build a RESTful API using Nest.js.

在简要介绍了其中一些概念之后，您现在可以进入下一节，在这里您将把到目前为止所获得的所有知识投入使用，同时您还将学习如何使用Nest.js无缝构建RESTful API。

As stated earlier in this post, you will create a sample application that will help you get a good grasp on some of the core concepts of Nest.js.

如本文前面所述，您将创建一个示例应用程序，以帮助您更好地了解Nest.js的一些核心概念。

This application will be specifically for a bookstore. At the end of the post you would have created a micro-service that will enable users to create and add a new book with few descriptions to an existing list of books. This could be from a database, but to ensure simplicity in this post, we won’t really be connecting our application to a database yet. But instead, we will make use of a mock data of books and once a new book is created, we will push and add it to the list.

该应用程序将专门用于书店。在文章的结尾，您将创建一个微服务，该服务将使用户能够创建新书并向其现有书单添加很少的描述。这可能来自数据库，但是为了确保本文的简洁性，我们还没有真正将应用程序连接到数据库。但是，相反，我们将使用书籍的模拟数据，一旦创建了新书籍，我们将其推送并添加到列表中。

第1步-安装Nest.js (Step 1 – Installing Nest.js)

In order to scaffold a new Nest.js application, you will need to globally install the Nest CLI application. It is a command-line tool specifically created to craft a new Nest.js app and provide access to several commands to generate different files and produce a well-structured application.

为了安装新的Nest.js应用程序，您需要全局安装Nest CLI应用程序。这是一个命令行工具，专门用于制作新的Nest.js应用并提供对多个命令的访问权限，以生成不同的文件并生成结构良好的应用。

Apart from using the CLI tool, you can also install a new Nest.js application by cloning the starter project from GitHub using Git, but for the purpose of this tutorial run the following command to install the Nest CLI:

除了使用CLI工具之外，您还可以通过使用Git从GitHub克隆启动项目来安装新的Nest.js应用程序，但出于本教程的目的，请运行以下命令来安装Nest CLI：

npm install -g @nestjs/cli
npm install -g @ nestjs / cli

This will give you access to the nest command for project installation and other project specific commands.

这将使您可以访问nest命令以进行项目安装以及其他项目特定的命令。

Next, run the following command to install a new project named bookstore-nest within your development folder:

接下来，运行以下命令以在开发文件夹中安装一个名为bookstore-nest的新项目：

nest new bookstore-nest
筑巢新书店巢

You will be asked a few questions during the installation, just follow the prompt and respond accordingly. Next, once the installation is complete, switch your working directory into the newly created project:

在安装过程中，系统将询问您一些问题，只需按照提示进行操作，然后做出相应的响应即可。接下来，安装完成后，将工作目录切换到新创建的项目中：

cd bookstore-nest
cd书店巢

Start the application with:

使用以下命令启动应用程序：

npm run start
npm运行开始

You can also run the followingcommand in order to use Nodemon for the project:

您也可以运行以下命令以将Nodemon用于项目：

// start the application using nodemon
npm run start:dev

Navigate to http://localhost:3000 in your browser and you will see the Hello World! message as shown in the following image:

在浏览器中导航到http://localhost:3000 ，您将看到Hello World ！消息，如下图所示：

With the project started, let’s create the root module.

随着项目的开始，让我们创建根模块。

第2步–生成模块 (Step 2 – Generating a Module)

Let’s generate a module for the bookstore. To do this, you will leverage the Nest CLI’s file generator. Run the following command to scaffold a new module for the application:

让我们为书店生成一个模块。为此，您将利用Nest CLI的文件生成器。运行以下命令为应用程序搭建新模块：

nest generate module books
嵌套生成模块书

This creates a new folder named books within the src folder. Within the books folder you will find a books.module.ts file:

这将在src文件夹中创建一个名为books的新文件夹。在books文件夹中，您将找到一个books.module.ts文件：

src/books/books/module.ts

src / books / books / module.ts

import { Module } from '@nestjs/common';
@Module({})
export class BooksModule {}

This was generated by the command and the module has also been added to the app.module.ts which happens to be the root module of the application.

这是由命令生成的，该模块也已添加到app.module.ts ，该碰巧是应用程序的根模块。

Next, you will create routes for the endpoints

接下来，您将为端点创建路由

步骤3 –创建路由和控制器 (Step 3 – Creating Routes and Controllers)

As mentioned earlier, routes exist in controllers, so you need to create controllers that will handle individual endpoints. Again, use Nest CLI to generate your controllers, run the following command:

如前所述，路由存在于控制器中，因此您需要创建将处理各个端点的控制器。再次使用Nest CLI生成控制器，运行以下命令：

nest generate controller books
嵌套生成控制器书籍

This creates a controller inside the books folder. Since we won’t be connecting to the database for now, create a sample mock data for the bookstore. Under the src folder, create a subfolder named mocks and within the newly created folder, create a new TypeScript file named books.mock.ts and add the following code in it:

这将在books文件夹中创建一个控制器。由于我们暂时将不连接数据库，因此请为书店创建一个样本模拟数据。在src文件夹下，创建一个名为mocks的子文件夹，并在新创建的文件夹中，创建一个名为books.mock.ts的新TypeScript文件，并在其中添加以下代码：

src/mocks/books.mock.ts

src / mocks / books.mock.ts

export const BOOKS = [
    { id: 1, title: 'First book', description: "This is the description for the first book", author: 'Olususi Oluyemi' },
    { id: 2, title: 'Second book', description: "This is the description for the second book", author: 'John Barry' },
    { id: 3, title: 'Third book', description: "This is the description for the third book", author: 'Clement Wilfred' },
    { id: 4, title: 'Fourth book', description: "This is the description for the fourth book", author: 'Christian nwamba' },
    { id: 5, title: 'Fifth book', description: "This is the description for the fifth book", author: 'Chris anderson' },
    { id: 6, title: 'Sixth book', description: "This is the description for the sixth book", author: 'Olususi Oluyemi' },
];

Next, you will create a service to hold all the logic for the bookstore.

接下来，您将创建一个服务来保存书店的所有逻辑。

步骤4 –设置服务 (Step 4 – Setting up a Service)

Run the following command to generate a service:

运行以下命令以生成服务：

nest generate service books

This command will create a new file named books.service.ts within ./src/books folder.

此命令将在./src/books文件夹中创建一个名为books.service.ts的新文件。

Next, open the newly created file and paste the following:

接下来，打开新创建的文件并粘贴以下内容：

/src/books/books.service.ts

import { Injectable, HttpException } from '@nestjs/common';
  import { BOOKS } from '../mocks/books.mock';

  @Injectable()
  export class BooksService {
      books = BOOKS;

      getBooks(): Promise<any> {
          return new Promise(resolve => {
              resolve(this.books);
          });
      }
      getBook(bookID): Promise<any> {
          let id = Number(bookID);
          return new Promise(resolve => {
              const book = this.books.find(book => book.id === id);
              if (!book) {
                  throw new HttpException('Book does not exist!', 404);
              }
              resolve(book);
          });
      }
  }

First, you imported the requires modules from Nest.js and also BOOKS from the mock data you created earlier.

首先，您从Nest.js导入了require模块，还从先前创建的模拟数据中导入了BOOKS 。

Next, you created two different methods named getBooks() and getBook() to retrieve the list of books from the mock data and to fetch just one book using the bookID as a parameter.

接下来，创建了两个名为getBooks()和getBook()不同方法，以从模拟数据中检索书籍列表，并使用bookID作为参数仅获取一本书。

Next, add the following method to the /src/books/books.service.ts immediately after the getBook() method:

接下来，在getBook()方法之后立即将以下方法添加到/src/books/books.service.ts ：

src/books/books.service.ts

src / books / books.service.ts

import { Injectable, HttpException } from '@nestjs/common';
import { BOOKS } from '../mocks/books.mock';
@Injectable()
export class BooksService {
    books = BOOKS;
    ...
    addBook(book): Promise<any> {
        return new Promise(resolve => {
            this.books.push(book);
            resolve(this.books);
        });
    }
}

The method above will be used to push a new book to the existing list

上面的方法将用于将新书推送到现有列表中

Finally, add the last method to delete a particular book using the bookID as a parameter:

最后，添加最后一种方法，以bookID作为参数删除特定的书：

src/books/books.service.ts

src / books / books.service.ts

import { Injectable, HttpException } from '@nestjs/common';
import { BOOKS } from '../mocks/books.mock';
@Injectable()
export class BooksService {
    books = BOOKS;
    ...
    deleteBook(bookID): Promise<any> {
        let id = Number(bookID);
        return new Promise(resolve => {
            let index = this.books.findIndex(book => book.id === id);
            if (index === -1) {
                throw new HttpException('Book does not exist!', 404);
            }
            this.books.splice(1, index);
            resolve(this.books);
        });
    }
}

步骤5 –将服务注入控制器 (Step 5 – Injecting the Service into the Controller)

Here, you will use dependency injection design pattern to pass the BooksService into the BooksController through a constructor. Open the BooksController created earlier and paste the following code in it:

在这里，您将使用依赖项注入设计模式将BooksController通过构造函数传递到BooksService 。打开BooksController创建的BooksController ，并将以下代码粘贴到其中：

src/books/books.controller.ts

src / books / books.controller.ts

import { Controller, Get, Param, Post, Body, Query, Delete } from '@nestjs/common';
import { BooksService } from './books.service';
import { CreateBookDTO } from './dto/create-book.dto';

@Controller('books')
export class BooksController {
    constructor(private booksService: BooksService) { }

    @Get()
    async getBooks() {
        const books = await this.booksService.getBooks();
        return books;
    }

    @Get(':bookID')
    async getBook(@Param('bookID') bookID) {
        const book = await this.booksService.getBook(bookID);
        return book;
    }

    @Post()
    async addBook(@Body() createBookDTO: CreateBookDTO) {
        const book = await this.booksService.addBook(createBookDTO);
        return book;
    }

    @Delete()
    async deleteBook(@Query() query) {
        const books = await this.booksService.deleteBook(query.bookID);
        return books;
    }
}

First, the important modules were imported from @nestjs/common and you also import both the BooksService and CreateBookDTO respectively. CreateBookDTO is a data transfer object, a TypeScript class created for type-checking and to define the structures of what an object looks like when creating a new book. We will create this DTO in a bit.

首先，重要模块是从@nestjs/common导入的，您还分别导入了BooksService和CreateBookDTO 。 CreateBookDTO是一个数据传输对象，它是一个TypeScript类，用于类型检查并定义对象在创建新书时的外观结构。我们将稍后创建此DTO。

Next, you used constructor to inject the BooksService into the controller and created four different methods which are:

接下来，您使用constructor将BooksService注入到控制器中，并创建了四种不同的方法：

getBooks(): Used to fetch the list of all books. It has @Get() decorator attached to it. This helps to map any GET request sent to /books to this controller.
getBooks() ：用于获取所有书籍的列表。它具有@Get()装饰器。这有助于将发送到/ books的任何GET请求映射到此控制器。
getBook(): Used to retrieve the details of a particular book by passing the bookID as a parameter.
getBook() ：用于通过将bookID作为参数来检索特定书籍的详细信息。
addBook(): Used to create and post a new book to the existing book list. And because we are not persisting into the database, the newly added book will only be held in memory.
addBook() ：用于创建新书籍并将其发布到现有书籍列表中。并且由于我们没有持久化到数据库中，因此新添加的书将仅保存在内存中。
deleteBook(): Used to delete a book by passing the bookID as a query parameter.
deleteBook() ：用于通过传递bookID作为查询参数来删除一本书。

Each of the methods has a special decorator attached to it, which makes it very easy to route each HTTP request to a specific method within the controller.

每个方法都附加有一个特殊的装饰器，这使得将每个HTTP请求路由到控制器内的特定方法非常容易。

步骤6 –定义DTO (Step 6 – Defining The DTO)

In the previous section, you made use of a data transfer object called CreateBookDTO. To create it, navigate to the ./src/books folder and create a new subfolder name dto. Next, within the newly created folder, create another file and call it create-book.dto.ts and paste the following in it:

在上一节中，您使用了一个名为CreateBookDTO的数据传输对象。要创建它，请导航到./src/books文件夹并创建一个新的子文件夹名称dto 。接下来，在新创建的文件夹中，创建另一个文件，并将其命名为create-book.dto.ts并将以下内容粘贴到其中：

src/books/dto/create-book.dto.ts

src / books / dto / create-book.dto.ts

export class CreateBookDTO {
    readonly id: number;
    readonly title: string;
    readonly description: string;
    readonly author: string;
}

You are almost done with the application. Navigate back to the ./src/books/books.module.ts file you created earlier and update it with the following code:

您几乎完成了该应用程序。导航回到您先前创建的./src/books/books.module.ts文件，并使用以下代码对其进行更新：

src/books/books.module.ts

src / books / books.module.ts

import { Module } from '@nestjs/common';
import { BooksController } from './books.controller';
import { BooksService } from './books.service';
@Module({
  controllers: [BooksController],
  providers: [BooksService]
})
export class BooksModule {}

Start the application again if it is not running at the moment with:

如果当前没有运行，请再次启动该应用程序：

npm run start
npm运行开始

Then use postman to test the API

然后使用邮递员测试API

Create some new books:

创建一些新书：

Get a book using an ID:

使用ID获取书籍：

And delete a book:

并删除一本书：

结论 (Conclusion)

In this tutorial you took a quick look at the fundamentals and basic building blocks of Nest.js and then built a RESTful API.

在本教程中，您快速了解了Nest.js的基础知识和基本构建块，然后构建了RESTful API。

You will find the complete source code of this tutorial here on GitHub.

您可以在GitHub上找到本教程的完整源代码。

翻译自: https://www.digitalocean.com/community/tutorials/getting-started-with-nestjs

nestjs