正文

从新手到高手：轻松掌握NestJS构建权限控制接口全攻略

/0 浏览量
0612

在这个信息爆炸的时代，构建一个安全、高效的后端服务成为了软件开发的重中之重。NestJS作为一款基于TypeScript的框架，因其强大的模块化和灵活性，在构建权限控制接口方面有着广泛的应用。本文将带领新手一步步成长为NestJS构建权限控制接口的高手，让你轻松掌握相关技能。

一、NestJS简介

1.1 什么是NestJS？

NestJS是一款构建在企业级应用中的现代化JavaScript框架。它基于Node.js平台，使用TypeScript语言编写，旨在解决大型项目开发中常见的问题，如模块化、配置管理、依赖注入等。

1.2 NestJS的优势

  • 模块化：将应用分解成可复用的模块，便于管理和维护。
  • 依赖注入：自动管理依赖关系，提高代码的可读性和可维护性。
  • TypeScript：提供强类型检查，减少运行时错误。
  • 可扩展性：支持插件和中间件，满足个性化需求。

二、权限控制概述

2.1 什么是权限控制？

权限控制是确保系统安全的重要手段，通过限制用户对资源的访问，防止未授权的操作。

2.2 权限控制的基本概念

  • 用户：系统中的用户实体。
  • 角色：一组具有相似权限的用户。
  • 权限：对资源进行操作的能力。
  • 资源：被用户或角色访问的对象。

三、NestJS实现权限控制

3.1 初始化NestJS项目

首先，使用npm或yarn安装NestJS：

npm install -g @nestjs/cli

创建新项目：

nest new my-project

进入项目目录：

cd my-project

3.2 构建用户模块

创建用户模块：

nest generate module users

定义用户实体和用户服务：

// entities/user.entity.ts
import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';

@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  username: string;

  @Column()
  password: string;
}

// services/user.service.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { User } from '../entities/user.entity';

@Injectable()
export class UserService {
  constructor(
    @InjectRepository(User)
    private userRepository: Repository<User>,
  ) {}

  async findAll(): Promise<User[]> {
    return this.userRepository.find();
  }

  async create(user: User): Promise<User> {
    return this.userRepository.save(user);
  }
}

3.3 构建角色模块

创建角色模块：

nest generate module roles

定义角色实体和角色服务：

// entities/role.entity.ts
import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';

@Entity()
export class Role {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string;
}

// services/role.service.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Role } from '../entities/role.entity';

@Injectable()
export class RoleService {
  constructor(
    @InjectRepository(Role)
    private roleRepository: Repository<Role>,
  ) {}

  async findAll(): Promise<Role[]> {
    return this.roleRepository.find();
  }

  async create(role: Role): Promise<Role> {
    return this.roleRepository.save(role);
  }
}

3.4 构建资源模块

创建资源模块：

nest generate module resources

定义资源实体和资源服务：

// entities/resource.entity.ts
import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';

@Entity()
export class Resource {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string;

  @Column()
  url: string;
}

// services/resource.service.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Resource } from '../entities/resource.entity';

@Injectable()
export class ResourceService {
  constructor(
    @InjectRepository(Resource)
    private resourceRepository: Repository<Resource>,
  ) {}

  async findAll(): Promise<Resource[]> {
    return this.resourceRepository.find();
  }

  async create(resource: Resource): Promise<Resource> {
    return this.resourceRepository.save(resource);
  }
}

3.5 构建权限模块

创建权限模块：

nest generate module permissions

定义权限实体和权限服务：

// entities/permission.entity.ts
import { Entity, PrimaryGeneratedColumn, Column, ManyToMany } from 'typeorm';
import { User } from '../entities/user.entity';
import { Role } from '../entities/role.entity';
import { Resource } from '../entities/resource.entity';

@Entity()
export class Permission {
  @PrimaryGeneratedColumn()
  id: number;

  @ManyToMany(() => User, user => user.permissions)
  users: User[];

  @ManyToMany(() => Role, role => role.permissions)
  roles: Role[];

  @ManyToMany(() => Resource, resource => resource.permissions)
  resources: Resource[];
}

// services/permission.service.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Permission } from '../entities/permission.entity';

@Injectable()
export class PermissionService {
  constructor(
    @InjectRepository(Permission)
    private permissionRepository: Repository<Permission>,
  ) {}

  async findAll(): Promise<Permission[]> {
    return this.permissionRepository.find();
  }

  async create(permission: Permission): Promise<Permission> {
    return this.permissionRepository.save(permission);
  }
}

3.6 构建认证模块

创建认证模块：

nest generate module auth

定义用户认证服务：

// services/auth.service.ts
import { Injectable } from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';
import { User } from '../entities/user.entity';

@Injectable()
export class AuthService {
  constructor(private jwtService: JwtService) {}

  async login(user: User): Promise<string> {
    const payload = { username: user.username, sub: user.id };
    return this.jwtService.sign(payload);
  }
}

3.7 构建权限中间件

创建权限中间件：

// middleware/role.middleware.ts
import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { Permission } from '../entities/permission.entity';

@Injectable()
export class RoleMiddleware implements CanActivate {
  constructor(private reflector: Reflector) {}

  async canActivate(context: ExecutionContext): Promise<boolean> {
    const requiredRoles = this.reflector.get<string[]>('roles', context.getHandler());
    if (!requiredRoles) {
      return true;
    }

    const request = context.switchToHttp().getRequest();
    const user = request.user;
    const hasRole = requiredRoles.some(role => role === user.role.name);

    return hasRole;
  }
}

3.8 注册中间件和模块

在main.ts中注册中间件和模块：

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { RoleMiddleware } from './middleware/role.middleware';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalMiddlewares(RoleMiddleware);
  await app.listen(3000);
}
bootstrap();

3.9 使用权限控制

在控制器中使用@UseGuards()装饰器添加权限中间件：

import { Controller, Get, Post, UseGuards } from '@nestjs/common';
import { RoleMiddleware } from './middleware/role.middleware';

@Controller('users')
@UseGuards(RoleMiddleware)
export class UsersController {
  constructor() {}

  @Get()
  findAll() {
    return 'List of users';
  }

  @Post()
  create() {
    return 'Create a new user';
  }
}

四、总结

通过以上步骤，我们成功地在NestJS中实现了权限控制接口。当然，实际应用中可能需要更复杂的权限控制逻辑，如基于角色或资源的多级权限控制等。本文仅为入门指南，希望能帮助新手快速掌握NestJS构建权限控制接口的技能。随着不断学习和实践，你将逐步成长为高手！

-- 展开阅读全文 --