Go 语言企业级权限管理系统设计与实现

动态权限检查

新增角色只需配置数据，无需修改代码。

// 权限检查逻辑
func DeleteBook(userID uint) error {
    if !permission.HasPermission(userID, "book:delete") {
        return errors.New("权限不足：您无法删除图书")
    }
    return deleteBook()
}

二、中间件设计

引入 RBAC 后，每个 API 都需要手动检查权限，导致代码重复。通过中间件（Middleware）可以统一处理鉴权逻辑。

1. 理论设计

在路由注册时应用权限中间件：

router.POST("/role", middleware.RequirePermission("role:create"), roleHandler.CreateRole)
router.GET("/role", middleware.RequirePermission("role:read"), roleHandler.GetRoles)

2. 项目实现细节

以 Gin 框架为例，中间件主要完成以下流程：

1. 路径跳过检查：判断当前请求是否在免检列表中。
2. 获取用户信息：从请求头 X-Userinfo 中获取 Base64 编码的用户信息。
3. 解码与反序列化：解码并转换为 UserInfo 结构体。
4. 租户 ID 处理：清理格式并从请求头获取目标租户 ID。
5. 权限验证：检查用户是否有权限访问该租户。
6. 上下文设置：验证通过后，将用户信息和租户 ID 存入 Context。

func Auth() gin.HandlerFunc {
    return AuthWithConfig(AuthConfig{})
}

func AuthWithConfig(config AuthConfig) gin.HandlerFunc {
    notAuth := config.SkipPaths
    var skip map[string]struct{}
    if len(notAuth) > 0 {
        skip = make(map[string]struct{})
        for _, path := range notAuth {
            skip[path] = struct{}{}
        }
    }

    return func(c *gin.Context) {
        // 跳过检查
        if _, ok := skip[c.FullPath()]; ok {
            c.Next()
            return
        }

        userInfos := c.Request.Header.Get("X-Userinfo")
        if userInfos == "" {
            err := errs.NewUnauthorizedError("missing user information")
            response.BuildErrorResponse(err, c)
            c.Abort()
            return
        }

        userProfile := &userModel.UserInfo{}
        user, err := base64.StdEncoding.DecodeString(userInfos)
        if err != nil {
            logrus.Error("x-userinfo base64 decoding failed", err)
            err = errs.NewUnauthorizedError("invalid user info encoding")
            response.BuildErrorResponse(err, c)
            c.Abort()
            return
        }

        err = json.Unmarshal(user, &userProfile)
        if err != nil {
            logrus.Error("x-userinfo json unmarshal failed", err)
            err = errs.NewUnauthorizedError("invalid user info format")
            response.BuildErrorResponse(err, c)
            c.Abort()
            return
        }

        // 租户权限验证
        requestTenantId := c.GetHeader("tenantId")
        c.Set("tenantId", requestTenantId)
        
        authorized := false
        for _, tenantId := range userProfile.TenantIds {
            if tenantId == requestTenantId {
                authorized = true
                break
            }
        }
        if !authorized {
            logrus.Warnf("User attempted to access unauthorized tenant: %s", requestTenantId)
            err = errs.NewUnauthorizedError("unauthorized tenant access")
            response.BuildErrorResponse(err, c)
            c.Abort()
            return
        }

        c.Set("user", userProfile)
        c.Next()
    }
}

3. 认证架构拓展

系统采用 Keycloak 作为身份和访问管理（IAM）解决方案，支持单点登录（SSO）、多因素认证（MFA）及 OAuth 2.0 等标准协议。

JWT 令牌生成流程：

1. Keycloak 作为签发中心，调用 LoginAdmin() 请求 JWT。
2. 使用配置文件中的管理员账户进行认证。
3. 管理操作及 API 调用均通过 JWT 令牌进行权限控制。

三、基于树结构的权限设计

1. 权限树结构

使用递归结构体定义权限层级。

type Permission struct {
    Key      string         `json:"key"`
    Title    string         `json:"title"`
    Children []Permission   `json:"children,omitempty"`
}

var DefaultPermissions = []Permission{
    {Key: "home", Title: "首页"},
    {Key: "system-manage", Title: "系统管理",
        Children: []Permission{
            {Key: "book-manage", Title: "图书管理",
                Children: []Permission{
                    {Key: "book-entry", Title: "图书录入"},
                    {Key: "book-list", Title: "图书列表"},
                },
            },
            {Key: "user-manage", Title: "读者管理"},
        },
    },
}

2. 权限层级映射

构建父子节点关系映射，便于快速查找。

func BuildPermissionParentMap() map[string]string {
    parentMap := make(map[string]string)
    buildParentMapRecursive(DefaultPermissions, "", parentMap)
    return parentMap
}

func buildParentMapRecursive(permissions []Permission, parentKey string, parentMap map[string]string) {
    for _, perm := range permissions {
        if parentKey != "" {
            parentMap[perm.Key] = parentKey
        }
        if len(perm.Children) > 0 {
            buildParentMapRecursive(perm.Children, perm.Key, parentMap)
        }
    }
}

