前言

nestjs的课程真的没有，不管是B站还是Y站，都寥寥无几，英文课程我是真的听不懂。这个教程已经是很好的教程了，最起码能够让我入门，把关键点都讲到了。

当然课程学习很是需要精力，特别是一些概念、操作步骤等等，需要我将这个笔记尽可能的完善，需要时间。要坚持下去，因为nestjs框架的用法，和很多很流行的框架是一致的，搞清楚一项就能够搞清楚别的框架了。

1、介绍nestjs

Nestjs 是一个用于构建高效可扩展的一个基于Node js 服务端应用程序开发框架，并且完全支持 typeScript。结合了 AOP 面向切面的编程方式。

什么是AOP？

https://zhuanlan.zhihu.com/p/161705262

https://zhuanlan.zhihu.com/p/657849682

看了曾探的设计模式一书，里面介绍了使用高阶函数来实现AOP的功能，我想可以作为理解AOP的入门。

​x
1
// 通过扩展 Function.prototype 来实现 AOP
2
​
3
Function.prototype.before = function (beforeFn) {
4
 var _self = this; // 保存原函数的引用
5
 return function () {
6
     // 返回包含了原函数和新函数的“代理”函数
7
     beforeFn.apply(this, arguments); // 执行新函数，修正this
8
     return _self.apply(this, arguments); // 执行原函数
9
 };
10
};
11
​
12
Function.prototype.after = function (afterFn) {
13
 var _self = this;
14
 return function () {
15
     var ret = _self.apply(this, arguments);
16
     afterFn.apply(this, arguments);
17
     return ret;
18
 };
19
};
20
​
21
var func = function () {
22
 console.log(2);
23
};
24
​
25
func = func
26
 .before(function () {
27
 console.log(1);
28
})
29
 .after(function () {
30
 console.log(3);
31
});
32
​
33
func();

执行结果：

这样，就能够让123按照顺序输出。

但是上面的after函数里面，我有一个疑问，就是var ret = _self.apply(this, arguments)，返回的ret在after.apply(this, arguments)后面，那么函数会在after之后执行吗？而要求的是函数在after之前执行。

可以输出ret看一下，是什么？

ret是undefined，那么说明这个赋值操作是没有效果的，将after里面改为这样，看执行效果：

xxxxxxxxxx
7
1
Function.prototype.after = function (afterFn) {
2
var _self = this;
3
return function () {
4
 _self.apply(this, arguments);
5
 afterFn.apply(this, arguments);
6
};
7
};

没有任何问题。

我还有一个疑问，就是before和after里面都有这段代码：_self.apply(this, arguments);，那么原函数会执行两次吗？但是输出结果明确告诉我们，原函数不会执行两次，那么里面到底是怎么执行的呢？

将after里面的这段代码_self.apply(this, arguments);注释后执行：

只输出了3，输出此时的_self看一下：

说明after里面的_self其实已经有before函数在里面了，实际上执行的是上面这个函数，所以原函数不会执行两次。

 

联想到nestjs，比如说日志记录、性能监控、事务管理、缓存管理、权限控制、异常处理等功能，都有AOP的思想在里面，当然nestjs里面实现的逻辑很复杂，但知道最简单的实现方式，能够帮助我更好的理解。因为我总是会怀疑，这能够实现吗？

nestjs 还是一个spring MVC 风格的框架，其中有依赖注入，IOC，控制反转，都是借鉴了Angular。

nestjs 的底层代码运用了 express 和 Fastify。在他们的基础上提供了一定程度的抽象，同时也将其 API 直接暴露给开发人员。这样可以轻松使用每个平台的无数第三方模块。

nestjs内置框架express，默认框架express。能够快速构建服务端应用程序，且学习成本非常低，容易上手。

express官网： https://www.expressjs.com.cn/

nestjs另一个内置框架：Fastify。

Fastify特性：

• 高性能： 据我们所知，Fastify 是这一领域中最快的 web 框架之一，另外，取决于代码的复杂性，Fastify 最多可以处理每秒 3 万次的请求。
• 可扩展： Fastify 通过其提供的钩子（hook）、插件和装饰器（decorator）提供完整的可扩展性。
• 基于 Schema： 即使这不是强制性的，我们仍建议使用 JSON Schema 来做路由（route）验证及输出内容的序列化，Fastify 在内部将 schema 编译为高效的函数并执行。
• 日志： 日志是非常重要且代价高昂的。我们选择了最好的日志记录程序来尽量消除这一成本，这就是 Pino!
• 对开发人员友好： 框架的使用很友好，帮助开发人员处理日常工作，并且不牺牲性能和安全性。
• 支持 TypeScript： 我们努力维护一个 TypeScript 类型声明文件，以便支持不断成长的 TypeScript 社区。

2、IOC控制反转 DI依赖注入

在学习 nestjs 之前需要先了解其设计模式。

IOC

Inversion of Control字面意思是控制反转，具体定义是高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象。

DI

依赖注入（Dependency Injection）其实和IoC是同根生，这两个原本就是一个东西，只不过由于控制反转概念比较含糊（可能只是理解为容器控制对象这一个层面，很难让人想到谁来维护对象关系），所以2004年大师级人物Martin Fowler又给出了一个新的名字：“依赖注入”。 类A依赖类B的常规表现是在类A中使用类B的instance（实例）。

为什么需要IOC和DI？想一想团队合作的时候，合并代码的时候，如果不想到处都是代码冲突，那么最好是公共模块和业务模块分开，并且业务模块之间的耦合尽量小，这样合作起来才顺利。

老师在视频讲解里面的例子是这样的：

xxxxxxxxxx
21
1
class A {
2
   name: string;
3
   constructor() {
4
        this.name = "小满";
5
   }
6
}
7
​
8
// 在B和C类中，想用到A类的name属性，于是可以像下面这样写，没有问题
9
class B {
10
   a: any;
11
   constructor() {
12
        this.a = new A().name;
13
   }
14
}
15
​
16
class C {
17
   b: any;
18
   constructor() {
19
        this.b = new A().name;
20
   }
21
}

但如果A类中的name是传递过来的，不是固定值，会怎么样呢？

可以看到，B类和C类里面的代码都需要进行修改，在实例化A类的时候，要显式的传值。那么此时A和B、C类之间的关系就是强耦合的。

解决办法就是使用依赖注入：

xxxxxxxxxx
49
1
// 定义两个普通的类，A和C
2
class A {
3
   name: string;
4
   constructor(name: string) {
5
        this.name = name;
6
   }
7
}
8
​
9
class C {
10
   age: number;
11
   constructor(age: number) {
12
        this.age = age;
13
   }
14
}
15
​
16
// 创建一个容器来收集引用
17
class Container {
18
   module: any;
19
   constructor() {
20
        this.module = {};
21
   }
22
​
23
   // 定义一个注入方法，这样就可以收集到类的引用了
24
   provide(key: string, module: any) {
25
        // 注意两个module是不同的，一个是类的属性，一个是传递过来的引用实例
26
        this.module[key] = module;
27
   }
28
​
29
   // 定义一个get方法，用于取出类的引用
30
   get(key: string) {
31
        return this.module[key];
32
   }
33
}
34
​
35
// 实例化容器
36
const module = new Container();
37
// 然后将两个类注入进去
38
module.provide("a", new A("小满啪啪啪"));
39
module.provide("c", new C(18));
40
​
41
// 上面的步骤，注入完成之后，就可以用依赖注入的方式来引用这些类的实例
42
class B {
43
   a: any;
44
   c: any;
45
   constructor(module: Container) {
46
        this.a = module.get("a");
47
        this.c = module.get("c");
48
   }
49
}

