Node 系列（一）使用 Midway 创建第一个应用

2022-05-09

字数统计: 1.6k字 | 阅读时长≈ 7分

前言

此文章为 Node 系列文章，会涵盖基于 Jwt 的登录鉴权、数据持久化、缓存中间件、多环境构建、 Docker 部署。

介绍

Midway 是阿里巴巴 - 淘宝前端架构团队，基于渐进式理念研发的 Node.js 框架。

Midway 基于 TypeScript 开发，结合了面向对象（OOP + Class + IoC）与函数式（FP + Function + Hooks）两种编程范式，并在此之上支持了 Web / 全栈 / 微服务 / RPC / Socket / Serverless 等多种场景，致力于为用户提供简单、易用、可靠的 Node.js 服务端研发体验。

快速初始化

使用 npm init midway 命令，快速初始化一个应用，Midway 会自动创建示例目录，代码以及安装依赖

1	$ npm init midway

针对 V3 项目，请选择 koa-v3
创建完成之后，将会得到一个类似下面这样的目录结构

.
├── src                            ## midway 项目源码
│   └── controller                 ## Web Controller 目录
│       └── user.controller.ts
│   └── middleware                 ## 中间件目录
│       └── user.middleware.ts
│   └── service                    ## 服务逻辑目录
│       └── user.service.ts
├── test
├── package.json
└── tsconfig.json

目录说明：

src Midway 项目的源码目录，之后所有的开发源码都放在该目录下
test 项目的测试目录，之后所有的代码测试文件都放在这里
package.json Node 项目基础的包管理配置文件
tsconfig.json TypeScript 编译配置文件

至此，一个简单的 Midway 项目就创建成功了。

启动项目

1 2	$ npm run dev $ open http://localhost:7001

Midway 会启动 HTTP 服务，打开访问，浏览器就会出现 Hello midwayjs! 的信息。之后写完接口之后，可以使用 Paw 软件进行调试。
如果需要修改端口号，可以 package.json 文件中进行修改，如下：

1
2
3

"scripts": {
    "dev": "cross-env NODE_ENV=local midway-bin dev --ts --port=8000",
  },

项目启动之后，我们可以先简单的写一个登录鉴权的接口试试手（目前先不涉及到库，后续会逐步添加进来）
在登录鉴权之前，我们可以先把日志加上，方便开发以及调试

日志

我们项目在初始化的时候，已经默认安装了 @midwayjs/logger 依赖，所以我们只需要引入使用就可以了。

import { Inject, Controller, Get } from '@midwayjs/decorator';
import { ILogger } from '@midwayjs/logger';

@Controller('/api')
export class APIController {
  @Inject()
  logger: ILogger;
  
  @Get('/test')
  async getUser(){
    this.logger.info('日志信息输出');
  }
}

这样，简单的日志就完成了。日志的其他方法以及格式，可以参考【日志】这个地址，这里就不过多去描述了。

登录鉴权

这里，我们可以使用 Jwt 策略。

Jwt 策略原理

Jwt 的原理是，在服务器认证通过后，将数据保存到一个 JSON 对象中，然后生成一个字符串 TOKEN ，返回给用户。用户在请求的时候，头部携带这个 TOKEN ，服务器就可以解析出来前面保存的 JSON 对象，然后识别用户的身份。

额外安装依赖和策略

1	$ npm i @midwayjs/jwt passport-jwt --save

然后在配置中设置

// src/config/config.default.ts
export default {
  // ...
  jwt: {
    secret: 'xxxxxxxxxxxxxx', // fs.readFileSync('xxxxx.key')
    expiresIn: '2d'   // 有效期
  },
}

// src/strategy/jwt.strategy.ts

import { CustomStrategy, PassportStrategy } from '@midwayjs/passport';
import { Strategy, ExtractJwt } from 'passport-jwt';
import { Config } from '@midwayjs/decorator';

@CustomStrategy()
export class JwtStrategy extends PassportStrategy(
  Strategy,
  'jwt'
) {
  @Config('jwt')
  jwtConfig;

  async validate(payload) {
    return payload;
  }

  getStrategyOptions(): any {
    return {
      secretOrKey: this.jwtConfig.secret,
      jwtFromRequest: ExtractJwt.fromHeader('token'),
    };
  }
}

