首页手记 Nest学习：新手入门全面指南

Nest学习：新手入门全面指南

标签：

React native Kotlin

概述

Nest框架是一个基于Angular和Node.js的高效、模块化和可扩展的JavaScript框架，利用了TypeScript语言的强类型特性。它通过装饰器和依赖注入简化了复杂的业务逻辑实现，nest学习者可以通过本文了解其特点、安装方法和基本使用。文章还详细介绍了如何创建和测试简单的API接口，以及如何使用GraphQL增强API能力。

Nest框架简介

什么是Nest框架

Nest框架是一个基于Angular和Node.js的高效、模块化和可扩展的JavaScript框架。它利用了TypeScript语言的强类型特性，为开发者提供了更好的代码结构和类型检查。Nest框架的设计理念是遵循面向对象编程的原则，通过使用装饰器和依赖注入来简化复杂的业务逻辑实现。

Nest框架的特点和优势

可扩展性：Nest框架的模块化设计使得你可以轻松地添加新的功能模块，而无需对现有代码进行大规模修改。
可维护性：清晰的模块划分和细致的代码结构使得代码易于理解和维护。
高效性：通过装饰器和依赖注入，Nest框架能够提供高效且简洁的代码实现。
可测试性：Nest框架支持单元测试和集成测试，使得软件的测试变得更加容易。
类型安全：利用TypeScript的强类型特性，Nest框架能够提供更好的类型检查，减少运行时错误。

安装Nest框架

安装Nest框架的第一步是确保你已经安装了Node.js和npm。接下来，使用npm全局安装Nest CLI，这是一个命令行工具，用于生成项目和管理项目文件。

npm install -g @nestjs/cli

安装完成后，可以使用nest new命令来创建一个新的Nest项目：

nest new my-nest-app

上述命令会生成一个基础的Nest项目结构。你可以使用如下命令来启动项目：

npm run start

快速上手Nest

创建第一个Nest项目

创建一个Nest项目的基本步骤如下：

安装Nest CLI。
使用nest new命令创建一个新的Nest项目。
启动项目并访问默认的API端点。

如上所述，安装Nest CLI后，可以使用以下命令创建一个新的Nest项目：

nest new my-nest-app

创建项目后，进入项目目录并启动项目：

cd my-nest-app
npm run start

启动项目后，访问http://localhost:3000/api，可以看到默认的欢迎信息。

项目结构解析

一个Nest项目通常包含以下主要文件和目录：

src/：项目的源代码目录，包含模块、服务、控制器等。
app.module.ts：应用的主模块文件，定义了应用的基本结构。
main.ts：应用的启动文件，配置了应用的入口点。
nest-cli.json：Nest CLI配置文件。
package.json：项目的npm配置文件。
README.md：项目的说明文档。

`app.module.ts` 示例代码

app.module.ts是项目的主模块文件，定义了应用的基本结构：

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';

