我们实现过登录和身份认证，登录的时候基于用户名密码，后续基于 jwt。

像这种身份认证逻辑其实很通用，每个项目都会有，自然可以抽取成一个库。

先不看第三方库是怎么做的，思考下，如果让你做一个身份认证的库，你会怎么设计呢？

首先，身份认证有多种方式，比如用户名密码、jwt、google 登录、github 登录等。

这多种方式都可以实现身份认证，那我们就可以用策略模式把它们封装成一个个策略类（Strategy）。

简单看下策略模式的介绍：

其实它就是实现了一个接口的多个类，这些类可以相互替换。

这里我们就可以用策略模式来做。

然后每个策略类里封装什么呢？

其实不同的认证方式虽然逻辑不同，但做的事情很类似：

• 用户名密码登录就是从 request 的 body 里取出 username、password 来认证。
• jwt 是从 request 的 Authorization 的 header 取出 token 来认证。

不同策略都会从 request 中取出一些东西来认证，如果认证就在 request.user 上存放认证后的 user 信息，这就是它们的共同点。

比如身份认证库 passport 的两种策略：

可以看到，不管是用户名密码的身份认证，还是 jwt 的身份认证，都会从 request 的 body 或者 header 中取出一些信息来，然后认证通过之后返回 user 的信息，passport 会设置到 request.user 上。

这个封装思路你理解了，那 passport 这个库也就差不多掌握了。

然后我们在 nest 里用一下 passport 这个库：

nest new nest-passport

进入项目，安装 passport：

npm install --save @nestjs/passport passport

然后我们首先实现用户名密码的认证。

这用到 passport-local 的策略，安装下：

npm install --save passport-local
npm install --save-dev @types/passport-local

然后创建一个认证模块：

nest g module auth
nest g service auth --no-spec

添加用户名密码认证的策略：

import { Strategy } from 'passport-local';
import { PassportStrategy } from '@nestjs/passport';
import { Injectable, UnauthorizedException } from '@nestjs/common';
import { AuthService } from './auth.service';

@Injectable()
export class LocalStrategy extends PassportStrategy(Strategy) {
  constructor(private authService: AuthService) {
    super();
  }

  async validate(username: string, password: string) {
    const user = await this.authService.validateUser(username, password);
    return user;
  }
}

在 AuthModule 引入下：

这个 LocalStrategy 的逻辑就像前面分析的：

从 reqeust 的 body 中取出 username 和 password 交给你去认证，认证过了之后返回 user，它会把 user 放到 request.user 上，如果认证不通过，就抛异常，由 exception filter 处理。

我们在 AuthService 里实现这个 validateUser 方法：

import { Inject, Injectable, UnauthorizedException } from '@nestjs/common';
import { UserService } from 'src/user/user.service';

@Injectable()
export class AuthService {

    @Inject()
    private userService: UserService;

    async validateUser(username: string, pass: string) {
        const user = await this.userService.findOne(username);

        if(!user) {
            throw new UnauthorizedException('用户不存在');
        }
        if(user.password !== pass) {
            throw new UnauthorizedException('密码错误');
        }

        const { password, ...result } = user;
        return result;
    }
}

AuthService 里根据用户名密码去校验，但是查询用户的逻辑应该在 UserModule 里，我们写一下：

nest g module user
nest g service user --no-spec

UserService：

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

@Injectable()
export class UserService {
    private readonly users = [
        {
            userId: 1,
            username: '神说要有光',
            password: 'guang',
        },
        {
            userId: 2,
            username: '东东东',
            password: 'dong',
        },
    ];

    async findOne(username: string) {
        return this.users.find(user => user.username === username);
    }
}

在 UserModule 里导出 UserService：

然后在 AuthModule 里引入下：

这样，passport 的流程就完成了，它会从 request 中取出 body 的 username 和 password 交给我们的 validate 方法去认证，认证完会返回 user 信息，放到 request.user 上。

那怎么应用这个策略呢？

很明显，这里适合用 Guard。

@nestjs/passport 已经做了封装了。

我们在 AppController 里加个 login 方法：

import { Controller, Get, Post, Req, UseGuards } from '@nestjs/common';
import { AppService } from './app.service';
import { AuthGuard } from '@nestjs/passport';
import { Request } from 'express';

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  @UseGuards(AuthGuard('local'))
  @Post('login')
  async login(@Req() req: Request) {
    console.log(req.user);
    return req.user;
  }

  @Get()
  getHello(): string {
    return this.appService.getHello();
  }
}

把服务跑起来：

npm run start:dev

postman 里测试下：

这样，基于 passport 的登录就完成了。

不用我们自己从 request 取 body 中的 username 和 password，也不用我们把查询结果放到 request.user 上，更不用自己实现 Guard。

确实减少了不少代码。

接下来继续做 JWT 的认证：

登录的时候通过用户名、密码认证，这时候登录认证成功会返回 jwt，然后再次访问会在 Authorization 的 header 携带 jwt，然后通过 header 的 jwt 来认证。

这是一种新的认证方式，需要用新的策略。

我们首先在登录成功之后返回 jwt。

安装用到的包：

npm install --save @nestjs/jwt

在 AppModule 里引入下：

JwtModule.register({
    secret: "guang"
}),