老师的原话：在引入IOC容器container之后，B和A的代码逻辑已经解耦。可以单独扩展其他功能，也可以方便地加入其他模块（比如C）。所以在面对复杂的后端业务逻辑中，引入IoC可以降低组件之间的耦合度，实现系统各层之间的解耦，减少维护和理解成本。

从上面的代码可以看到，如果B类中想用到A类或C类的实例，只需要从容器中取出来使用即可，而不必在B类中实例化一个A类或C类的实例，这样B类与A类、C类就解耦了。

那Container、实例化Container、将各种类注入Container实例，这些步骤在nestjs里面是谁在操作呢？我好像写的最多的就是各种各样的类，从来没有进行过这些操作啊？

这些是nestjs框架在操作，它帮助我们完成了这些步骤，我们只需要做的就是在B类里面引入实例化对象来使用即可。这部分在xxx.controller.ts、xxx.service.ts里面的constructor里面看到的最多。

案例未使用控制反转和依赖注入之前的代码

xxxxxxxxxx
19
1
class A {
2
    name: string
3
    constructor(name: string) {
4
        this.name = name
5
    }
6
}
7
 
8
class B {
9
    age:number
10
    entity:A
11
    constructor (age:number) {
12
        this.age = age;
13
        this.entity = new A('小满')
14
    }
15
}
16
 
17
const c = new B(18)
18
 
19
c.entity.name

我们可以看到，B 中代码的实现是需要依赖 A 的，两者的代码耦合度非常高。当两者之间的业务逻辑复杂程度增加的情况下，维护成本与代码可读性都会随着增加，并且很难再多引入额外的模块进行功能拓展。

为了解决这个问题可以使用IOC容器

xxxxxxxxxx
42
1
class A {
2
    name: string
3
    constructor(name: string) {
4
        this.name = name
5
    }
6
}
7
 
8
 
9
class C {
10
    name: string
11
    constructor(name: string) {
12
        this.name = name
13
    }
14
}
15
//中间件用于解耦
16
class Container {
17
    modeuls: any
18
    constructor() {
19
        this.modeuls = {}
20
    }
21
    provide(key: string, modeuls: any) {
22
        this.modeuls[key] = modeuls
23
    }
24
    get(key) {
25
        return this.modeuls[key]
26
    }
27
}
28
 
29
const mo = new Container()
30
mo.provide('a', new A('小满1'))
31
mo.provide('c', new C('小满2'))
32
 
33
class B {
34
    a: any
35
    c: any
36
    constructor(container: Container) {
37
        this.a = container.get('a')
38
        this.c = container.get('c')
39
    }
40
}
41
 
42
new B(mo)

其实就是写了一个中间件，来收集依赖，主要是为了解耦，减少维护成本。

更多关于IOC的资料，参考：https://zhuanlan.zhihu.com/p/658932974

MVC模型

后端MVC概念的理解：

1）Model（模型）

• 含义：模型是应用程序中用于处理数据的部分。它主要负责数据的存储、检索和业务逻辑的执行。模型通常与数据库或其他数据源进行交互，并且包含了数据的验证、关联和操作等功能。

• 示例：

  • 假设我们正在构建一个电商后端应用。在这个应用中，有一个 “商品” 模型。这个模型对应的类可能会包含商品的名称、价格、库存等属性。
  • 以 Python 的 Django 框架为例，定义一个商品模型可能如下：

xxxxxxxxxx
6
1
from django.db import models
2
​
3
class Product(models.Model):
4
    name = models.CharField(max_length = 200)
5
    price = models.DecimalField(max_digits = 10, decimal_places = 2)
6
    stock = models.IntegerField()

• 这个Product模型类定义了商品的基本数据结构。它可以通过 Django 的 ORM（对象关系映射）与数据库进行交互，比如将商品数据保存到数据库中、从数据库中查询商品信息等。同时，模型还可以包含业务逻辑，例如，在这个Product类中可以定义一个方法来计算商品的总价值（total_value = price * stock）。

2）View（视图）

• 含义：视图主要负责将数据以合适的格式呈现给用户或者其他系统。在后端应用中，对于 RESTful API 而言，视图通常是指将数据转换为合适的格式（如 JSON）返回给客户端。它是用户和系统之间交互的接口部分，决定了用户看到的数据外观。

• 示例：

  • 继续以电商后端应用为例，当客户端（如移动应用或网页前端）请求获取商品列表时，视图层会从模型层获取商品数据，然后将其格式化为 JSON 格式返回。
  • 在 Django 中，可以通过视图函数或者基于类的视图来实现。以下是一个简单的视图函数示例，用于获取商品列表并返回 JSON 数据：

xxxxxxxxxx
14
1
from django.http import JsonResponse
2
from.models import Product
3
​
4
def product_list(request):
5
    products = Product.objects.all()
6
    product_list = []
7
    for product in products:
8
        product_dict = {
9
            'name': product.name,
10
            'price': product.price,
11
            'stock': product.stock
12
        }
13
        product_list.append(product_dict)
14
        return JsonResponse(product_list, safe=False)

• 这个视图函数product_list从Product模型中获取所有商品对象，然后将每个商品的相关信息提取出来，组成一个字典列表，最后将这个列表以 JSON 格式返回给客户端。

3）Controller（控制器）

• 含义：控制器是在模型和视图之间起到协调作用的组件。它接收用户的请求，根据请求的类型和内容调用相应的模型方法来处理数据，然后将处理后的数据传递给视图进行展示。控制器决定了应用程序如何响应不同的用户请求，是业务逻辑的调度者。

• 示例：

  • 在一个基于 Java Spring Boot 的后端应用中，控制器可以通过@RestController注解来定义。假设我们有一个用户注册的功能。
  • 控制器类可能如下：

xxxxxxxxxx
22
1
import org.springframework.beans.factory.annotation.Autowired;
2
import org.springframework.web.bind.annotation.PostMapping;
3
import org.springframework.web.bind.annotation.RequestBody;
4
import org.springframework.web.bind.annotation.RestController;
5
import com.example.demo.model.User;
6
import com.example.demo.service.UserService;
7
​
8
@RestController
9
public class UserController {
10
    @Autowired
11
    private UserService userService;
12
​
13
    @PostMapping("/register")
14
    public String registerUser(@RequestBody User user) {
15
        boolean result = userService.register(user);
16
        if (result) {
17
            return "User registered successfully";
18
        } else {
19
            return "Registration failed";
20
        }
21
    }
22
}

• 这个UserController接收一个用户注册的POST请求（通过@PostMapping注解定义），将请求体中的用户数据（@RequestBody User user）传递给UserService（这是业务逻辑处理部分，属于模型层的范畴）进行注册操作。根据UserService返回的结果，控制器决定返回给客户端相应的消息，这个消息最终会通过视图层（在这种情况下，Spring Boot 会自动将字符串转换为合适的响应格式，如 JSON 或者纯文本）返回给客户端。

那么在nestjs中，应该怎么理解MVC呢？