@Module({
  imports: [],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

`main.ts` 示例代码

main.ts是应用的启动文件，配置了应用的入口点：

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

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

实现简单的API接口

创建一个简单的API接口通常涉及以下几个步骤：

创建控制器。
创建服务。
在控制器中使用服务。

创建控制器

控制器负责处理HTTP请求。创建一个简单的控制器：

nest generate controller user

生成的user.controller.ts文件如下：

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

@Controller('users')
export class UserController {
  @Get()
  findAll(): string {
    return 'All users';
  }
}

创建服务

服务是业务逻辑实现的载体。创建一个简单的服务：

nest generate service user

生成的user.service.ts文件如下：

import { Injectable } from '@nestjs/common';

@Injectable()
export class UserService {
  getUsers(): string {
    return 'All users';
  }
}

在控制器中使用服务

修改控制器文件，使用服务来处理HTTP请求：

import { Controller, Get } from '@nestjs/common';
import { UserService } from '../user.service';

@Controller('users')
export class UserController {
  constructor(private readonly userService: UserService) {}

  @Get()
  findAll(): string {
    return this.userService.getUsers();
  }
}

现在启动项目并访问http://localhost:3000/users，可以看到返回的结果为All users。

提供者（Providers）

提供者是Nest框架中的服务或控制器。提供者使用@Injectable装饰器标记，并通过@Module装饰器的providers数组来注册。提供者可以依赖注入其他提供者，从而实现模块化和解耦的代码结构。

示例代码

定义一个简单的提供者：

import { Injectable } from '@nestjs/common';

@Injectable()
export class UserService {
  getUsers(): string {
    return 'All users';
  }
}

基础概念详解

控制器（Controllers）

控制器是Nest框架中处理HTTP请求的核心组件。每个控制器都包含一个或多个装饰器，用于定义HTTP方法（如@Get）和路由路径。

示例代码

创建一个简单的控制器来处理HTTP GET请求：

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

@Controller('users')
export class UserController {
  @Get()
  findAll(): string {
    return 'All users';
  }
}

服务（Services）

服务是业务逻辑的实现载体。在Nest框架中，服务通常使用@Injectable装饰器来标记。服务的作用是封装和组织应用的业务逻辑，使其更易于测试和维护。

示例代码

创建一个简单的服务来返回所有用户：

import { Injectable } from '@nestjs/common';

@Injectable()
export class UserService {
  getUsers(): string {
    return 'All users';
  }
}

模块（Modules）

模块是Nest框架中的核心概念之一。一个模块定义了一组控制器、服务和其他模块之间的依赖关系。模块通过@Module装饰器来定义。

示例代码

定义一个简单的模块，包含一个控制器和一个服务：

import { Module } from '@nestjs/common';
import { UserController } from './user.controller';
import { UserService } from './user.service';

@Module({
  controllers: [UserController],
  providers: [UserService],
})
export class UserModule {}

实践案例：构建用户管理系统

用户注册和登录功能

在本章节中，我们将实现一个简单的用户注册和登录功能。首先，我们将创建一个注册接口，接收用户信息并将其存储在内存中。然后，我们将实现一个登录接口，验证用户信息并返回一个token。

创建用户模块

首先，我们需要创建一个用户模块来管理用户相关的服务和控制器。

nest generate module user

生成的user.module.ts文件如下：

import { Module } from '@nestjs/common';
import { UserService } from './user.service';
import { UserController } from './user.controller';

@Module({
  providers: [UserService],
  controllers: [UserController],
})
export class UserModule {}

创建用户服务

接下来，我们需要创建一个用户服务，用于处理用户注册和登录逻辑。

nest generate service user

生成的user.service.ts文件如下：

import { Injectable } from '@nestjs/common';

@Injectable()
export class UserService {
  private users = new Map<string, { username: string; password: string }>();

  register(username: string, password: string): boolean {
    if (this.users.has(username)) {
      return false;
    }
    this.users.set(username, { username, password });
    return true;
  }

  login(username: string, password: string): string | null {
    const user = this.users.get(username);
    if (!user) {
      return null;
    }
    if (user.password === password) {
      return 'token';
    }
    return null;
  }
}

创建用户控制器

现在，我们需要创建一个用户控制器来处理HTTP请求。

nest generate controller user

生成的user.controller.ts文件如下：

import { Controller, Post, Body, Get } from '@nestjs/common';
import { UserService } from '../user.service';

@Controller('users')
export class UserController {
  constructor(private readonly userService: UserService) {}

  @Post('register')
  register(@Body() body: { username: string; password: string }): string {
    const { username, password } = body;
    if (this.userService.register(username, password)) {
      return 'User registered successfully';
    }
    return 'Username already exists';
  }

  @Post('login')
  login(@Body() body: { username: string; password: string }): string | null {
    return this.userService.login(body.username, body.password);
  }
}

测试注册和登录接口

启动项目并使用Postman测试注册和登录接口。

注册接口：http://localhost:3000/users/register
登录接口：http://localhost:3000/users/login

用户信息管理

接下来，我们将实现一个简单的用户信息管理功能，包括获取用户列表和删除用户。

更新用户服务

首先，我们需要更新用户服务，添加获取用户列表和删除用户的方法。

import { Injectable } from '@nestjs/common';

@Injectable()
export class UserService {
  private users = new Map<string, { username: string; password: string }>();

  register(username: string, password: string): boolean {
    if (this.users.has(username)) {
      return false;
    }
    this.users.set(username, { username, password });
    return true;
  }

  login(username: string, password: string): string | null {
    const user = this.users.get(username);
    if (!user) {
      return null;
    }
    if (user.password === password) {
      return 'token';
    }
    return null;
  }

  getUsers(): { username: string }[] {
    return Array.from(this.users.keys()).map((username) => ({ username }));
  }

  deleteUser(username: string): boolean {
    if (!this.users.has(username)) {
      return false;
    }
    this.users.delete(username);
    return true;
  }
}

更新用户控制器

接下来，我们需要更新用户控制器，添加获取用户列表和删除用户的方法。

import { Controller, Post, Body, Get, Param } from '@nestjs/common';
import { UserService } from '../user.service';

@Controller('users')
export class UserController {
  constructor(private readonly userService: UserService) {}

  @Post('register')
  register(@Body() body: { username: string; password: string }): string {
    const { username, password } = body;
    if (this.userService.register(username, password)) {
      return 'User registered successfully';
    }
    return 'Username already exists';
  }

  @Post('login')
  login(@Body() body: { username: string; password: string }): string | null {
    return this.userService.login(body.username, body.password);
  }

  @Get()
  getUsers(): { username: string }[] {
    return this.userService.getUsers();
  }

  @Delete(':username')
  deleteUser(@Param('username') username: string): string {
    if (this.userService.deleteUser(username)) {
      return 'User deleted successfully';
    }
    return 'User not found';
  }
}

测试用户信息管理接口

启动项目并使用Postman测试获取用户列表和删除用户接口。

获取用户列表接口：http://localhost:3000/users
删除用户接口：http://localhost:3000/users/{username}

使用GraphQL增强API能力

接下来，我们将使用GraphQL增强API能力，实现一个简单的GraphQL接口来查询和操作用户信息。

安装Apollo库

首先，我们需要安装Apollo库来支持GraphQL。

npm install @nestjs/graphql @nestjs/apollo graphql

更新用户服务

接下来，我们需要更新用户服务，添加GraphQL查询和操作的方法。

import { Injectable } from '@nestjs/common';

@Injectable()
export class UserService {
  private users = new Map<string, { username: string; password: string }>();

  register(username: string, password: string): boolean {
    if (this.users.has(username)) {
      return false;
    }
    this.users.set(username, { username, password });
    return true;
  }

  login(username: string, password: string): string | null {
    const user = this.users.get(username);
    if (!user) {
      return null;
    }
    if (user.password === password) {
      return 'token';
    }
    return null;
  }

  getUsers(): { username: string }[] {
    return Array.from(this.users.keys()).map((username) => ({ username }));
  }

  deleteUser(username: string): boolean {
    if (!this.users.has(username)) {
      return false;
    }
    this.users.delete(username);
    return true;
  }

  getUser(username: string): { username: string } | null {
    if (this.users.has(username)) {
      return { username };
    }
    return null;
  }
}

创建GraphQL模块

接下来，我们需要创建一个GraphQL模块来定义GraphQL类型和解析器。

nest generate module graphql

生成的graphql.module.ts文件如下：

import { Module } from '@nestjs/common';
import { GraphQLModule } from '@nestjs/graphql';
import { UserResolver } from './user.resolver';
import { UserService } from '../user.service';

@Module({
  imports: [
    GraphQLModule.forRoot({
      autoSchemaFile: true,
    }),
  ],
  providers: [UserResolver],
})
export class GraphQLModule {}

创建GraphQL解析器

接下来，我们需要创建一个GraphQL解析器来实现GraphQL查询和操作。

nest generate resolver user

生成的user.resolver.ts文件如下：

import { Resolver, Query, Args } from '@nestjs/graphql';
import { UserService } from '../user.service';

@Resolver()
export class UserResolver {
  constructor(private readonly userService: UserService) {}

  @Query(() => String)
  register(@Args('username') username: string, @Args('password') password: string): string {
    if (this.userService.register(username, password)) {
      return 'User registered successfully';
    }
    return 'Username already exists';
  }

  @Query(() => String)
  login(@Args('username') username: string, @Args('password') password: string): string | null {
    return this.userService.login(username, password);
  }

  @Query(() => [String])
  getUsers(): { username: string }[] {
    return this.userService.getUsers();
  }

  @Query(() => String)
  getUser(@Args('username') username: string): { username: string } | null {
    return this.userService.getUser(username);
  }

  @Mutation(() => String)
  deleteUser(@Args('username') username: string): string {
    if (this.userService.deleteUser(username)) {
      return 'User deleted successfully';
    }
    return 'User not found';
  }
}

测试GraphQL接口

启动项目并使用GraphQL Playground测试GraphQL接口。

注册用户：mutation { register(username: "test", password: "test") }
登录用户：mutation { login(username: "test", password: "test") }
获取用户列表：query { getUsers }
获取用户信息：query { getUser(username: "test") }
删除用户：mutation { deleteUser(username: "test") }

测试与调试

单元测试与集成测试

Nest框架通过整合Jest和Supertest库提供了强大的单元测试和集成测试支持。下面是一个简单的测试示例，用于验证用户注册和登录功能是否正常工作。

单元测试示例

创建一个单元测试文件，用于测试用户服务中的注册和登录逻辑。

import { Test, TestingModule } from '@nestjs/testing';
import { UserService } from './user.service';

describe('UserService', () => {
  let service: UserService;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [UserService],
    }).compile();

    service = module.get<UserService>(UserService);
  });

  it('should register a user', () => {
    const result = service.register('test', 'password');
    expect(result).toBe(true);
  });

  it('should not register a user twice', () => {
    service.register('test', 'password');
    const result = service.register('test', 'password');
    expect(result).toBe(false);
  });

  it('should login a user', () => {
    service.register('test', 'password');
    const token = service.login('test', 'password');
    expect(token).toBe('token');
  });

  it('should not login a user with wrong password', () => {
    service.register('test', 'password');
    const token = service.login('test', 'wrongPassword');
    expect(token).toBeNull();
  });
});

