前面我们写了很多 Http 服务了，这些服务都是单体架构的。
单体架构就是所有业务逻辑都在一个服务里实现。
这样有个问题：
项目越来越大之后，模块越来越多，代码会越来越难以维护。
并且因为代码都在一个项目里，不好扩展。比如有的业务模块想多部署几个节点就做不到，只能整体扩展。
所以就有了拆分的需求，把业务模块拆成单独的微服务：
拆分也很简单，就是把之前放在不同目录的业务模块放到不同的服务里，再加上通信就好了。
不过微服务和微服务之间一般不是用 http 来通信的。
为什么呢？
因为 http 的请求响应会携带大量的 header：
这些增大了通信的开销。
所以服务和服务之间没必要用 http，直接用 tcp 就好了。
nest 里实现微服务以及之间的 tcp 通信也很简单，下面我们来写一下。
创建个 nest 项目:
nest new microservice-test-main
再创建一个：
nest new microservice-test-user
前面那个作为 http 服务向外提供接口，后面这个是微服务，提供 tcp 的微服务通信端口。
进入 microservice-test-user
安装微服务的包：
npm install @nestjs/microservices --save
然后修改下应用启动方式：
之前这个是启动 http 服务的：
微服务不需要暴露 http 接口，只需要支持微服务的通信就行。
改成这样：
import { NestFactory } from "@nestjs/core";
import { Transport, MicroserviceOptions } from "@nestjs/microservices";
import { AppModule } from "./app.module";
async function bootstrap() {
const app = await NestFactory.createMicroservice<MicroserviceOptions>(
AppModule,
{
transport: Transport.TCP,
options: {
port: 8888,
},
}
);
app.listen();
}
bootstrap();
这就是启动一个微服务，通信端口在 8888，用 TCP 方式通信。
然后暴露个方法出去。
这里暴露接口不再是 http 时的 @Get、@Post 了，而是这样：
@MessagePattern('sum')
sum(numArr: Array<number>): number {
return numArr.reduce((total, item) => total + item, 0);
}
很容易理解，就是消息匹配什么模式，然后调用这个方法，处理参数，返回结果。
我们接收一个数字数组，返回所有数字的和。
这样，我们就创建了一个微服务：
然后在 microservice-test-main 这个服务里连上它。
进入 microservice-test-main
安装微服务相关的包：
npm install @nestjs/microservices --save
然后做什么呢？
很明显，要引入连接微服务的客户端。
在 AppModule 引入 ClientsModule 动态模块：
ClientsModule 的动态模块有 register、registerAsync 方法。
我们之前用过的 JwtModule 也是 register、registerAsync，这是动态模块的方法名规范。（忘记的同学回过头看下动态模块那一节）
import { Module } from "@nestjs/common";
import { AppController } from "./app.controller";
import { AppService } from "./app.service";
import { ClientsModule, Transport } from "@nestjs/microservices";
@Module({
imports: [
ClientsModule.register([
{
name: "USER_SERVICE",
transport: Transport.TCP,
options: {
port: 8888,
},
},
]),
],
controllers: [AppController],
providers: [AppService],
})
export class AppModule {}
这里的 register 参数是一个数组，也就是说你有多个微服务的时候，都依次写在这里就行。
引入了 ClientsModule 模块，就可以注入其中的 provider 来用了。
@Inject('USER_SERVICE')
private userClient: ClientProxy;
@Get('sum')
calc(@Query('num') str) {
const numArr = str.split(',').map((item) => parseInt(item));
return this.userClient.send('sum', numArr);
}
注入的时候指定 token 为前面我们声明的微服务名字：
注入的对象就是连接这个微服务的客户端代理：
调用它的 send 方法，第一个是消息的名字，第二个是参数。
这里的 sum 就是微服务那边声明的这个消息，而参数就是那边声明的参数:
把两个服务都跑起来：
npm run start:dev
微服务那边跑起来的提示是这样的：
http 服务跑起来的提示是这样的：
然后浏览器访问下 http://localhost:3000/sum?num=3,5,6：
返回了 14，是 3 + 5 + 6 的结果。
浏览器把 3、5、6 的参数传递给 http 服务，然后它给微服务发送消息，把参数带过去，微服务计算后返回了 14 给 http 服务，它再返回给浏览器：
前面在微服务里是用 @MessagePattern 声明的要处理的消息。
如果并不需要返回消息的话，可以用 @EventPattern 声明：
比如我们在 microservice-test-user 的 AppController 再添加一个方法：
@EventPattern('log')
log(str: string) {
console.log(str);
}
然后在 microservice-test-main 里调用下：
this.userClient.emit("log", "求和");
注意，如果那边是 @MessagePattern 声明的方法，这边要用 send 方法调用。而 @EventPattern 声明的方法，这边要用 emit 方法调用。
测试下：
可以看到，微服务收到了这边发送的消息，并打印了日志。
那微服务之间具体传输了什么消息呢？我们抓包看一下。
想抓 tcp 层的包需要用到 wireshark。
在 wireshark 官网下载安装包：
安装后把它跑起来：
选择 loopback 这个网卡，本地回环地址，可以抓到 localhost 的包：
输入过滤器 port 8888，也就是过滤 8888 端口的数据包。
然后回车就会进入抓包界面：
这时候再访问下 http://localhost:3000/sum?num=1,2,3
可以看到抓到了几个 tcp 的包：
点开这几个 PSH 的包看一下：
内容如下：
{"pattern": "log", "data": "求和"}
{"pattern": "sum", data: [1, 2, 3], "id": "3b4a92305a76109bf0e79"}
{"response": 6, "isDisposed": true, "id": "3b4a92305a76109bf0e79"}
前两个是主服务发送给微服务的，后面那个是微服务返回的。
从抓包我们可以得出结论：
- 微服务之间的 tcp 通信的消息格式是 json
- 如果是 message 的方式，需要两边各发送一个 tcp 包，也就是一问一答的方式
- 如果是 event 的方式，只需要客户端发送一个 tcp 的包
案例代码在小册仓库：
总结
之前我们一直写的都是单体的 http 服务，这样项目大了以后会难以维护和扩展。
这时候可以通过微服务的方式把业务逻辑拆分到不同的微服务里。
微服务之间通过 tcp 方式通信，在 nest 里需要用到 @nestjs/microservices 这个包。
微服务启动的时候不再调用 NestFactory.create 而是调用 NestFactory.createMicroservice 方法，指定 tcp 的端口。
然后另一个服务里通过 ClientsModule 来注入连接这个微服务的代理对象。
之后分别用 send、emit 方法来调用微服务的 @MessagePattern、@EventPattern 声明的方法。
这就是微服务的创建和通信方式。
我们还通过 wireshark 抓包分析了 tcp 通信的内容，发现微服务之间的通信是基于 json 的。
项目大了之后，为了维护和扩展方便，拆分微服务是很自然的事情。