参考：https://www.zhihu.com/question/544494969/answer/3027687155

1）Model（模型）

• 在 NestJS 中，模型通常是指数据结构和数据库交互相关的部分。
• 例如，如果使用 TypeORM（一个 NestJS 中常用的数据库访问库），模型文件会定义数据库表对应的实体类。假设你有一个用户模块，user.entity.ts文件就是模型的一部分。
• 以下是一个简单的 TypeORM 实体类（模型）示例：

xxxxxxxxxx
10
1
import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';
2
@Entity()
3
export class User {
4
    @PrimaryGeneratedColumn()
5
    id: number;
6
    @Column()
7
    name: string;
8
    @Column()
9
    email: string;
10
}

• 这个User类定义了数据库中user表的结构，包括id、name和email字段。它可以用于数据库的增删改查操作，比如在数据访问层（Repository）中作为操作的数据对象。

2）View（视图）

• 在传统的 MVC 中，视图主要负责数据的展示。在 NestJS 的后端应用场景下，视图概念可能有所不同。如果是构建一个 RESTful API，视图可以理解为返回给客户端的数据格式（如 JSON 格式的数据）。
• 一般来说，没有像传统 Web 开发中那种.html等视图文件。在 NestJS 的控制器（Controller）方法中，会通过@Get、@Post等装饰器定义的路由处理函数返回数据给客户端，这个返回的数据可以看作是 “视图” 部分。
• 例如，在一个用户控制器user.controller.ts中的一个获取用户信息的方法：

xxxxxxxxxx
10
1
import { Controller, Get } from '@nestjs/common';
2
import { UserService } from './user.service';
3
@Controller('users')
4
export class UserController {
5
    constructor(private readonly userService: UserService) {}
6
    @Get(':id')
7
    async findOne(id: string): Promise<User> {
8
        return this.userService.findOne(id);
9
    }
10
}

• 当客户端发送一个GET请求到/users/:id这个路由时，控制器的findOne方法会调用服务层（user.service.ts）的findOne方法获取用户数据，并将其返回给客户端。返回的用户数据（这里假设是User类型的对象）的格式就是客户端看到的 “视图”。

3）Controller（控制器）

• 在 NestJS 中，控制器文件（通常以.controller.ts结尾）负责处理传入的请求并返回响应。它是应用程序中处理 HTTP 请求的入口点。
• 如上面提到的user.controller.ts文件，它使用@Controller装饰器定义了一个基本的路由前缀（/users），并在其中定义了具体的路由处理方法（如findOne方法），这些方法通过 HTTP 方法装饰器（如@Get、@Post等）来处理不同类型的请求。
• 控制器会调用服务层（Service）的方法来获取数据或者执行业务逻辑，然后将结果返回给客户端或者进行进一步的处理（如格式化数据等）。它起到了协调模型和视图（在 API 场景下是数据返回格式）之间交互的作用。

3、前置知识-装饰器

注意：

我在学习nestjs的时候，有一个错误的理解：装饰器就是为了实现依赖注入。直到我想要将nestjs教程做成xmind时，不得不提炼一下知识点时，我才发现这是一个错误理解。装饰器能够在nestjs中实现依赖注入，但是在nestjs中，装饰器的作用还有很多，以下是它的作用。

一、控制反转（IoC）和依赖注入

1. @Injectable()装饰器：

   • 用于标记一个类可以被 NestJS 的依赖注入系统管理。
   • 当一个服务类被标记为 @Injectable()后，NestJS 可以在需要这个服务的地方自动实例化并注入该服务。
   • 例如，在一个控制器中，如果需要使用某个服务，可以将该服务作为参数传入控制器的构造函数，NestJS 会自动查找并注入这个服务实例。
   • 这使得代码的模块间耦合度降低，提高了代码的可维护性和可测试性。

二、定义路由和处理请求

1. @Controller()装饰器：

   • 用于定义一个控制器类，该类负责处理特定的路由请求。
   • 可以通过设置装饰器的参数来指定控制器的路由前缀，例如 @Controller('users') 表示这个控制器处理以 /users 开头的路由请求。

2. @Get()、@Post()、@Put()、@Delete() 等装饰器：

   • 用于定义控制器中的具体路由处理方法。
   • 比如 @Get('profile') 表示处理 GET 请求到 /users/profile 的路由，方法内部可以编写具体的业务逻辑来响应这个请求。

三、配置参数和元数据

1. @Param()、@Query()、@Body()等装饰器：

   • 用于从请求中提取特定类型的参数。
   • @Param('id') 可以提取路由参数中的 id 值，@Query('page') 可以提取查询参数中的 page 值，@Body() 可以提取请求体中的数据。
   • 这些装饰器使得在处理请求时能够方便地获取和使用各种类型的输入数据。

四、实现中间件和过滤器

1. @UseMiddleware()装饰器：

   • 用于将中间件应用到特定的路由或控制器上。
   • 中间件可以在请求处理管道中执行一些通用的逻辑，如日志记录、身份验证、错误处理等。

2. @UseFilters()装饰器：

   • 用于将异常过滤器应用到特定的路由或控制器上。
   • 过滤器可以捕获和处理在请求处理过程中发生的异常，返回统一的错误响应格式。

总之，装饰器在 NestJS 中起到了关键的作用，它们帮助开发者以一种简洁、声明式的方式构建强大的应用程序，提高了开发效率和代码的可维护性。

这一节主要讲在typescript中，装饰器的几种用法，就这么四种用法，真的是不多，可以从ts的定义里面看到，装饰器就是一个函数，里面有哪些参数、可以用这些参数做什么，这些都可以从类型定义看出来。

注意：上面的装饰器是typescript传统的装饰器，现在传统和新版本的装饰器可以共存，这就是为什么我ctrl+点击ClassDecorator，会在lib.decorators.legacy.d.ts这个文件里面出现了，因为我知道legacy就是遗产、遗留的意思。

新版本的装饰器，可以在阮一峰的typescript教程里面查看，使用起来区别还是很大的，但是这里用传统的装饰器来学习nestjs，没有任何问题，只需要知道它的原理就行了。

1、什么是装饰器

装饰器是一种特殊的类型声明，他可以附加在类，方法，属性，参数上面。

如果是自己创建的项目里面，要写装饰器，需要开启一项配置。（像nestjs这些框架，如果使用它的脚手架来创建项目，就是默认打开这项配置的。）

类装饰器

作用：它会自动把class的构造函数传入到装饰器的第一个参数 target，然后通过prototype可以自定义添加属性和方法。

上面的“class的构造函数”，要搞清楚是什么意思。就是constructor。

xxxxxxxxxx
1
1
declare type ClassDecorator = <TFunction extends Function>(target: TFunction) => TFunction | void;

xxxxxxxxxx
15
1
function decotators (target:any) {
2
    console.log(target)
3
    target.prototype.name = '小满'
4
}
5
 
6
@decotators
7
class Xiaoman {
8
    constructor () {
9
 
10
    }
11
}
12
 
13
const xiaoman:any = new Xiaoman()
14
 
15
console.log(xiaoman.name);

属性装饰器

xxxxxxxxxx
1
1
declare type PropertyDecorator = (target: Object, propertyKey: string | symbol) => void;

使用@符号给属性添加装饰器，它会返回两个参数：

1.原型对象