集成测试示例

创建一个集成测试文件，用于测试用户控制器中的注册和登录端点。

import { Test, TestingModule } from '@nestjs/testing';
import { INestApplication } from '@nestjs/common';
import { UserController } from './user.controller';
import { UserService } from './user.service';
import { NestExpressApplication } from '@nestjs/platform-express';
import * as request from 'supertest';

describe('UserController', () => {
  let app: INestApplication;
  let userService: UserService;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      controllers: [UserController],
      providers: [UserService],
    })
      .overrideProvider(UserService)
      .useClass(MockUserService)
      .compile();

    app = module.createNestApplication<NestExpressApplication>();
    userService = module.get<UserService>(UserService);
    await app.init();
  });

  afterAll(async () => {
    await app.close();
  });

  it('should register a user', () => {
    return request(app.getHttpServer())
      .post('/users/register')
      .send({ username: 'test', password: 'password' })
      .expect(200)
      .expect('User registered successfully');
  });

  it('should not register a user twice', () => {
    return request(app.getHttpServer())
      .post('/users/register')
      .send({ username: 'test', password: 'password' })
      .expect(200)
      .expect('User registered successfully')
      .then(() => {
        return request(app.getHttpServer())
          .post('/users/register')
          .send({ username: 'test', password: 'password' })
          .expect(200)
          .expect('Username already exists');
      });
  });

  it('should login a user', () => {
    return request(app.getHttpServer())
      .post('/users/login')
      .send({ username: 'test', password: 'password' })
      .expect(200)
      .expect('token');
  });

  it('should not login a user with wrong password', () => {
    return request(app.getHttpServer())
      .post('/users/login')
      .send({ username: 'test', password: 'wrongPassword' })
      .expect(401);
  });
});