// src/middleware/jwt.middleware.ts

import { Middleware } from '@midwayjs/decorator';
import { PassportMiddleware } from '@midwayjs/passport';
import { JwtStrategy } from '../strategy/jwt-strategy';
import * as passport from 'passport';
import { Context } from '@midwayjs/koa';

@Middleware()
export class JwtPassportMiddleware extends PassportMiddleware(JwtStrategy) {
  // 由于登录鉴权，是要放到全局中间件的，并且登录接口是不可以走鉴权的，所以此处使用 ignore 添加路由忽略的逻辑
  ignore(ctx: Context): boolean {
    return ctx.path === '/user/login';
  }
  getAuthenticateOptions(): Promise<passport.AuthenticateOptions> | passport.AuthenticateOptions {
    return {};
  }
}

由于登录鉴权，需要涉及到的接口会很多，所以我们可以把这个放到全局中间件。所谓全局中间件就是对所有路由生效的 Web 中间件。
我们需要在项目启动前，加入到中间件列表中， useMiddleware 可以把中间件加入到中间件列表。

// src/configuration.ts
import { JwtPassportMiddleware } from './middleware/jwt.middleware';

export class ContainerLifeCycle {
  @App()
  app: koa.Application;

  async onReady() {
    // add middleware
    this.app.useMiddleware([ReportMiddleware, JwtPassportMiddleware]);
  }
}

另外，一般接口返回的格式都是需要统一格式的数据，数据会包括 code 、msg、data，三部分，所以我们可以封装一个统一的数据格式。
首先，我们通过 class 来定义一个泛型类 ResultRtn ，我们在类里定义一个静态方法，把数据按照需要的格式 return。
为了简化一下参数，我们又额外定义了 2 个静态方法， ofSuccess 和 ofError 。

// src/constent/resultRtn.ts
export class ResultRtn<T> {
  public code: number;
  public msg: string;
  public data: T;

  static of<T>(code: number, msg: string, data: T): ResultRtn<T> {
    const result = new ResultRtn<T>();
    result.code = code;
    result.msg = msg;
    result.data = data;
    return result;
  }

  static ofSuccess<T>(data: T): ResultRtn<T> {
    return this.of(200, '操作成功', data);
  }
  
  static ofError<T>(data: T): ResultRtn<T> {
    return this.of(500, '服务异常', data);
  }
}

在 controller 中使用方式如下：

import { Inject, Controller, Get, Body, Post } from '@midwayjs/decorator';
import { Context } from '@midwayjs/koa';
import { JwtService } from '@midwayjs/jwt';
import { User } from '../interface';
import { ResultRtn } from '../constent/result';
import { ILogger } from '@midwayjs/logger';

@Controller('/user')
export class APIController {
  @Inject()
  jwt: JwtService;
  @Inject()
  logger: ILogger;
  @Inject()
  ctx: Context;

  // 此路由为登录，传入用户名和密码之后，会返回用户一个 TOKEN 。
  // @Body() 为接收 body 部分传过来的参数
  // @Body() user: User ：此处我们需要获取整个 body 的数据，而且数据格式需要我们统一定义，
  // 所以我们在 interface.ts 中定义了 User，这里只要引入 User 就可以了。
  /*
  // interface.ts
  
  export interface User {
    name: string;
    password: string;
  }
  */
  @Post('/login')
  async getUser(@Body() user: User): Promise<ResultRtn<string>> {
    // user 等价于 ctx.request.body 整个 body 对象
    const token = await this.jwt.sign({
      username: user.name,
      password: user.password,
    });
    this.logger.info('token:[%s]', token);
    return ResultRtn.ofSuccess(token);
  }

  @Get('/test')
  async getTest(): Promise<ResultRtn<object>> {
    const list = [1, 2, 3, 4];
    return ResultRtn.ofSuccess(list);
  }
}

启动 MySQL 参考下一篇文章：【Node 系列（二）启动 MySQL】

本文作者： Gladysdrea
本文链接： https://gladysdrea.github.io/blogs/2022/05/09/Node系列/Node系列(一)使用Midway创建第一个应用/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！