2.属性的名称

xxxxxxxxxx
11
1
const currency: PropertyDecorator = (target: any, key: string | symbol) => {
2
    console.log(target, key)
3
}
4
 
5
class Xiaoman {
6
    @currency
7
    public name: string
8
    constructor() {
9
        this.name = ''
10
    }
11
}

这里我有一个疑问：这个类并没有实例化，也没有输出类的哪些信息，那执行2.ts文件的输出是哪来的呢？

其实之所以有这个疑问，就是因为没有搞清楚装饰器的作用，上面已经说了，属性装饰器会返回两个参数，而我已经在装饰器函数里面输出了这两个参数的值。那么执行这个文件的时候，会编译这个类，同样也会执行里面的装饰器函数，所以会有输出结果显示出来。

参数装饰器

xxxxxxxxxx
1
1
declare type ParameterDecorator = (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;

在按照下面的代码写之后，会报错：

虽然看不懂，但我感觉重点是这一句，于是我找到ParameterDecorator的类型定义，发现它是这样的：

declare type ParameterDecorato = (target: Object, propertyKey: string | symbol | undefined, parameterIndex: number) => void;

propertyKey需要加一个undefined的类型，加了之后就不报错了。

但是我看到别的版本的typescript里面的定义不是这样的，等做项目的时候注意就行了。

使用@符号给参数添加装饰器，它会返回三个参数：

1.原型对象

2.方法的名称（注意：虽然修饰的是参数，但是返回的这个propertyKey，是方法的名称。）

3.参数的位置索引，从0开始（注意：这里指的是被装饰器修饰的参数，在方法里面所在的位置索引）

xxxxxxxxxx
13
1
const currency: ParameterDecorator = (target: any, key: string | symbol ,index:number) => {
2
    console.log(target, key,index)
3
}
4
 
5
class Xiaoman {
6
    public name: string
7
    constructor() {
8
        this.name = ''
9
    }
10
    getName(name:string,@currency age:number) {
11
        return this.name
12
    }
13
}

方法装饰器

xxxxxxxxxx
1
1
declare type MethodDecorator = <T>(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T> | void;

使用@符号给方法添加装饰器，它会返回三个参数：

1.原型对象

2.方法的名称

3.属性描述符。可写对应writable，可枚举对应enumerable，可配置对应configurable，value对应被修饰的函数本身。

xxxxxxxxxx
14
1
const currency: MethodDecorator = (target: any, key: string | symbol,descriptor:any) => {
2
    console.log(target, key,descriptor)
3
}
4
 
5
class Xiaoman {
6
    public name: string
7
    constructor() {
8
        this.name = ''
9
    }
10
    @currency
11
    getName(name:string,age:number) {
12
        return this.name
13
    }
14
}

注意：装饰器可以写成很多种样子，但是@后面的表达式，必须是一个函数（或者执行后可以得到一个函数）。

所以，只要下面这些方式，@后面的表达式，最终执行后得到的是一个函数，那么写起来都是OK的。

xxxxxxxxxx
7
1
@myFunc
2
@myFuncFactory(arg1, arg2)
3
​
4
@libraryModule.prop
5
@someObj.method(123)
6
​
7
@(wrap(dict['prop']))

https://wangdoc.com/typescript/decorator

那么我的这个疑问：装饰器既然是一个函数，那么在使用装饰器的时候，要不要带括号呢？

如果在编写装饰器的时候，不用传参，那么使用装饰器的时候就不要写括号，写了括号反而会报错：Unable to resolve signature of property decorator when called as an expression.。被当作了一个表达式了。

如果在编写装饰器的时候，传递了参数，一般都会用到函数的柯里化，这时候使用装饰器就要带括号了，即使不传实参。

4、前置知识-装饰器，实现一个GET请求

这一节课对理解nestjs框架原理很有帮助，装饰器到底是怎么被应用的，不管是自定义的装饰器还是nestjs提供的装饰器，目前就是死记硬背在用。如果自己能够独立做出这个需求，搞清楚这一点，那么nestjs的原理就理解的很深刻了，写起代码来就很得心应手了。

1、首先使用npm init初始化项目，然后安装依赖npm install axios -S。

2、定义控制器 Controller。这里实际上就是模拟nestjs里面的xxx.controller.ts中的controller类。里面的getList就是一个方法，类似于xxx.controller.ts里面经常见到的findAll(){}。

xxxxxxxxxx
9
1
class Controller {
2
    constructor() {
3
 
4
    }
5
    getList () {
6
 
7
    }
8
  
9
}

3、定义装饰器

这时候需要使用装饰器工厂（也就是函数柯里化），因为装饰器默认会塞入一些参数，那么在xxx.controller.ts里面的@Get、@Post这些装饰器中，我们是可以传递参数的，传递的参数怎么在装饰器定义的函数里面接收呢？这时候就要用到函数的柯里化了。

定义 descriptor 的类型，通过 descriptor描述符里面的value 把axios的结果返回给当前使用装饰器的函数

xxxxxxxxxx
16
1
import axios from "axios"
2
​
3
const Get = (url: string): MethodDecorator => {
4
    return (target, key, descriptor: PropertyDescriptor) => {
5
        const fnc = descriptor.value;
6
        axios.get(url).then(res => {
7
            fnc(res, {
8
                status: 200,
9
            })
10
        }).catch(e => {
11
            fnc(e, {
12
                status: 500,
13
            })
14
        })
15
    }
16
}

完整代码 接口可以直接用允许跨域的

xxxxxxxxxx
28
1
import axios from 'axios'
2
 
3
const Get = (url: string): MethodDecorator => {
4
    return (target, key, descriptor: PropertyDescriptor) => {
5
        const fnc = descriptor.value;
6
        axios.get(url).then(res => {
7
            fnc(res, {
8
                status: 200,
9
            })
10
        }).catch(e => {
11
            fnc(e, {
12
                status: 500,
13
            })
14
        })
15
    }
16
}
17
 
18
//定义控制器
19
class Controller {
20
    constructor() {
21
 
22
    }
23
    @Get('https://api.apiopen.top/api/getHaoKanVideo?page=0&size=10')
24
    getList (res: any, status: any) {
25
        console.log(res.data.result.list, status)
26
    }
27
  
28
}

看到MethodDecorator的typescript定义，里面的descriptor的类型是TypedPropertyDescriptor<T>，不是老师所讲的PropertyDescriptor，于是我就按照typescript定义的类型来做，但是怎么都调不通，里面的泛型T不知道该传什么进去，我详细编写了这个T的类型，但还是报错。虽然说按照老师所用的PropertyDescriptor可以调通，但是为什么不能使用typescript定义的类型呢？这一点我想搞清楚，趁现在有时间。

于是我看了一下阮一峰的typescript教程，发现MethodDecorator其实不是最新的typescript装饰器标准，而是以前的：

https://wangdoc.com/typescript/decorator#%E6%96%B9%E6%B3%95%E8%A3%85%E9%A5%B0%E5%99%A8，这是最新的方法装饰器，名称是ClassMethodDecorator，里面的参数也不一样。但由于传统的装饰器还是可以使用的，那么还是要看一下传统的方法装饰器，https://wangdoc.com/typescript/decorator-legacy#%E6%96%B9%E6%B3%95%E8%A3%85%E9%A5%B0%E5%99%A8。

我发现这个文档里面的例子，也是使用的PropertyDescriptor类型：

这下就麻烦了，我就是想知道这个PropertyDescriptor类型是怎么来的，无论是百度还是bing，都无法搜索到我想要的答案，于是我把代码发给chatgpt，让它来教我。

问：

下面的代码，使用了typescript传统的方法装饰器：

xxxxxxxxxx
22
1
function enumerable(value: boolean) {
2
return function (
3
target: any,
4
propertyKey: string,
5
descriptor: PropertyDescriptor
6
) {
7
descriptor.enumerable = value;
8
};
9
}
10
​
11
class Greeter {
12
greeting: string;
13
​
14
constructor(message:string) {
15
this.greeting = message;
16
}
17
​
18
@enumerable(false)
19
greet() {
20
return 'Hello, ' + this.greeting;
21
}
22
}

里面的descriptor参数，类型为什么使用了PropertyDescriptor这个类型。我看见MethodDecorator里面的定义，descriptor参数的类型是TypedPropertyDescriptor，为什么要这样写呢？

答：

在 TypeScript 中，装饰器的实现需要考虑到装饰的目标是类、属性还是方法。对于方法装饰器，descriptor 参数的类型通常是 PropertyDescriptor，因为它提供了对被装饰方法的描述和控制。而对于带有泛型参数的方法装饰器，比如 TypedPropertyDescriptor<T>，它提供了更多类型安全性，允许在编译时检查装饰器是否正确应用于方法。

问：

如果上面的代码中，使用TypedPropertyDescriptor定义descriptor 参数的类型，应该怎么写呢？

答：

在 TypeScript 中，如果你想使用 TypedPropertyDescriptor<T> 来定义方法装饰器的 descriptor 参数类型，你需要做以下修改：

xxxxxxxxxx
22
1
function enumerable(value: boolean) {
2
return function (
3
target: any,
4
propertyKey: string,
5
descriptor: TypedPropertyDescriptor<() => string> // Adjust the type here
6
) {
7
descriptor.enumerable = value;
8
};
9
}
10
​
11
class Greeter {
12
greeting: string;
13
​
14
constructor(message:string) {
15
this.greeting = message;
16
}
17
​
18
@enumerable(false)
19
greet() {
20
return 'Hello, ' + this.greeting;
21
}
22
}

在上面的代码中，我将 descriptor 参数的类型从 PropertyDescriptor 改为了 TypedPropertyDescriptor<() => string>。这里假设 greet() 方法返回类型为 string，因此使用了 () => string 类型来描述。

• TypedPropertyDescriptor<T> 是一个泛型接口，允许你指定方法的签名，以便在装饰器中对其进行更加精确的类型控制和检查。
• 在装饰器中使用 TypedPropertyDescriptor<T> 可以增强 TypeScript 的类型安全性，确保装饰器在编译时正确地应用于目标方法。

这种方式适用于需要对方法装饰器进行类型检查和限制的场景，特别是当装饰的方法具有特定的参数和返回类型时。

问：

上面你说“对于方法装饰器，descriptor 参数的类型通常是 PropertyDescriptor，因为它提供了对被装饰方法的描述和控制。”，我从哪里可以看到通常使用PropertyDescriptor，明明定义里面就是 TypedPropertyDescriptor 啊？

答：

理解 TypeScript 中装饰器的 descriptor 参数类型选择涉及到你希望在装饰器内部对方法进行何种粒度的控制和类型检查。

Method Decorator 中的 descriptor 参数类型选择：

1. PropertyDescriptor vs TypedPropertyDescriptor:

   • PropertyDescriptor: 这是一个通用的描述符类型，用于属性和方法的装饰器。它提供了基本的描述符信息，如是否可枚举等，但不包含具体的方法签名信息。
   • TypedPropertyDescriptor: 这是一个泛型接口，允许你指定方法的具体签名，包括参数和返回类型。在方法装饰器中，如果你需要访问和操作方法的具体类型信息，如确保方法的返回类型是特定的类型或对方法的参数类型进行检查，那么使用 TypedPropertyDescriptor<T> 是更为适合的选择。

2. 选择合适的类型：

   • 使用 PropertyDescriptor: 如果装饰器只需对方法进行基本的控制，如修改方法的可枚举性而不需要关注具体的方法签名和类型，那么可以使用 PropertyDescriptor。
   • 使用 TypedPropertyDescriptor: 如果装饰器需要更精细的类型控制，如确保方法的返回类型符合预期或对方法参数进行类型检查，那么应该使用 TypedPropertyDescriptor<T>。在这种情况下，你需要提供正确的方法签名作为泛型参数，例如 TypedPropertyDescriptor<() => string> 表示方法返回类型为 string。

3. 在实际代码中的应用：

   • 根据你的示例，如果 greet() 方法确实返回 string 类型，并且你希望装饰器确保这一点，那么你应该使用 TypedPropertyDescriptor<() => string> 来描述 descriptor 的类型。
   • TypeScript 的编辑器通常会根据上下文和泛型参数提供代码补全功能，帮助你选择合适的类型。此外，你也可以查阅 TypeScript 的官方文档或相关资源，以深入了解每种类型的适用场景和差异。

4. 了解类型定义来源：

   • 在 TypeScript 中，MethodDecorator 的定义确实表明 descriptor 参数的类型可以是 TypedPropertyDescriptor<T>，这使得你可以在装饰器中对方法的具体签名进行类型安全的控制。
   • 如果你想查看官方文档或其他 TypeScript 相关资源，你可以进一步理解每种类型的用途和限制，以便根据实际需求正确选择 descriptor 的类型。

综上所述，选择 PropertyDescriptor 或 TypedPropertyDescriptor<T> 取决于你对方法装饰器所需的精度和类型安全性的具体要求。通过合适的类型选择，可以确保在装饰器中有效地操作和控制目标方法的行为和类型。

 

从上面的答案，我还是没有得到我想要的回答：我从哪里可以知道，descriptor可以使用PropertyDescriptor类型？或许就是需要经验积累吧，多看别人写的typescript代码才能知道。

那么我也可以知道，本来就可以使用TypedPropertyDescriptor<T>来定义descriptor的类型，只是我的水平不够。把代码发给chatgpt，让它来帮我解决一下。

问：

我写了下面这段代码：

xxxxxxxxxx
25
1
import axios from "axios";
2
​
3
const Get = (url: string): MethodDecorator => {
4
  return (target: any, key: string | symbol, descriptor: TypedPropertyDescriptor<() => void>) => {
5
    const fnc = descriptor.value;
6
    axios
7
      .get(url)
8
      .then((res) => {
9
        fnc(res, {
10
          status: 200,
11
          message: "success",
12
        });
13
      })
14
      .catch((err) => {});
15
  };
16
};
17
​
18
class Controller {
19
  constructor() {}
20
​
21
  @Get("")
22
  getList(res: any, obj: { status: number; message: string }) {
23
    console.log(res, obj);
24
  }
25
}

typescript报错：Type '(target: any, key: string | symbol, descriptor: TypedPropertyDescriptor<() => void>) => void' is not assignable to type 'MethodDecorator'.

请问怎么改？

答：

在你的代码中，报错是因为 Get 方法返回的装饰器类型不匹配 MethodDecorator。实际上，装饰器函数需要返回一个装饰器，而不是直接定义装饰器函数本身。

下面是如何修正你的代码：

xxxxxxxxxx
30
1
import axios from "axios";
2
​
3
// 定义 Get 装饰器工厂函数，返回一个装饰器函数
4
const Get = (url: string): MethodDecorator => {
5
  return (target: any, key: string | symbol, descriptor: TypedPropertyDescriptor<() => void>) => {
6
    const originalMethod = descriptor.value; // 保存原始方法
7
​
8
    // 修改方法的实现
9
    descriptor.value = function(this: any, ...args: any[]) {
10
      axios
11
        .get(url)
12
        .then((res) => {
13
          // 调用原始方法，并传入参数
14
          originalMethod.apply(this, [res, { status: 200, message: "success" }]);
15
        })
16
        .catch((err) => {});
17
    };
18
​
19
    return descriptor; // 返回修改后的 descriptor
20
  };
21
};
22
​
23
class Controller {
24
  constructor() {}
25
​
26
  @Get("") // 使用 Get 装饰器
27
  getList(res: any, obj: { status: number; message: string }) {
28
    console.log(res, obj);
29
  }
30
}

修正的关键点在于：

1. Get 装饰器工厂函数： 返回一个方法装饰器，而不是直接实现装饰器函数。这样可以确保装饰器的类型与 MethodDecorator 兼容。
2. 修改 descriptor： 在装饰器内部，修改方法的实现，保留原始方法并用新的实现替换。这样可以在 axios 请求完成后调用原始方法，并传入响应和其他参数。
3. 返回 descriptor： 最后，确保从装饰器函数返回修改后的 descriptor，以使 TypeScript 理解装饰器的应用方式。

通过这些调整，你应该能够解决 TypeScript 报错并成功应用装饰器。

问：

按照你上面的代码，还是报错，报错信息如下：

Type '(target: any, key: string | symbol, descriptor: TypedPropertyDescriptor<() => void>) => TypedPropertyDescriptor<() => void>' is not assignable to type 'MethodDecorator'. Types of parameters 'descriptor' and 'descriptor' are incompatible. Type 'TypedPropertyDescriptor' is not assignable to type 'TypedPropertyDescriptor<() => void>'. Types of property 'value' are incompatible. Type 'T | undefined' is not assignable to type '(() => void) | undefined'. Type 'T' is not assignable to type '(() => void) | undefined'.ts(2322)

答：

The error you're encountering arises because the type returned by your Get decorator function does not match TypeScript's expected MethodDecorator type. Let's address this issue step by step:

1、Understanding the Error

The error message Type '(target: any, key: string | symbol, descriptor: TypedPropertyDescriptor<() => void>) => TypedPropertyDescriptor<() => void>' is not assignable to type 'MethodDecorator'. indicates that TypeScript expects a method decorator (MethodDecorator type) but is receiving a different type (TypedPropertyDescriptor<() => void>).

2、Correcting the Decorator

To fix this, ensure your decorator function returns a proper method decorator that TypeScript can recognize. Here's how you can correct your decorator:

1. Define a Factory Function: Create a factory function that returns the actual decorator function.
2. Modify the Decorator Function: Inside the decorator function, modify the method's behavior using the provided descriptor.
3. Return the Descriptor: Return the modified descriptor after making necessary changes.

Here's the corrected implementation:

xxxxxxxxxx
31
1
import axios from "axios";
2
​
3
// Define Get decorator factory function
4
const Get = (url: string): MethodDecorator => {
5
  return (target: any, key: string | symbol, descriptor: PropertyDescriptor) => {
6
    const originalMethod = descriptor.value as Function; // Cast to Function type
7
​
8
    // Modify method implementation
9
    descriptor.value = function(this: any, ...args: any[]) {
10
      axios
11
        .get(url)
12
        .then((res) => {
13
          // Call original method with response and additional object
14
          originalMethod.apply(this, [res, { status: 200, message: "success" }]);
15
        })
16
        .catch((err) => {});
17
    };
18
​
19
    return descriptor; // Return modified descriptor
20
  };
21
};
22
​
23
// Example usage of Get decorator
24
class Controller {
25
  constructor() {}
26
​
27
  @Get("") // Applying Get decorator to getList method
28
  getList(res: any, obj: { status: number; message: string }) {
29
    console.log(res, obj);
30
  }
31
}

3、Explanation

• Decorator Factory Function: Get function now returns a method decorator (MethodDecorator) rather than trying to directly implement the decorator function itself.
• Decorator Function: Inside the decorator function returned by Get, descriptor is of type PropertyDescriptor, which matches TypeScript's expected type for method decorators.
• Modification of Descriptor: The descriptor.value is modified to intercept the original method execution and perform additional actions (in this case, making an Axios GET request).
• Returning Descriptor: Always return the modified descriptor at the end of the decorator function to ensure TypeScript recognizes it correctly.

4、Conclusion

By following these steps, you ensure that TypeScript understands the decorator's purpose and correctly infers the types involved (PropertyDescriptor in this case). This approach aligns with TypeScript's type expectations for method decorators and allows you to apply additional behaviors to methods effectively.

 

还是没有解决我的问题，但是仔细一想，typescript本身也并不是完美的，说不定就是因为使用TypedPropertyDescriptor<T>不好定义，所以后来才添加了PropertyDescriptor来解决问题。这个问题就到这里吧。

 

但是我还是不甘心，到底哪里不同啊？

区别就在于PropertyDescriptor的value就定义成了any类型，我定义成这样descriptor: TypedPropertyDescriptor<any>，果然就不报错了。

xxxxxxxxxx
30
1
import axios from "axios";
2
​
3
const Get = (url: string): MethodDecorator => {
4
  return (target: any, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<any>) => {
5
    const cb = descriptor.value;
6
    axios
7
      .get(url)
8
      .then((res) => {
9
        cb(res, {
10
          status: 200,
11
          message: "success",
12
        });
13
      })
14
      .catch((err) => {
15
        cb(err, {
16
          status: 500,
17
          message: "fail",
18
        });
19
      });
20
  };
21
};
22
​
23
class Controller {
24
  constructor() {}
25
​
26
  @Get("https://api.apiopen.top/api/getHaoKanVideo?page=0&size=5")
27
  getList(res: any, obj: { status: number; message: string }) {
28
    console.log(res.data.result.list, obj);
29
  }
30
}

 

老师的这个例子，用了前端的axios请求，并没有把nestjs里面装饰器的处理很好的展现出来。比如说nestjs里面的Get装饰器，会被用到非常多的接口上面，而Get装饰器接收一个参数，就是接口的路径，里面还可以用:id这种方式表示动态参数。

那Get装饰器接收到参数之后，怎么将参数和对应的方法结合起来的呢？应该就是用到了descriptor.value，这样就可以进行不同的处理，返回不同的结果。

那么方法里面可能还有参数装饰器，比如说Controller类还有类装饰器，类里面还有属性装饰器，这些装饰器的执行顺序是什么样的？

https://wangdoc.com/typescript/decorator#%E8%A3%85%E9%A5%B0%E5%99%A8%E7%9A%84%E6%89%A7%E8%A1%8C%E9%A1%BA%E5%BA%8F

5、nestjs cli

通过cli创建nestjs项目

xxxxxxxxxx
5
1
# 安装nestjs脚手架
2
npm i -g @nestjs/cli
3
    
4
# 创建项目
5
nest new [项目名称]

如果在编写过程中，需要热更新，使用npm run start:dev启动项目就可以了。

xxxxxxxxxx
6
1
{
2
    "start": "nest start",
3
    "start:dev": "nest start --watch",
4
    "start:debug": "nest start --debug --watch",
5
    "start:prod": "node dist/main"
6
}

使用nestjs/cli创建的项目，用vscode打开的时候，会自动将换行符转换为crlf，原本的文件里面应该是lf的。这样文件打开就会一堆红色波浪线，原来以为是代码哪里写错了，不是的，刚创建的项目怎么可能有错。错误在Windows系统，将换行符改为了crlf。

最有效的方法就是将开发平台换为liunx或者mac，但这是后话了，下面讲一下Windows平台怎么处理。

1、Git设置

git在提交、拉取代码的时候，会自动转换换行符，我设置了关闭转换换行符。

xxxxxxxxxx
1
1
git config --global core.autocrlf false

git提供了一个名为core.eol的配置选项，用于控制换行符在提交时的换行行为，我设置为lf。

xxxxxxxxxx
1
1
git config --global core.eol lf

2、vscode设置

打开settings，搜索eol（end of line），然后将eol改为\n

3、在vscode中安装editorconfig for vscode，并在项目中编写配置文件

参考：visual-studio-code - vscode如何替换所有文件的回车格式为LF呢？ - SegmentFault 思否

在项目的根目录中创建并配置文件.editorconfig，配置如下：

xxxxxxxxxx
9
1
root = true
2
​
3
[*]
4
charset = utf-8
5
indent_style = space
6
indent_size = 2
7
end_of_line = lf
8
insert_final_newline = true
9
trim_trailing_whitespace = true

然后只需要将爆红色波浪线的文件，使用ctrl+s重新保存一下就可以了。

上面这些设置，到底最终起作用的是哪一个配置，这我不知道，我还是都配置了吧，免得出问题。

plus：

不要想买macbook来解决这个问题，直接使用Ubuntu开发环境就行了，除非公司送给我一台macbook，否则我是不会买的，太贵了。

目录介绍

1、main.ts：入口文件主文件，类似于vue 的main.ts。通过 NestFactory.create(AppModule) 创建一个app，这里的AppModule就类似于vue里面绑定一个根组件App.vue（SPA模式）。app就相当于一个应用。app.listen(3000); 监听3000端口。

xxxxxxxxxx
8
1
import { NestFactory } from '@nestjs/core';
2
import { AppModule } from './app.module';
3
 
4
async function bootstrap() {
5
  const app = await NestFactory.create(AppModule);
6
  await app.listen(3000);
7
}
8
bootstrap();

2、app.module.ts

xxxxxxxxxx
12
1
import { Module } from '@nestjs/common';
2
import { AppController } from './app.controller';
3
import { AppService } from './app.service';
4
​
5
// 使用一个类装饰器来修饰AppModule，现在应该看得懂了。app.module.ts根模块用于处理其它类的引用与共享。可以把它理解为IOC里面的container（容器）。
6
@Module({
7
  imports: [],
8
  controllers: [AppController],
9
  providers: [AppService],
10
})
11
export class AppModule {}
12
​

3、Controller.ts 控制器

可以理解成vue的路由，private readonly appService: AppService 这一行代码就是依赖注入，不需要实例化 appService ，nestjs框架内部会自己实例化，我们只需要放上去就可以了。（如果不理解，就看一下前面的IOC内容）

xxxxxxxxxx
28
1
import { Controller, Get } from '@nestjs/common';
2
import { AppService } from './app.service';
3
 
4
@Controller()
5
export class AppController {
6
  constructor(private readonly appService: AppService) {}
7
 
8
  @Get()
9
  getHello(): string {
10
    return this.appService.getHello();
11
  }
12
}
13
 
14
//-----------------------------------------------------
15
//下面的代码是测试一下修改路由地址之后，访问是否正常
16
 
17
import { Controller, Get } from '@nestjs/common';
18
import { AppService } from './app.service';
19
 
20
@Controller('/get')
21
export class AppController {
22
  constructor(private readonly appService: AppService) {}
23
 
24
  @Get('/hello')
25
  getHello(): string {
26
    return this.appService.getHello();
27
  }
28
}

4、app.service.ts

这个文件主要实现业务逻辑的，当然Controller可以实现逻辑，但是就是单一的无法复用，放到app.service，如果别的模块也需要，就可以实现复用。

xxxxxxxxxx
8
1
import { Injectable } from '@nestjs/common';
2
 
3
@Injectable()
4
export class AppService {
5
  getHello(): string {
6
    return 'Hello World!';
7
  }
8
}

之前一直对nestjs里面的IOC和装饰器不理解，为什么不直接使用express呢？原因还是在于无法做大型项目，如果项目只有一个人做，那么无所谓，随便你用什么框架，但是多个人合作之后，就要求大家的代码能够不冲突、风格统一、重要代码能够复用、快速完成任务等等，express能够做到这些吗？我想很难，因为如果它里面的一个复用组件变化了之后，用到这个组件的地方都需要修改，也许这就是难点。

不想使用nestjs主要原因还是在于我不会用装饰器，不理解IOC的原理。（2024-06-16）现在有了一点理解之后，我发现用起来真的非常简单，重点就可以放在业务逻辑上了，写项目就没有问题了。

6、nestjs cli常用命令

nest --help 可以查看nestjs所有的命令

案例生成一个用户模块

1.生成controller.ts

xxxxxxxxxx
1
1
nest g co user

2.生成 module.ts

xxxxxxxxxx
1
1
nest g mo user

3.生成service.ts

xxxxxxxxxx
1
1
nest g s user

以上步骤一个一个生成的太慢了我们可以直接使用一个命令生成CURD

xxxxxxxxxx
1
1
 nest g resource xiaoman

第一次使用这个命令的时候，除了生成文件之外还会自动使用 npm 帮我们更新资源，安装一些额外的插件，后续再次使用就不会更新了。

生成了一套标准的CURD 模板

7、restful风格设计

RESTful 是一种风格，在RESTful中，一切都被认为是资源，每个资源有对应的URL标识。不是标准也不是协议，只是一种风格。当然你也可以不按照他的风格去写，不过一般都是使用这些现成的风格。

1.接口url 传统接口使用语义化的路径，定义起来很复杂。

http://localhost:8080/api/get_list?id=1

http://localhost:8080/api/delete_list?id=1

http://localhost:8080/api/update_list?id=1

RESTful接口

http://localhost:8080/api/get_list/1

RESTful 风格：一个接口就会完成“增删改查”，它是通过不同的请求方式来区分的。

查询GET

提交POST

更新 PUT PATCH

删除 DELETE

2.RESTful 版本控制

一共有三种控制方法，我们一般用第一种，因为第一种更加语义化。

在接口前面通过版本号来访问不同的接口版本。

①在app.module.ts里面开启版本控制。

xxxxxxxxxx
13
1
import { NestFactory } from '@nestjs/core';
2
import { VersioningType } from '@nestjs/common';
3
import { AppModule } from './app.module';
4
 
5
async function bootstrap() {
6
  const app = await NestFactory.create(AppModule);
7
  // 开启版本控制，使用第一种方法，在URI里面进行控制。可以ctrl+点击VersioningType看一下，共有几种值。
8
  app.enableVersioning({
9
    type: VersioningType.URI,
10
  })
11
  await app.listen(3000);
12
}
13
bootstrap();

②在需要控制版本的路径里面配置版本

这里以user.controller为例来配置版本。Controller装饰器里面的参数变为一个对象，通过version 配置版本，path就是这个Controller的访问路径。

当然如果想要控制某一个接口的版本，那么可以在这个接口上方使用@Version(1)装饰器来配置。

xxxxxxxxxx
32
1
import { Controller, Get, Post, Body, Patch, Param, Delete, Version } from '@nestjs/common';
2
import { UserService } from './user.service';
3
import { CreateUserDto } from './dto/create-user.dto';
4
import { UpdateUserDto } from './dto/update-user.dto';
5
 
6
@Controller({
7
  path:"user",
8
  version:'1'
9
})
10
export class UserController {
11
  constructor(private readonly userService: UserService) {}
12
 
13
  @Post()
14
  create(@Body() createUserDto: CreateUserDto) {
15
    return this.userService.create(createUserDto);
16
  }
17
 
18
  @Get()
19
  // @Version('1')
20
  findAll() {
21
    return this.userService.findAll();
22
  }
23
 
24
  @Get(':id')
25
  findOne(@Param('id') id: string) {
26
    return this.userService.findOne(+id);
27
  }
28
 
29
  @Patch(':id')
30
  update(@Param('id') id: string, @Body() updateUserDto: UpdateUserDto) {
31
    return this.userService.update(+id, updateUserDto);
32
  }

访问配置了版本的接口时，需要在路径前面加上v版本号，比如说是版本1，那么就是v1。

这个版本控制，可能之前在大方租车见过，但是印象不深，因为毕竟不是后端。这个版本控制怎么使用呢？有没有可能v1和v2会共存呢？

老师说了一下使用场景，应该是这样的：公司决定要做一个app，然后会分阶段不断优化，在每个阶段都有其各自的git分支，比如说刚开始的版本，会在部分接口前面加上版本1，第二个分支就会加上版本2，以此类推。但如果第二个分支是从第一个分支创建的，还是有可能共存，这方面的信息还是看到了再说吧。

3.Code码规范

200 OK

304 Not Modified 协商缓存了

400 Bad Request 参数错误

401 Unauthorized token错误

403 Forbidden referer origin 验证失败

404 Not Found 接口不存在

500 Internal Server Error 服务端错误

502 Bad Gateway 上游接口有问题或者服务器问题

8、nestjs控制器

什么是Controller？

Controllers are responsible for handling incoming requests and returning responses to the client.

A controller's purpose is to receive specific requests for the application. The routing mechanism controls which controller receives which requests. Frequently, each controller has more than one route, and different routes can perform different actions.

In order to create a basic controller, we use classes and decorators. Decorators associate classes with required metadata and enable Nest to create a routing map (tie requests to the corresponding controllers).

Controller Request （获取前端传过来的参数）

nestjs提供了方法参数装饰器，用来帮助我们快速获取参数，如下：

调试工具可以使用postMan、ApiFox 等。

1.获取get请求传参

可以使用Request装饰器或者 Query装饰器，跟express完全一样。

也可以使用Query 直接获取 不需要在通过req.query 了

xxxxxxxxxx
15
1
import { Controller, Get, Post, Body, Patch, Param, Delete, Version, Request, Query } from '@nestjs/common';
2
import { UserService } from './user.service';
3
import { CreateUserDto } from './dto/create-user.dto';
4
import { UpdateUserDto } from './dto/update-user.dto';
5
 
6
@Controller('user')
7
export class UserController {
8
  constructor(private readonly userService: UserService) { }
9
 
10
  @Get()
11
  find(@Query() query) {
12
    console.log(query)
13
    return { code: 200 }
14
  }
15
}

也可以直接读取query里面的某个参数，比如说@Query('name') query，那么此时输出query，就是传递过来的name的值。

2.post 获取参数

可以使用Request装饰器 或者 Body 装饰器 跟express 完全一样

或者直接使用Body 装饰器

也可以直接读取key，写成这种形式@Body('name') body，此时输出body，就是传递过来的name的值。

xxxxxxxxxx
25
1
import { Controller, Get, Post, Body, Patch, Param, Delete, Version, Request, Query } from '@nestjs/common';
2
import { UserService } from './user.service';
3
import { CreateUserDto } from './dto/create-user.dto';
4
import { UpdateUserDto } from './dto/update-user.dto';
5
 
6
@Controller('user')
7
export class UserController {
8
  constructor(private readonly userService: UserService) { }
9
 
10
  @Get()
11
  find(@Query() query) {
12
    console.log(query)
13
    return { code: 200 }
14
  }
15
 
16
  @Post()
17
  create (@Body() body) {
18
     
19
    console.log(body)
20
 
21
    return {
22
       code:200
23
    }
24
  }
25
}

3.动态路由

在请求方法装饰器的参数里面，使用:参数名来接收动态参数，比如说@Get(":id")，接收参数名为id的动态参数。可以使用Request装饰器req.params.id或者Param装饰器param.id来接收参数。

需要注意的是，@Param装饰器没有s，但是req.params.xxxx这里面的params有s。

xxxxxxxxxx
35
1
import { Controller, Get, Post, Body, Patch, Param, Delete, Version, Request, Query } from '@nestjs/common';
2
import { UserService } from './user.service';
3
import { CreateUserDto } from './dto/create-user.dto';
4
import { UpdateUserDto } from './dto/update-user.dto';
5
 
6
@Controller('user')
7
export class UserController {
8
  constructor(private readonly userService: UserService) { }
9
 
10
  @Get()
11
  find(@Query() query) {
12
    console.log(query)
13
    return { code: 200 }
14
  }
15
 
16
  @Post()
17
  create (@Body('name') body) {
18
     
19
    console.log(body)
20
 
21
    return {
22
       code:200
23
    }
24
  }
25
 
26
  @Get(':id')
27
  findId (@Param() param) {
28
     
29
    console.log(param)
30
 
31
    return {
32
       code:200
33
    }
34
  }
35
}

也可以直接读取key，写成@Param('id') param的形式，此时输出param，就是id的值。

4.读取header 信息

我在调试工具随便加了一个cookie

xxxxxxxxxx
35
1
import { Controller, Get, Post, Body, Patch, Param, Delete, Version, Request, Query, Ip, Header, Headers } from '@nestjs/common';
2
import { UserService } from './user.service';
3
import { CreateUserDto } from './dto/create-user.dto';
4
import { UpdateUserDto } from './dto/update-user.dto';
5
 
6
@Controller('user')
7
export class UserController {
8
  constructor(private readonly userService: UserService) { }
9
 
10
  @Get()
11
  find(@Query() query) {
12
    console.log(query)
13
    return { code: 200 }
14
  }
15
 
16
  @Post()
17
  create (@Body('name') body) {
18
     
19
    console.log(body)
20
 
21
    return {
22
       code:200
23
    }
24
  }
25
 
26
  @Get(':id')
27
  findId (@Headers() header) {
28
     
29
    console.log(header)
30
 
31
    return {
32
       code:200
33
    }
34
  }
35
}