每天都在重复昨天的不努力？预想很好，可惜很难克服自己的惰性。明日何其多，何其多。

 

@Post方法

import { Controller, Get, Req, Query,Headers, Param, Post, Body } from '@nestjs/common';

@Controller('posts')
export class PostsController {
  @Get()
  index(@Headers() header){
    console.log(header)
    return [{title:'hello ~'}];
  }

  @Get(':id')
  show(@Param() params){
    return{
      title:`Post ${params.id}`
    }
  }

  @Post()
  store(@Body() body){
    console.log(body)
  }
}

dto，通过网络传输的数据

post.dto.ts

export class CreatePostDto{
  readonly title:string;
}

  @Post()
  store(@Body() post:CreatePostDto){
    console.log(post.title)
  }

02.NEST.JS 应用框架：核心部件（1）

强制把nest升级到最新版本

nest update --tag latest --force

中间件！

生成demo中间件

nest generate middleware demo core/middlewares

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

@Injectable()
export class DemoMiddleware implements NestMiddleware {
  use(req: any, res: any, next: () => void) {
    next();
  }
}

 

创建服务，可以注入到控制器中使用。

创建服务

nest generate service demo posts/providers

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

@Injectable()
export class DemoService {}

在app.module.ts中自动添加了DemoService服务。

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { PostsController } from './posts/posts.controller';
import { DemoService } from './posts/providers/demo/demo.service';

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

创建接口

nest generate interface post posts/interfaces

接口里面是定义类型包含的属性，难道是模型类？

 

 

 

export interface Post {
  title:string
}

string是小写。

 

 

 在服务里，鼠标放在上面，选择修复。

import { Injectable } from '@nestjs/common';
import { Post } from 'src/posts/interfaces/post.interface';

@Injectable()
export class DemoService {
  private readonly posts:Post[]=[];

  findAll():Post[]{
    return this.posts;
  }

  create(post:Post){
    this.posts.push(post);
  }
}

在服务里，引用接口，实现模型。在服务里添加模型，和方法。方法返回类型，可以是模型，或者说就是接口。创建新的post，就是往数组接口里push。

在控制器里，把服务作为依赖，注入进来。通过控制器的构造方法实现注入。

import { Controller, Get, Req, Query,Headers, Param, Post, Body } from '@nestjs/common';
import { CreatePostDto } from './post.dto';
import { DemoService } from './providers/demo/demo.service';

@Controller('posts')
export class PostsController {
  private readonly demoService;
  constructor(demoService:DemoService){
    this.demoService=demoService;
  }

  @Get()
  index(){
    return this.demoService.findAll();
  }

  @Get(':id')
  show(@Param() params){
    return{
      title:`Post ${params.id}`
    }
  }

  @Post()
  store(@Body() post:CreatePostDto){
    this.demoService.create(post);
  }
}

什么鬼？？？

dto里定义了类型Post，

export class CreatePostDto{
  readonly title:string;
}

接口里定义了接口Post，

export interface Post {
  title:string
}

服务里用的都是接口Post,

import { Injectable } from '@nestjs/common';
import { Post } from 'src/posts/interfaces/post.interface';

@Injectable()
export class DemoService {
  private readonly posts:Post[]=[];

  findAll():Post[]{
    return this.posts;
  }

  create(post:Post){
    this.posts.push(post);
  }
}

控制器的路由方法里，参数是用的dto的类型Post，执行的方法里是服务方法，参数当然是服务里用的接口Post，有什么区别？

  @Post()
  store(@Body() post:CreatePostDto){
    this.demoService.create(post);
  }
　控制器中的参数是dto定义的类，Post，只读

CreatePostDto就是dto定义的类型Post，为只读。接口类型的Post没有加只读，值是可变的。

  create(post:Post){
    this.posts.push(post);
  }
  服务中定义的方法，参数是接口类型Post

 

 先post提交数据，然后用get方法获取所有数据。