ACL是直接给用户分配权限：
比如用户1有权限A、B、C，用户二有权限A，用户3有权限A、B。
这种记录每个用户有什么权限的方式,叫做访问控制表 (Access control List);
用户和权限是多对多的关系，存储这种关系需要用户表、角色表、用户-角色的中间表。
我们来实践一下：
在数据库中创建acl_test的数据库:
CREATE DATABASE acl_test DEFAULT CHARACTER SET utf8mb4;
然后再创建一个nest项目:
nest new acl-test -p npm
再新建的项目里安装typeorm：
npm install --save @nestjs/typeorm typeorm mysql2
在appModule中引入TypeOrmModule:
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AppController } from './app.controller';
import { AppService } from './app.service';
@Module({
imports: [
TypeOrmModule.forRoot({
type: "mysql",
host: "localhost",
port: 3306,
username: "root",
password: "root",
database: "acl_test",
synchronize: true,
logging: true,
entities: [],
poolSize: 10,
connectorPackage: 'mysql2',
extra: {
authPlugin: 'sha256_password',
}
}),
],
controllers: [AppController],
providers: [AppService],
})
export class AppModule {}
然后创建一个名为user的模块：
nest g resource user
添加User和Permission的Entity:
user.entity.ts:
import { Column, CreateDateColumn, Entity, PrimaryGeneratedColumn, UpdateDateColumn } from "typeorm";
@Entity()
export class User {
@PrimaryGeneratedColumn()
id: number;
@Column({
length: 50
})
username: string;
@Column({
length: 50
})
password: string;
@CreateDateColumn()
createTime: Date;
@UpdateDateColumn()
updateTime: Date;
}
permission.entity.ts:
import { Column, CreateDateColumn, Entity, PrimaryGeneratedColumn, UpdateDateColumn } from "typeorm";
@Entity()
export class Permission {
@PrimaryGeneratedColumn()
id: number;
@Column({
length: 50
})
name: string;
@Column({
length: 100,
nullable: true
})
desc: string;
@CreateDateColumn()
createTime: Date;
@UpdateDateColumn()
updateTime: Date;
}
然后在User里加入和Permission的关系，也就是多对多：
@ManyToMany(() => Permission)
@JoinTable({
name: 'user_permission_relation'
})
permissions: Permission[]
通过@ManyToMany声明和Permission的多对多关系
多对多是需要通过中间表来维护的，通过@JoinTable声明，指定中间表的名字
然后再TypeOrm.forRoot的entities数组中加入这俩entity:
然后把nest服务跑起来试试：
npm run start:dev
可以看到正确生成了三个表：
user_permission_relation表中也生成了userId、permissionId这两个外键。并且中间表的两个外键也都是主表删除或者更新时，从表级联删除或者更新。
然后我们插入一些数据，不用 sql 插入，而是用 TypeORM 的 api 来插入：
修改下 UserService，添加这部分代码：
@InjectEntityManager()
entityManager: EntityManager;
async initData() {
const permission1 = new Permission();
permission1.name = 'create_aaa';
permission1.desc = '新增 aaa';
const permission2 = new Permission();
permission2.name = 'update_aaa';
permission2.desc = '修改 aaa';
const permission3 = new Permission();
permission3.name = 'remove_aaa';
permission3.desc = '删除 aaa';
const permission4 = new Permission();
permission4.name = 'query_aaa';
permission4.desc = '查询 aaa';
const permission5 = new Permission();
permission5.name = 'create_bbb';
permission5.desc = '新增 bbb';
const permission6 = new Permission();
permission6.name = 'update_bbb';
permission6.desc = '修改 bbb';
const permission7 = new Permission();
permission7.name = 'remove_bbb';
permission7.desc = '删除 bbb';
const permission8 = new Permission();
permission8.name = 'query_bbb';
permission8.desc = '查询 bbb';
const user1 = new User();
user1.username = '东东';
user1.password = 'aaaaaa';
user1.permissions = [
permission1, permission2, permission3, permission4
]
const user2 = new User();
user2.username = '光光';
user2.password = 'bbbbbb';
user2.permissions = [
permission5, permission6, permission7, permission8
]
await this.entityManager.save([
permission1,
permission2,
permission3,
permission4,
permission5,
permission6,
permission7,
permission8
])
await this.entityManager.save([
user1,
user2
]);
}
注入EntityManager，实现权限和用户的保存。
aaa增删改查、bbb增删改查、一共8个权限
user1 有 aaa 的 4 个权限，user2 有 bbbb 的 4 个权限。
调用 entityManager.save 来保存。
然后改一下userController：
@Get('init')
async initData() {
await this.userService.initData();
return 'done'
}
然后访问一下/user/init的路由：
permission表中插入了数据：
user表中插入了数据:
user_permission_relation表中也正确的插入了数据：
然后我们来实现登录相关的接口，这次通过session+cookie的方式：
安装session相关的包：
npm install express-session @types/express-session
在main.ts中使用这个中间件:
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import * as session from 'express-session';
async function bootstrap() {
const app = await NestFactory.create(AppModule);
app.use(session({
secret: 'guang',
resave: false,
saveUninitialized: false
}));
await app.listen(3000);
}
bootstrap();
secret 是加密 cookie 的密钥。
resave 是 session 没变的时候要不要重新生成 cookie。
saveUninitialized 是没登录要不要也创建一个 session。
然后在 UserController 添加一个 /user/login 的路由：
@Post('login')
login(@Body() loginUser: LoginUserDto, @Session() session){
console.log(loginUser)
return 'success'
}
然后去创建dto对象:
export class LoginUserDto {
username: string;
password: string;
}
安装参数验证需要的包:
npm install --save class-validator class-transformer
然后给 dto 对象添加 class-validator 的装饰器：
import { IsNotEmpty, Length } from "class-validator";
export class LoginUserDto {
@IsNotEmpty()
@Length(1, 50)
username: string;
@IsNotEmpty()
@Length(1, 50)
password: string;
}
然后全局启用ValidationPipe:
然后在UserService中实现一下login方法：
async login(loginUserDto: LoginUserDto) {
//去数据库里根据用户名查询
const user = await this.entityManager.findOneBy(User, {
username: loginUserDto.username,
});
//如果在数据库中没有查询到数据
if (!user) {
throw new HttpException('用户不存在', HttpStatus.ACCEPTED);
}
//如果查询到了 但是密码不对
if (user.password !== loginUserDto.password) {
throw new HttpException('密码错误', HttpStatus.ACCEPTED);
}
return user;
}
然后改一下UserController的login方法：
@Post('login')
async login(@Body() loginUser: LoginUserDto, @Session() session) {
const user = await this.userService.login(loginUser);
session.user = {
username: user.username,
};
return 'success';
}
测试一下，session已经返回了：
登录成功之后会返回cookie,之后只要带上这个cookie就可以查询到服务端的对应的session，从而取出user信息。
然后添加aaa，bbb两个模块，分别生成CRUD方法：
nest g resource aaa
nest g resource bbb
然后重新启动一下，/aaa和/bbb已经可以访问了。
而实际上这些接口是要被控制权限访问的
用户东东有aaa的增删改查权限，而用户光光拥有bbb的增删改查权限。
所以要对接口的调用做限制。
先添加一个LoginGuard，限制只有登录状态才可以访问这些接口：
nest g guard login --no-spec --flat
然后增加登录状态的检查：
import {
CanActivate,
ExecutionContext,
Injectable,
UnauthorizedException,
} from '@nestjs/common';
import { Observable } from 'rxjs';
import { Request } from 'express';
//默认session里没有user的类型，所以需要扩展一下 利用同名 interface 会自动合并的特点来扩展 Session。
declare module 'express-session' {
interface Session {
user: { username: string };
}
}
@Injectable()
export class LoginGuard implements CanActivate {
canActivate(
context: ExecutionContext,
): boolean | Promise<boolean> | Observable<boolean> {
const request: Request = context.switchToHttp().getRequest();
//从请求中去拿user,如果拿不到则表示未登录
if (!request.session?.user) {
throw new UnauthorizedException('用户未登录');
}
return true;
}
}
然后给aaa和bbb接口都加上这个登录Guard:
再访问一下，就可以抛出未登录的异常：
带上之前登录返回的cookie，就可以正常访问aaa或者bbb的接口了。
光有登录鉴权还不够，我们还需要做当前登录用户的权限控制，所以需要再写一个PermissionGuard：
nest g guard permission --no-spec --flat
因为 PermissionGuard 里需要用到 UserService 来查询数据库，所以把它移动到 UserModule 里。
在PermissionGuard注入一下UserService
import { CanActivate, ExecutionContext, Inject, Injectable } from '@nestjs/common';
import { Request } from 'express';
import { Observable } from 'rxjs';
import { UserService } from './user.service';
@Injectable()
export class PermissionGuard implements CanActivate {
@Inject(UserService)
private userService: UserService;
canActivate(
context: ExecutionContext,
): boolean | Promise<boolean> | Observable<boolean> {
console.log(this.userService);
return true;
}
}
在UserModule的provides、exports里添加UserService和PermissionGuard:
import { Module, UseGuards } from '@nestjs/common';
import { UserService } from './user.service';
import { UserController } from './user.controller';
import { PermissionGuard } from './permission.guard';
@Module({
controllers: [UserController],
providers: [UserService, PermissionGuard],
exports: [UserService, PermissionGuard]
})
export class UserModule {}
这样就可以在 PermissionGuard 里注入 UserService 了。
然后再Aaamodule中引入这个UserModule:
然后就可以在/aaa的handler里添加PermissionGuard:
使用apiFox访问一下：
首先重新登录，post方法请求/user/login，然后带上cookie使用get请求一下/aaa接口，打印出来了UserService,说明PermissionGuard里成功注入UserService。
然后来实现权限检查的逻辑，在UserService里添加一个方法：
async findByUsername(username: string) {
const user = await this.entityManager.findOne(User, {
where: {
username,
},
relations: {
permissions: true
}
});
return user;
}
根据用户名查找用户，并且查询出关联的权限来：
在 PermissionGuard 里调用下：
import {
CanActivate,
ExecutionContext,
Injectable,
Inject,
UnauthorizedException,
} from '@nestjs/common';
import { UserService } from './user.service';
import { Request } from 'express';
@Injectable()
export class PermissionGuard implements CanActivate {
@Inject(UserService)
private userService: UserService;
async canActivate(context: ExecutionContext): Promise<boolean> {
const request: Request = context.switchToHttp().getRequest();
const user = request.session.user;
if (!user) {
throw new UnauthorizedException('用户未登录');
}
const foundUser = await this.userService.findByUsername(user.username);
console.log(foundUser);
return true;
}
}
打印下查找到登录用户的信息。
我们是试试看：
先登录,拿到cookie,然后去访问/aaa：
然后我们就根据当前handler需要的权限来判断是否返回true就可以了。
那怎么给当前handler标记需要什么权限呢？
很明显是通过metadata:
给/aaa接口声明需要query_aaa的权限.
然后再PermissionGuard里通过reflector取出来：
取出 handler 声明的 metadata，如果用户权限里包含需要的权限，就返回 true，否则抛出没有权限的异常。
我们试一下，这次用光光的账号：
可以看到，光光并没有访问/aaa接口的权限：
apifox返回了:
然后登录东东的账号，可以正确访问/aaa：
东东是有query_aaa的权限的。
这样就通过ACL的方式完成了接口权限的控制。
但是每次访问接口，都会触发三个表的关联查询，效率很低，那该如何优化呢？
可以把权限放入redis中，使用redis的缓存来做这种优化:
我们引入下redis:
npm install redis
然后创建一个模块来封装redis操作:
nest g module redis
然后新建一个 service：
nest g service redis --no-spec
然后在 RedisModule 里添加 redis 的 provider：
import { Global, Module } from '@nestjs/common';
import { createClient } from 'redis';
import { RedisService } from './redis.service';
@Global()
@Module({
providers: [RedisService,
{
provide: 'REDIS_CLIENT',
async useFactory() {
const client = createClient({
socket: {
host: 'localhost',
port: 6379
}
});
await client.connect();
return client;
}
}
],
exports: [RedisService]
})
export class RedisModule {}
并使用 @Global 把这个模块声明为全局的。
这样，各个模块就都可以注入这个 RedisService 了。
然后在 RedisService 里添加一些 redis 操作方法：
import { Inject, Injectable } from '@nestjs/common';
import { RedisClientType } from 'redis';
@Injectable()
export class RedisService {
@Inject('REDIS_CLIENT')
private redisClient: RedisClientType
async listGet(key: string) {
return await this.redisClient.lRange(key, 0, -1);
}
async listSet(key: string, list: Array<string>, ttl?: number) {
for(let i = 0; i < list.length;i++) {
await this.redisClient.lPush(key, list[i]);
}
if(ttl) {
await this.redisClient.expire(key, ttl);
}
}
}
注入 redisClient，封装 listGet 和 listSet 方法，listSet 方法支持传入过期时间。
底层用的命令是 lrange 和 lpush、exprire。
然后在 PermissionGuard 里注入来用下：
先查询redis,没有再去查数据库并保存到redis,有的话直接用redis的缓存结果。
key 为 user_${username}_permissions，这里的 username 是唯一的。
缓存过期时间为 30 分钟。
import { RedisService } from './../redis/redis.service';
import { CanActivate, ExecutionContext, Inject, Injectable, UnauthorizedException } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { Request } from 'express';
import { Observable } from 'rxjs';
import { UserService } from './user.service';
@Injectable()
export class PermissionGuard implements CanActivate {
@Inject(UserService)
private userService: UserService;
@Inject(Reflector)
private reflector: Reflector;
@Inject(RedisService)
private redisService: RedisService;
async canActivate(
context: ExecutionContext,
): Promise<boolean> {
const request: Request = context.switchToHttp().getRequest();
const user = request.session.user;
if(!user) {
throw new UnauthorizedException('用户未登录');
}
let permissions = await this.redisService.listGet(`user_${user.username}_permissions`);
if(permissions.length === 0) {
const foundUser = await this.userService.findByUsername(user.username);
permissions = foundUser.permissions.map(item => item.name);
this.redisService.listSet(`user_${user.username}_permissions`, permissions, 60 * 30)
}
const permission = this.reflector.get('permission', context.getHandler());
if(permissions.some(item => item === permission)) {
return true;
} else {
throw new UnauthorizedException('没有权限访问该接口');
}
}
}
再走一遍登录流程，访问一下/aaa接口，可以看到redis中存入了对应的权限：
之后就会先查redis,不会再访问sql了
- 权限 Control Access List ACL权限control access list 权限control access based access-control-allow-origin 权限acl 39 access access-control-allow-origin xmlhttprequest access-control-allow-origin control access origin 权限 文件acl origin access-control-allow-origin same-origin access-control-allow-origin requested 39 resource 课堂 权限acl