3. 三级权限结构

1. 一级权限：模块级别（如：系统管理）
2. 二级权限：功能级别（如：图书管理）
3. 三级权限：操作级别（如：图书录入）

四、前端权限控制

前端权限控制分为多层防护，确保安全性。

1. 获取权限数据

用户登录后，后端返回权限列表，前端存储至 Store。

async fetchAndSetStaffInfo() {
    try {
        const response = await getCurrentStaff();
        if (response && response.code === 0) {
            this.permissions = response.data.permissions || [];
        }
    } catch (error) {
        console.error('获取用户信息失败:', error);
    }
}

2. 第一层防护：菜单不显示

根据权限过滤路由表，无权限的菜单项不渲染。

const filterRoute = (routeList, currentPermissions) => {
    for (let i = routeList.length - 1; i >= 0; i--) {
        const route = routeList[i];
        if (!hasSystemManagePermission(currentPermissions)) {
            routeList.splice(i, 1);
        }
    }
};

3. 第二层防护：子菜单过滤

侧边栏组件进一步过滤子菜单项。

const filteredMenuGroups = computed(() => {
    return menuGroups.map((group) => ({
        ...group,
        items: group.items.filter((item) => {
            const requiredPermission = menuPermissionMap[item.key];
            return !requiredPermission || permissions.value.includes(requiredPermission);
        }),
    })).filter((group) => group.items.length > 0);
});

4. 第三层防护：权限指令控制

使用自定义指令控制页面元素显示。

<a-button v-permission="'user-manage'" type="primary">读者管理</a-button>

const permission = {
    mounted(el, binding) {
        const { value } = binding;
        const { permissions } = useUserStore();
        if (value && !permissions.includes(value)) {
            el.style.display = 'none';
        }
    },
};

5. 第四层防护：组合式函数检查

在组件逻辑中直接调用权限检查函数。

import { usePermission } from '@/hooks/usePermission';
const { hasPermission } = usePermission();
if (!hasPermission('user-manage')) {
    router.push('/403');
}

6. 第五层防护：路由守卫

针对直接 URL 访问，在路由层面进行拦截。

五、Casbin 集成实践

Casbin 是强大的开源访问控制框架，支持多种模型。

1. 基本使用

初始化 Casbin 加载模型和策略文件。

package main

import (
    "fmt"
    "github.com/casbin/casbin/v2"
    "log"
)

func check(e *casbin.Enforcer, sub, obj, act string) {
    ok, _ := e.Enforce(sub, obj, act)
    if ok {
        fmt.Printf("%s CAN %s %s\n", sub, act, obj)
    } else {
        fmt.Printf("%s CANNOT %s %s\n", sub, act, obj)
    }
}

func main() {
    e, err := casbin.NewEnforcer("casbin/model.ini", "casbin/policy.csv")
    if err != nil {
        log.Fatalf("NewEnforecer failed:%v\n", err)
    }
    check(e, "zhangsan", "/index", "GET")
}

2. RBAC 模型配置

配置文件 model.ini 定义角色关系。

[request_definition]
r = sub, obj, act
[policy_definition]
p = sub, obj, act
[role_definition]
g = _, _
[policy_effect]
e = some(where (p.eft == allow))
[matchers]
m = g(r.sub, p.sub) && r.obj == p.obj && r.act == p.act

3. GORM 持久化

将策略存储到数据库中。

import (
    "gorm.io/gorm"
    "github.com/casbin/gorm-adapter/v3"
)

// 初始化 GORM 连接
db := core.InitGorm()

// 迁移 CasbinRule 表
db.AutoMigrate(&gormadapter.CasbinRule{})

// 创建适配器
a, _ := gormadapter.NewAdapterByDB(db)

// 创建 Enforcer
e, _ := casbin.NewCachedEnforcer(m, a)
e.LoadPolicy()

4. 事务一致性处理

在移除用户角色关系时，需保证数据库与 Casbin 的一致性，采用补偿机制。

// 从数据库中移除关联
if err = roleRepo.RemoveRoleFromUser(ctx, userID, roleID); err != nil {
    return fmt.Errorf("数据库移除角色失败：%w", err)
}

// 从 Casbin 中移除用户角色关系
userIDStr := strconv.FormatUint(uint64(userID), 10)
_, err = p.casbinSvc.Enforcer.DeleteRoleForUser(userIDStr, role.Code)
if err != nil {
    // 补偿性原则：回滚数据库操作
    roleRepo.AddRoleFromUser(ctx, userID, roleID)
    return fmt.Errorf("Casbin 移除用户角色失败：%w", err)
}

六、总结

本文详细阐述了基于 Go 语言的企业级权限管理系统设计，涵盖 RBAC 模型、中间件鉴权、权限树构建、前后端多层防护以及 Casbin 框架的深度集成。通过模块化设计与严格的权限校验机制，确保了系统的安全性与可维护性。