Nestjs gRPC 官方demo详解

src     // 源码目录
├── app.module.ts       // 系统总module文件
├── grpc-client.options.ts      //grpc配置，注意：虽然这里是以client命名的，但是这个是客户端和服务器的配置，也就是说客户端和服务器是一套配置！！！
├── hero        //hero模块代码，此demo是模块化的工程构造。
│   ├── hero.controller.ts      //controller文件，注意：这个文件是http的controller和grpc的controller结合版，里面既有http的路由处理，又有grpc的路由处理
│   ├── hero.module.ts      // 模块注册文件
│   ├── hero.proto      // 用于grpc protobuf协议的proto定义文件，里面是proto3语法
│   └── interfaces      //相关接口文件夹
│       ├── hero-by-id.interface.ts     //相关接口文件
│       └── hero.interface.ts       //相关接口文件
└── main.ts     //程序主入口点击复制复制失败已复制

» yarn start                                                                                                              
yarn run v1.22.4
$ nest start
[Nest] 415470   - 2020-09-21 2:41:05 ├F10: PM┤   [NestFactory] Starting Nest application...
[Nest] 415470   - 2020-09-21 2:41:05 ├F10: PM┤   [InstanceLoader] AppModule dependencies initialized +8ms
[Nest] 415470   - 2020-09-21 2:41:05 ├F10: PM┤   [InstanceLoader] ClientsModule dependencies initialized +0ms
[Nest] 415470   - 2020-09-21 2:41:05 ├F10: PM┤   [InstanceLoader] HeroModule dependencies initialized +0ms
[Nest] 415470   - 2020-09-21 2:41:05 ├F10: PM┤   [NestMicroservice] Nest microservice successfully started +3ms
[Nest] 415470   - 2020-09-21 2:41:05 ├F10: PM┤   [RoutesResolver] HeroController {/hero}: +4ms
[Nest] 415470   - 2020-09-21 2:41:05 ├F10: PM┤   [RouterExplorer] Mapped {/hero, GET} route +1ms
[Nest] 415470   - 2020-09-21 2:41:05 ├F10: PM┤   [RouterExplorer] Mapped {/hero/:id, GET} route +1ms
[Nest] 415470   - 2020-09-21 2:41:05 ├F10: PM┤   [NestApplication] Nest application successfully started +2ms
Application is running on: http://[::1]:3001点击复制复制失败已复制

» curl http://127.0.0.1:3001/hero                                                                   
[{"id":1,"name":"John"},{"id":2,"name":"Doe"}]% 点击复制复制失败已复制

import { NestFactory } from '@nestjs/core';
import { MicroserviceOptions } from '@nestjs/microservices';
import { AppModule } from './app.module';
import { grpcClientOptions } from './grpc-client.options';
async function bootstrap() {
  /**
   * This example contains a hybrid application (HTTP + gRPC)
   * You can switch to a microservice with NestFactory.createMicroservice() as follows:
   *
   * const app = await NestFactory.createMicroservice<MicroserviceOptions>(AppModule, {
   *  transport: Transport.GRPC,
   *  options: {
   *    package: 'hero',
   *    protoPath: join(__dirname, './hero/hero.proto'),
   *  }
   * });
   * await app.listenAsync();
   *
   */
  const app = await NestFactory.create(AppModule);
  app.connectMicroservice<MicroserviceOptions>(grpcClientOptions);
  await app.startAllMicroservicesAsync();
  await app.listen(3001);
  console.log( `Application is running on: c194a9eg<!-- begin-inline-katex{await app.getUrl()}` );
}
bootstrap();
点击复制复制失败已复制

const app = await NestFactory.createMicroservice<MicroserviceOptions>(AppModule, {
    transport: Transport.GRPC,
    options: {
        package: 'hero',
        protoPath: join(__dirname, './hero/hero.proto'),
    }
});
await app.listenAsync();点击复制复制失败已复制

const app = await NestFactory.createMicroservice<MicroserviceOptions>(AppModule, {
    transport: Transport.GRPC,
    options: {
        url: `end-inline-katex-->{process.env.COMMON_BIND}:c194a9eg<!-- begin-inline-katex{process.env.COMMON_PORT}` ,
        package: "iot.log",
        protoPath: join(__dirname, './app.proto'),
    },
});
app.useGlobalFilters(new GrpcExceptionsFilter());
await app.listenAsync();点击复制复制失败已复制

import { ClientOptions, Transport } from '@nestjs/microservices';
import { join } from 'path';
export const grpcClientOptions: ClientOptions = {
  transport: Transport.GRPC,
  options: {
    package: 'hero', // ['hero', 'hero2']
    protoPath: join(__dirname, './hero/hero.proto'), // ['./hero/hero.proto', './hero/hero2.proto']
  },
};点击复制复制失败已复制

syntax = "proto3";
package hero;
service HeroService {
  rpc FindOne (HeroById) returns (Hero);
  rpc FindMany (stream HeroById) returns (stream Hero);
}
message HeroById {
  int32 id = 1;
}
message Hero {
  int32 id = 1;
  string name = 2;
}点击复制复制失败已复制

import { Module } from '@nestjs/common';
import { ClientsModule } from '@nestjs/microservices';
import { grpcClientOptions } from '../grpc-client.options';
import { HeroController } from './hero.controller';
@Module({
  imports: [
    ClientsModule.register([
      {
        name: 'HERO_PACKAGE',
        ...grpcClientOptions,
      },
    ]),
  ],
  controllers: [HeroController],
})
export class HeroModule {}点击复制复制失败已复制

import { Controller, Get, Inject, OnModuleInit, Param } from '@nestjs/common';
import {
  ClientGrpc,
  GrpcMethod,
  GrpcStreamMethod,
} from '@nestjs/microservices';
import { Observable, ReplaySubject, Subject } from 'rxjs';
import { toArray } from 'rxjs/operators';
import { HeroById } from './interfaces/hero-by-id.interface';
import { Hero } from './interfaces/hero.interface';
interface HeroService {
  findOne(data: HeroById): Observable<Hero>;
  findMany(upstream: Observable<HeroById>): Observable<Hero>;
}
@Controller('hero')
export class HeroController implements OnModuleInit {
  private readonly items: Hero[] = [
    { id: 1, name: 'John' },
    { id: 2, name: 'Doe' },
  ];
  private heroService: HeroService;
  constructor(@Inject('HERO_PACKAGE') private readonly client: ClientGrpc) {}
  onModuleInit() {
    this.heroService = this.client.getService<HeroService>('HeroService');
  }
  @Get()
  getMany(): Observable<Hero[]> {
    const ids$ = new ReplaySubject<HeroById>();
    ids$.next({ id: 1 });
    ids$.next({ id: 2 });
    ids$.complete();
    const stream = this.heroService.findMany(ids$.asObservable());
    return stream.pipe(toArray());
  }
  @Get(':id')
  getById(@Param('id') id: string): Observable<Hero> {
    return this.heroService.findOne({ id: +id });
  }
  @GrpcMethod('HeroService')
  findOne(data: HeroById): Hero {
    return this.items.find(({ id }) => id === data.id);
  }
  @GrpcStreamMethod('HeroService')
  findMany(data$: Observable<HeroById>): Observable<Hero> {
    const hero$ = new Subject<Hero>();
    const onNext = (heroById: HeroById) => {
      const item = this.items.find(({ id }) => id === heroById.id);
      hero$.next(item);
    };
    const onComplete = () => hero$.complete();
    data$.subscribe(onNext, null, onComplete);
    return hero$.asObservable();
  }
}点击复制复制失败已复制