然后在 AppController 里 login 接口返回 jwt 的 token：

这里需要扩展下 express 的 request.user 的类型。

import { Controller, Get, Inject, Post, Req, UseGuards } from '@nestjs/common';
import { AppService } from './app.service';
import { AuthGuard } from '@nestjs/passport';
import { Request } from 'express';
import { JwtService } from '@nestjs/jwt';

interface JwtUserData {
  userId: number;
  username: string;
}

declare module 'express' {
  interface Request {
    user: JwtUserData
  }
}

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Inject()
  jwtService: JwtService;

  @UseGuards(AuthGuard('local'))
  @Post('login')
  async login(@Req() req: Request) {
    console.log(req.user);
    const token = this.jwtService.sign({
      userId: req.user.userId,
      username: req.user.username
    }, {
      expiresIn: '0.5h'
    });

    return {
      token
    }
  }

  @Get()
  getHello(): string {
    return this.appService.getHello();
  }
}

试一下：

这样，登录之后返回 jwt 就完成了。

然后添加 jwt.strategy.ts

import { ExtractJwt, Strategy } from 'passport-jwt';
import { PassportStrategy } from '@nestjs/passport';
import { Injectable } from '@nestjs/common';

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
  constructor() {
    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
      ignoreExpiration: false,
      secretOrKey: 'guang',
    });
  }

  async validate(payload: any) {
    return { userId: payload.userId, username: payload.username };
  }
}

指定从 request 的 header 里提取 token，然后取出 payload 之后会传入 validate 方法做验证，返回的值同样会设置到 request.user。

安装用到的包：

npm install --save passport-jwt
npm install --save-dev @types/passport-jwt

在 AuthModule 引入下：

在 AppController 里添加一个新的需要登录认证的接口：

@UseGuards(AuthGuard('jwt'))
@Get("list")
list(@Req() req: Request) {
    console.log(req.user);
    return ['111', '222', '333', '444', '555']
}

首先不带 token 访问下：

然后通过 Authorization 的 header 带上 Bearer xxx 的 token 访问下：

可以看到，jwt 的认证生效了。

对比下用 passport 和不用有啥区别呢？

不用我们自己从 request 的 header 里取 token 了，也不用自己从 token 提取的信息放到 request.user 里了，也不用自己写 Guard 了。

确实方便了很多。

这样，我们就用了两个 local 和 jwt 两个策略了。

其他策略也是类似的流程，从 request 取一些信息，交给 validate 方法去验证，返回 user 放到 request.user 里。

那如果我想对 Guard 的流程做一些扩展呢？

比如 jwt 的 Guard，现在需要在每个 controller 上手动应用，我想通过一个 @IsPublic 的装饰器来标识，如果有 @IsPublic 的装饰器就不需要身份认证，否则就需要。

这就需要继承 AuthGuard('jwt') 做一些扩展了：

首先，生成一个自定义装饰器：

nest g decorator is-public --flat --no-spec

它的实现就是给被装饰对象添加一个 metadata：

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

export const IS_PUBLIC_KEY = 'isPublic';
export const IsPublic = () => SetMetadata(IS_PUBLIC_KEY, true);

然后在 AppController 里加几个路由：

@IsPublic()
@Get('aaa')
aaa() {
    return 'aaa';
}

@Get('bbb')
bbb() {
    return 'bbb';
}

aaa 是 public 的，不需要身份认证，而 bbb 需要。

这时就需要对 AuthGuard('jwt') 做下扩展。

新建 auth/JwtAuthGuard.ts

import { ExecutionContext, Injectable } from "@nestjs/common";
import { Reflector } from "@nestjs/core";
import { AuthGuard } from "@nestjs/passport";
import { IS_PUBLIC_KEY } from "src/is-public.decorator";

@Injectable()
export class JwtAuthGuard extends AuthGuard('jwt') {
  constructor(private reflector: Reflector) {
    super();
  }

  canActivate(context: ExecutionContext) {
    const isPublic = this.reflector.getAllAndOverride<boolean>(IS_PUBLIC_KEY, [
      context.getHandler(),
      context.getClass(),
    ]);

    if (isPublic) {
      return true;
    }
    return super.canActivate(context);
  }
}

实现就是从目标 controller、handler 上取 public 的 meatadata，如果有就直接放行，否则才做认证。

然后在 AppModule 里注册为全局 Guard：

{
    provide: APP_GUARD,
    useClass: JwtAuthGuard
}

测试下：

没啥问题，这样，对 AuthGuard('jwt') 的扩展就完成了。

案例代码上传了小册仓库

总结

之前我们都是自己实现身份认证，比如基于用户名密码的认证，基于 jwt 的认证，今天我们基于 passport 库来实现了一遍。

passport 把不同的认证逻辑封装成了不同 Strategy，每个 Stategy 都有 validate 方法来验证。

每个 Strategy 都是从 request 取出一些东西，交给 validate 方法验证，validate 方法返回 user 信息，自动放到 request.user 上。

并且 @nestjs/passport 提供了 Guard 可以直接用，如果你想扩展，继承 AuthGuard('xxx') 然后重写下 canActivate 方法就好了。

细想一下，你做各种认证的时候，是不是也在做同样的事情呢？

那既然每次都是做这些事情，那为啥不用 passport 库来简化呢？