class MockUserService {
  register(username: string, password: string): boolean {
    return true;
  }

  login(username: string, password: string): string | null {
    if (username === 'test' && password === 'password') {
      return 'token';
    }
    return null;
  }
}

使用Docker进行环境隔离

Docker是一个开源的容器化平台，可以用来创建和运行隔离的环境。下面是如何使用Docker进行环境隔离的示例。

创建Dockerfile

在项目的根目录下创建一个Dockerfile，用于构建Docker镜像。

cat > Dockerfile <<EOF
FROM node:14

WORKDIR /app

COPY package.json package-lock.json ./

RUN npm install

COPY . .

EXPOSE 3000

CMD ["npm", "run", "start"]
EOF

构建Docker镜像

使用以下命令构建Docker镜像：

docker build -t my-nest-app .

运行Docker容器

使用以下命令运行Docker容器：

docker run -p 3000:3000 my-nest-app

使用Docker Compose部署到云环境

创建一个docker-compose.yml文件，用于管理Docker容器。

version: '3'
services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - PORT=3000
      - DATABASE_URL=mongodb://localhost:27017/mydatabase

使用以下命令启动Docker容器：

docker-compose up

错误处理与调试技巧

Nest框架提供了强大的错误处理功能，可以通过全局异常过滤器来捕获和处理异常。

全局异常过滤器示例

创建一个全局异常过滤器，用于捕获和处理异常。

import { ExceptionFilter, Catch, ArgumentsHost, HttpException, HttpStatus } from '@nestjs/common';

@Catch()
export class GlobalExceptionFilter implements ExceptionFilter {
  catch(exception: any, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse();
    const request = ctx.getRequest();
    const status = exception instanceof HttpException ? exception.getStatus() : HttpStatus.INTERNAL_SERVER_ERROR;

    response.status = status;
    response.json({
      statusCode: status,
      timestamp: new Date().toISOString(),
      path: request.url,
      message: exception.message,
    });
  }
}

注册全局异常过滤器

在app.module.ts文件中注册全局异常过滤器。

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { GlobalExceptionFilter } from './global.filter';

@Module({
  imports: [],
  controllers: [AppController],
  providers: [AppService, { provide: APP_FILTER, useClass: GlobalExceptionFilter }],
})
export class AppModule {}

部署与维护

构建项目和环境变量管理

在部署Nest应用之前，你需要构建项目并管理环境变量。

构建项目

使用以下命令构建项目：

npm run build

管理环境变量

创建一个.env文件来管理环境变量。

cat > .env <<EOF
PORT=3000
DATABASE_URL=mongodb://localhost:27017/mydatabase
EOF

使用环境变量

在main.ts文件中使用环境变量。

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import * as dotenv from 'dotenv';

dotenv.config();

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(process.env.PORT);
}
bootstrap();

部署到云环境

将Nest应用部署到云环境通常涉及以下几个步骤：

使用Docker容器化应用。
使用Docker Compose或Kubernetes管理应用。
使用云提供商的平台和服务部署应用。

使用Docker部署到云环境

使用Docker容器化应用，并使用Docker Compose或Kubernetes管理应用。

使用Docker Compose部署到云环境

创建一个docker-compose.yml文件，用于管理Docker容器。

version: '3'
services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - PORT=3000
      - DATABASE_URL=mongodb://localhost:27017/mydatabase

使用以下命令启动Docker容器：

docker-compose up

使用Kubernetes部署到云环境

创建一个deployment.yaml和service.yaml文件，用于管理Kubernetes资源。

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-nest-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-nest-app
  template:
    metadata:
      labels:
        app: my-nest-app
    spec:
      containers:
      - name: my-nest-app
        image: my-nest-app
        ports:
        - containerPort: 3000
        env:
        - name: PORT
          value: "3000"
        - name: DATABASE_URL
          value: "mongodb://localhost:27017/mydatabase"

# service.yaml
apiVersion: v1
kind: Service
metadata:
  name: my-nest-app
spec:
  selector:
    app: my-nest-app
  ports:
  - protocol: TCP
    port: 80
    targetPort: 3000

使用以下命令部署应用：

kubectl apply -f deployment.yaml
kubectl apply -f service.yaml

日志管理和监控

日志管理和监控是应用部署后的重要环节，可以使用多种工具来实现。下面是如何使用Prometheus和Grafana进行监控和日志管理的示例。

使用Prometheus和Grafana进行监控

创建一个prometheus.yml文件，用于配置Prometheus的监控。

global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'nest-app'
    static_configs:
      - targets: ['localhost:3000']

创建一个grafana.json文件，用于配置Grafana的监控。

{
  "dashboard": {
    "id": -1,
    "title": "Nest App",
    "panels": [
      {
        "type": "graph",
        "title": "Requests per second",
        "yAxes": [
          {
            "label": "Requests/second",
            "format": "short"
          }
        ],
        "lines": true,
        "fill": 1,
        "nullPointMode": "connected",
        "xaxis": {
          "mode": "time"
        },
        "yaxis": {
          "align": false,
          "alignLevel": null
        },
        "targets": [
          {
            "expr": "rate(nest_app_requests_total[5m])",
            "interval": "",
            "legendFormat": "Requests",
            "refId": "A"
          }
        ]
      }
    ]
  }
}

使用Prometheus和Grafana进行监控的具体步骤可以参考Prometheus和Grafana的官方文档。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

翻翻过去那场雪

手记
篇

粉丝

7

获赞与收藏

25

关注作者，订阅最新文章

相关文章推荐

给学习 OpenStack 架构的新手入门指南

JavaScript：从新手到忍者修炼入门指南

React JS和React-Native新手学习指南

Java工程师学习指南（入门篇）

Java工程师学习指南（入门篇）

阅读免费教程

Kotlin 教程

36个小节 15445 233

后端通用面试教程

41个小节 30273 342

网络编程入门教程

20个小节 12461 235

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

Nest学习：新手入门全面指南

app.module.ts 示例代码

main.ts 示例代码

创建控制器

创建服务

在控制器中使用服务

示例代码

示例代码

示例代码

示例代码

创建用户模块

创建用户服务

创建用户控制器

测试注册和登录接口

更新用户服务

更新用户控制器

测试用户信息管理接口

安装Apollo库

更新用户服务

创建GraphQL模块

创建GraphQL解析器

测试GraphQL接口

单元测试示例

集成测试示例

创建Dockerfile

构建Docker镜像

运行Docker容器

全局异常过滤器示例

注册全局异常过滤器

构建项目

管理环境变量

使用环境变量

使用Docker部署到云环境

使用Docker Compose部署到云环境

使用Kubernetes部署到云环境

使用Prometheus和Grafana进行监控

相关文章推荐

阅读免费教程

`app.module.ts` 示例代码

`main.ts` 示例代码