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

// 传统方式：硬编码权限检查
func DeleteBook(userType string) {
    if userType == "student" {
        return // 学生不能删除
    }
    if userType == "teacher" {
        return // 老师也不能删除
    }
    if userType == "admin" {
        // 只有管理员能删除
        deleteBook()
    }
}

// 不再硬编码，而是用数据库存储
1、定义角色
type Role struct {
    ID          uint   `json:"id"`
    Name        string `json:"name"`        // "学生", "教师", "管理员"
    Description string `json:"description"` // "普通学生用户"
}

2、定义权限
type Permission struct {
    ID     uint   `json:"id"`
    Name   string `json:"name"`   // "book:borrow", "user:create"
    Action string `json:"action"` // "借阅图书", "创建用户"
}

// 现在的权限检查
func DeleteBook(userID uint) error {
    if !permission.HasPermission(userID, "book:delete") {
        return errors.New("权限不足：您无法删除图书")
    }
    return deleteBook()
}
 新增角色？只需要配置数据，无需改代码！
// 2. 权限检查 - 如何工作的？
func (r *RoleService) HasPermission(roleID uint, permission string) bool {
    // 具体的权限验证逻辑
    // 为什么这样设计？
}

// 传统方式：硬编码权限
if userType == "teacher" {
    // 教师相关操作
} else if userType == "student" {
    // 学生相关操作
}
// 问题：新增角色需要修改代码

// 你的方案：动态权限
if permission.HasRole(user.RoleID, "teacher") {
    // 教师相关操作
}
// 优势：新增角色只需要配置数据

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

 if !permission.HasPermission(userID, "book:delete") {
        return errors.New("权限不足：您无法删除图书")
    }

// 展示如何在路由中应用权限中间件
router.POST("/role", middleware.RequirePermission("role:create"), roleHandler.CreateRole)
router.GET("/role", middleware.RequirePermission("role:read"), roleHandler.GetRoles)

// - 1.  路径跳过检查 - 检查当前请求路径是否在跳过列表中，如果是则直接放行
// - 2. 获取用户信息 - 从请求头 X-Userinfo 中获取 Base64 编码的用户信息
// - 3.  解码和反序列化 - 将 Base64 字符串解码后，反序列化为 UserInfo 结构体
// - 4. 租户ID处理 - 清理租户ID格式（移除前导斜杠），从请求头获取目标租户ID
// - 5. 权限验证 - 检查用户是否有权限访问请求的租户（用户的租户列表中是否包含目标租户）
// - 6. 设置上下文 - 验证通过后，将用户信息和租户ID设置到 Gin 上下文中供后续使用
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
		}

		// Remove the leading slash from each tenant ID
		for i, tenantId := range userProfile.TenantIds {
			if len(tenantId) > 0 && tenantId[0] == '/' {
				userProfile.TenantIds[i] = tenantId[1:]
			}
		}

		// Get tenantId from request header
		requestTenantId := c.GetHeader("tenantId")
		c.Set("tenantId", requestTenantId)
		if requestTenantId == "" && len(userProfile.TenantIds) > 0 {
			requestTenantId = userProfile.TenantIds[0]
			c.Set("tenantId", requestTenantId)
		}
		if requestTenantId == "" {
			logrus.Error("Missing tenantId in request header")
			err = errs.NewUnauthorizedError("missing tenantId in request header")
			response.BuildErrorResponse(err, c)
			c.Abort()
			return
		}

		// Check if the requested tenantId is in user's tenant list
		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
		}
		// Authorized, continue
		c.Set("user", userProfile)
		c.Next()
	}
}

// 从配置中获取，需要跳过的路径	
// 通过map存储实现O(1)查询
notAuth := config.SkipPaths
	var skip map[string]struct{}
	if len(notAuth) > 0 {
		skip = make(map[string]struct{})
		for _, path := range notAuth {
			skip[path] = struct{}{}
		}
	}
// 跳过
if _, ok := skip[c.FullPath()]; ok {
	c.Next()
	return
}

// 1. 获取网关传递的用户信息       
 userInfos := c.Request.Header.Get("X-Userinfo")
		....

// 2. Base64解码
userProfile := &userModel.UserInfo{}
user, err := base64.StdEncoding.DecodeString(userInfos)
		....
    
// 3. JSON反序列化为用户对象
err = json.Unmarshal(user, &userProfile)
		....

// 4. 租户权限验证
        ....

客户端 → 网关/认证服务 → 业务服务
       ↓
   JWT验证/登录
       ↓
   生成用户信息
       ↓
   Base64编码后放入Header
       ↓
   转发到后端服务

本项目JWT令牌的生成方式
通过对项目代码的深入分析，我发现本项目的JWT令牌生成采用了以下架构：

JWT令牌生成流程
1. Keycloak作为JWT令牌签发中心

- 项目使用 `keycloak.go` 中的 `GetAdminToken` 方法
- 通过调用 k.client.LoginAdmin() 向Keycloak服务器请求JWT令牌
- 使用配置文件中的管理员账户（AdminUser/AdminPass）进行认证
2. JWT令牌的具体生成过程

```
token, err := k.client.LoginAdmin(k.ctx, global.Config.Keycloak.
AdminUser, global.Config.Keycloak.AdminPass, "master")
```
3. 令牌使用场景

- 管理操作 ：在用户创建、更新、删除等管理操作中使用
- 权限验证 ：通过 `auth.go` 中间件验证用户身份
- API调用 ：所有需要认证的API都通过JWT令牌进行权限控制

// CreateUser 在 Keycloak 中创建新用户
// 实现了完整的用户创建流程，包括权限分配和事务回滚
func (k *KeycloakService) CreateUser(req *UserCreateRequest) (string, error) {
    // 步骤1: 获取 Keycloak 管理员访问令牌
    token, err := k.GetAdminToken()
    if err != nil {
        logrus.Error(err)
        return "", err
    }
    
    // 步骤2: 检查用户名（身份证号）是否已存在
    exists, err := k.CheckUsernameExists(req.IdNumber)
    if err != nil {
        logrus.Error(err)
        return "", err
    }
    if exists {
        logrus.Errorf("User with idNumber %s already exists", req.IdNumber)
        return "", errors.NewResourceAlreadyExistError("身份证重复！")
    }
    
    // 步骤3: 设置默认密码（如果未提供）
    if len(req.Password) == 0 {
        req.Password = "Aa123456" // 建议：提取为配置项
    }
    
    // 步骤4: 构建 Keycloak 用户对象
    keycloakUser := gocloak.User{
        Username: gocloak.StringP(req.IdNumber),    // 使用身份证作为用户名
        Enabled:  gocloak.BoolP(true),              // 启用用户
        LastName: gocloak.StringP(req.Name),        // 设置姓名
        Credentials: &[]gocloak.CredentialRepresentation{
            {
                Type:      gocloak.StringP("password"),
                Value:     gocloak.StringP(req.Password),
                Temporary: gocloak.BoolP(false),        // 非临时密码
            },
        },
    }
    
    // 步骤5: 在 Keycloak 中创建用户
    userID, err := k.client.CreateUser(k.ctx, token.AccessToken, k.realm, keycloakUser)
    if err != nil {
        logrus.Errorf("Failed to create user %s in realm %s: %v", req.Name, k.realm, err)
        return "", err
    }
    
    // 步骤6: 添加用户到指定组（带事务回滚）
    err = k.AddUserToGroup(userID, req.GroupName)
    if err != nil {
        logrus.Errorf("Failed to add user %s to group %s: %v", userID, req.GroupName, err)
        // 回滚：删除已创建的用户
        if rollbackErr := k.DeleteUser(userID); rollbackErr != nil {
            logrus.Errorf("Rollback failed: %v", rollbackErr)
        }
        return "", err
    }
    
    // 步骤7: 为用户分配角色（带事务回滚）
    err = k.AddRoleToUser(userID, req.Role)
    if err != nil {
        logrus.Errorf("Failed to add role %s to user %s: %v", req.Role, userID, err)
        // 回滚：删除已创建的用户
        if rollbackErr := k.DeleteUser(userID); rollbackErr != nil {
            logrus.Errorf("Rollback failed: %v", rollbackErr)
        }
        return "", err
    }
    
    return userID, nil
}

// Permission 权限结构体
type Permission struct {
	Key      string       `json:"key"`
	Title    string       `json:"title"`
	Children []Permission `json:"children,omitempty"`
}

// DefaultPermissions 默认权限树结构
var DefaultPermissions = []Permission{
	{
		Key:   "home",
		Title: "首页",
	},
	{
		Key:   "bookshelf",
		Title: "个人书架",
	},
	{
		Key:   "borrow-history",
		Title: "借阅记录",
	},
	{
		Key:   "activity-center",
		Title: "活动中心",
	},
	{
		Key:   "message-center",
		Title: "消息中心",
	},
	{
		Key:   "system-manage",
		Title: "系统管理",
		Children: []Permission{
			{
				Key:   "book-manage",
				Title: "图书管理",
				Children: []Permission{
					{Key: "book-entry", Title: "图书录入"},
					{Key: "book-list", Title: "图书列表"},
					{Key: "book-recommend", Title: "图书推荐"},
					{Key: "book-check", Title: "图书清查"},
				},
			},
			{
				Key:   "borrow-manage",
				Title: "借阅管理",
				Children: []Permission{
					{Key: "book-borrow", Title: "图书借阅"},
					{Key: "book-return", Title: "图书归还"},
					{Key: "flow-approve", Title: "漂流审批"},
					{Key: "reserve-list", Title: "候补列表"},
					{Key: "borrow-record", Title: "借阅记录"},
				},
			},
			{
				Key:   "activity-manage",
				Title: "活动管理",
				Children: []Permission{
					{Key: "activity-create", Title: "活动创建"},
					{Key: "activity-approve", Title: "活动审批"},
					{Key: "activity-list", Title: "活动列表"},
				},
			},
			{
				Key:   "notice-manage",
				Title: "通知管理",
				Children: []Permission{
					{Key: "notice-create", Title: "通知创建"},
					{Key: "notice-list", Title: "通知列表"},
				},
			},
			{
				Key:   "system-setting",
				Title: "系统设置",
				Children: []Permission{
					{Key: "user-manage", Title: "读者管理"},
					{Key: "role-manage", Title: "角色配置"},
					{Key: "system-configure", Title: "系统配置"},
					{Key: "grade-configure", Title: "年级配置"},
					{Key: "venue-configure", Title: "馆场地配置"},
					{Key: "activity-configure", Title: "活动配置"},
				},
			},
		},
	},
}

// BuildPermissionParentMap 从DefaultPermissions构建权限层级关系映射
func BuildPermissionParentMap() map[string]string {
	parentMap := make(map[string]string)
	buildParentMapRecursive(DefaultPermissions, "", parentMap)
	return parentMap
}

// buildParentMapRecursive 递归构建权限父子关系映射
// 能够快速找到子权限的父权限
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)
		}
	}
}

用户(User) → 角色(Role) → 权限(Permission) → 资源(Resource)
     ↓           ↓           ↓              ↓
  身份认证    角色分配    权限控制      资源访问

type UserInfo struct {
    Name        string   // 用户姓名
    Username    string   // 用户名
    AccountId   string   // 账户ID
    Roles       []string // 用户角色列表
    TenantIds   []string // 租户ID列表（多租户支持）
    // ... 其他字段
}

type Role struct {
    Name        string      // 角色名称
    Description string      // 角色描述
    BorrowLimit int         // 借阅数量限制
    BorrowDays  int         // 借阅天数限制
    TenantId    string      // 租户ID
    Permissions string      // 权限配置JSON
    Status      enum.Status // 状态
}

type Permission struct {
    Key      string       // 权限标识
    Title    string       // 权限名称
    Children []Permission // 子权限
}

系统管理 (system-manage)
├── 图书管理 (book-manage)
│   ├── 图书录入 (book-entry)
│   ├── 图书列表 (book-list)
│   └── 图书推荐 (book-recommend)
├── 借阅管理 (borrow-manage)
│   ├── 图书借阅 (book-borrow)
│   └── 图书归还 (book-return)
└── 系统设置 (system-setting)
    ├── 读者管理 (user-manage)
    └── 角色配置 (role-manage)

用户登录
    ↓
后端返回用户权限列表: ["home", "personal-bookshelf", "borrow-record", "activity-center", "message-center"]
    ↓
前端存储权限到 Pinia Store
    ↓
菜单渲染时过滤权限
    ↓
系统管理菜单不显示（因为没有任何系统管理权限）
    ↓
用户无法通过正常途径访问读者管理页面
    ↓
即使通过直接URL访问，组件内部也会进行权限检查
    ↓
最终被拒绝访问或跳转到403页面

async fetchAndSetStaffInfo() {
  try {
    this.isLoading = true;
    const response = await getCurrentStaff(); // 调用后端API获取用户信息
    if (response && (response as any).data && (response as any).code === 0) {
      const staffData = (response as any).data;
      // 设置用户权限
      this.permissions = staffData.permissions || []; // 普通读者只有基础权限
    }
  } catch (error) {
    console.error('获取用户信息失败:', error);
  }
}

const filterRoute = (routeList: TRouter[], currentPermissions: string[]) => {
  // 检查用户是否有系统管理权限
  const hasSystemManagePermission = systemManagePermissions.some((permission) =>
    currentPermissions.includes(permission),
  );

  for (let i = routeList.length - 1; i >= 0; i--) {
    const route = routeList[i];
    const routeName = route.name as string;
    
    // 特殊处理系统管理菜单
    if (routeName === 'SystemManage') {
      if (!hasSystemManagePermission) {
        routeList.splice(i, 1); // 移除系统管理菜单
      }
    }
  }
};

// 菜单权限映射
const menuPermissionMap = {
  'user-manage': 'user-manage',
  'role-manage': 'role-manage',
  // ... 其他权限映射
};

// 根据权限过滤菜单组
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); // 过滤掉没有可用菜单项的组
});

<!-- 在任何组件中使用权限指令 -->
<a-button v-permission="'user-manage'" type="primary">
  读者管理
</a-button>

const permission: Directive = {
  mounted(el: HTMLElement, binding) {
    const { value } = binding;
    const user = useUserStore();
    const { permissions } = user;

    if (value) {
      let hasPermission = false;
      if (typeof value === 'string') {
        hasPermission = permissions.includes(value); // 检查是否有该权限
      }

      if (!hasPermission) {
        el.style.display = 'none'; // 没有权限则隐藏元素
      }
    }
  },
};

export function usePermission() {
  const user = useUserStore();

  // 检查是否有指定权限
  const hasPermission = (permission: string): boolean => {
    return user.hasPermission(permission);
  };

  return {
    hasPermission,
    // ... 其他权限检查方法
  };
}

<script setup>
import { usePermission } from '@/hooks/usePermission';

const { hasPermission } = usePermission();

// 检查权限
if (!hasPermission('user-manage')) {
  // 没有权限，执行相应逻辑
  router.push('/403'); // 跳转到无权限页面
}
</script>

go get github.com/casbin/casbin/v2

[request_definition]
r = sub, obj, act

[policy_definition]
p = sub, obj, act

[matchers]
m = r.sub == p.sub && r.obj == p.obj && r.act == p.act

[policy_effect]
e = some(where (p.eft == allow))

p, zhangsan, /index, GET
p, zhangsan, /home, GET
p, zhangsan, /users, GET
p, zhangsan, /users, POST
p, wangwu, /index, GET
p, wangwu, /home, GET

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.pml", "casbin/policy.csv")
	if err != nil {
		log.Fatalf("NewEnforecer failed:%v\n", err)
	}

	check(e, "zhangsan", "/index", "GET")
	check(e, "zhangsan", "/home", "GET")
	check(e, "zhangsan", "/users", "POST")
	check(e, "wangwu", "/users", "POST")
}

// 增加
e.AddPolicy("wangwu", "/users", "POST") // 增加
e.SavePolicy()    // 落库
// 删除
e.RemovePolicy("wangwu", "/users", "POST")
e.SavePolicy()

# ==============================================
# Casbin 权限模型配置文件详解
# ==============================================

# [request_definition] 部分：定义权限检查请求的结构
# 这部分规定了在执行权限检查时(enforce方法)，需要提供哪些参数
[request_definition]
# 定义了一个请求(r)包含三个元素：
# - sub (subject): 访问主体，通常是用户ID、用户名或角色
# - obj (object): 访问客体，即要访问的资源或对象
# - act (action): 操作动作，如读(read)、写(write)、删除(delete)等
r = sub, obj, act

# [policy_definition] 部分：定义权限策略的存储结构
# 这部分规定了在数据库或策略文件中存储的权限规则格式
[policy_definition]
# 定义了一个策略(p)包含三个元素：
# - sub: 被授权的主体
# - obj: 被授权的资源
# - act: 被允许的操作
p = sub, obj, act

# [matchers] 部分：定义请求与策略的匹配规则
# 这部分是Casbin的核心，决定了如何将请求与存储的策略进行匹配
[matchers]
# 匹配规则说明：
# - r.sub == p.sub: 请求的主体必须与策略的主体完全匹配
# - r.obj == p.obj: 请求的资源必须与策略的资源完全匹配
# - r.act == p.act: 请求的操作必须与策略的操作完全匹配
# 只有当这三个条件都满足时，策略才会匹配成功
m = r.sub == p.sub && r.obj == p.obj && r.act == p.act

# [policy_effect] 部分：定义多个匹配策略时的效果组合规则
# 这部分决定了当多个策略匹配请求时，如何组合这些策略的效果
[policy_effect]
# 效果规则说明：
# - some(where (p.eft == allow)): 只要有一个匹配的策略允许访问，最终结果就是允许
# - 这意味着这是一个"一票通过"系统：只要有一条规则允许，即使有其他规则拒绝，也会允许访问
e = some(where (p.eft == allow))

# ==============================================
# Casbin 策略规则详解
# ==============================================

# 策略规则格式: p, 主体(sub), 资源(obj), 操作(act)
# 每条规则表示"哪个主体可以对哪个资源执行什么操作"

# 用户"zhangsan"的权限规则:
p, zhangsan, /index, GET    # 允许zhangsan访问首页(GET请求)
p, zhangsan, /home, GET     # 允许zhangsan访问主页(GET请求)
p, zhangsan, /users, GET    # 允许zhangsan查看用户列表(GET请求)
p, zhangsan, /users, POST   # 允许zhangsan创建新用户(POST请求)

# 用户"wangwu"的权限规则:
p, wangwu, /index, GET      # 允许wangwu访问首页(GET请求)
p, wangwu, /home, GET       # 允许wangwu访问主页(GET请求)

# ==============================================
# 权限分析:
# ==============================================

# zhangsan 拥有以下权限:
# - 可以访问首页 (/index)
# - 可以访问主页 (/home)
# - 可以查看用户列表 (/users - GET)
# - 可以创建新用户 (/users - POST)
# 说明: zhangsan 是一个有较高权限的用户，可以管理用户

# wangwu 拥有以下权限:
# - 可以访问首页 (/index)
# - 可以访问主页 (/home)
# 说明: wangwu 是一个普通用户，只有基本的浏览权限

# 注意: 这两个用户都没有删除用户的权限(如 DELETE /users/123)
# 也没有访问其他可能存在的资源(如 /admin, /settings 等)的权限

[request_definition]
r = sub, obj, act

[policy_definition]
p = sub, obj, act

# 新增角色定义，配合下方[matchers]中 g(r.sub, p.sub)
[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

p, admin, /index, GET
p, admin, /home, GET
p, admin, /users, GET
p, admin, /users, POST
p, yunwei, /index, GET
p, yunwei, /home, GET
g, zhangsan, admin
g, wangwu, yunwei

# p 开头的是对应角色权限，一般用户可分为3类（游客-普通用户-管理员）
# g 开头的是为用户分配的角色。

go get github.com/casbin/gorm-adapter/v3

package core

import (
  "fmt"
  "github.com/sirupsen/logrus"
  "gorm.io/driver/mysql"
  "gorm.io/gorm"
  "gorm.io/gorm/logger"
  "time"
)

func InitGorm() *gorm.DB {
  dsn := "root:root@tcp(127.0.0.1:3306)/rule_db?charset=utf8mb4&parseTime=True&loc=Local"

  var mysqlLogger logger.Interface
  db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
    Logger:                                   mysqlLogger,
    DisableForeignKeyConstraintWhenMigrating: true,
  })
  if err != nil {
    logrus.Error(fmt.Sprintf("[%s] mysql连接失败", dsn))
    panic(err)
  }
  sqlDB, _ := db.DB()
  sqlDB.SetMaxIdleConns(10)               // 最大空闲连接数
  sqlDB.SetMaxOpenConns(100)              // 最多可容纳
  sqlDB.SetConnMaxLifetime(time.Hour * 4) // 连接最大复用时间，不能超过mysql的wait_timeout
  return db
}

gormadapter "github.com/casbin/gorm-adapter/v3"

global.DB.AutoMigrate(
  &gormadapter.CasbinRule{},
)

// 初始化GORM数据库连接，并将连接实例赋值给全局变量global.DB
// 这里假设core.InitGorm()已经配置好数据库连接参数并返回一个*gorm.DB实例
global.DB = core.InitGorm()

// 使用GORM数据库连接创建Casbin适配器
// 适配器负责将Casbin策略持久化到数据库中（使用GORM作为ORM工具）
// 第二个返回值是错误对象，这里使用_忽略错误检查（实际项目中不建议这样做）
a, _ := gormadapter.NewAdapterByDB(global.DB)

// 从文件加载Casbin模型配置
// "./testdata/model.pml"是模型定义文件的路径，包含请求定义、策略定义等配置
// 如果加载失败，会返回错误信息
m, err := model.NewModelFromFile("./testdata/model.pml")
if err != nil {
  // 如果模型加载失败，记录错误日志并返回
  // 使用logrus.Error记录错误级别日志，包含错误详情
  logrus.Error("字符串加载模型失败!", err)
  return
}

// 创建带缓存的Casbin执行器
// 与标准执行器不同，缓存执行器会将策略缓存到内存中，提高权限检查性能
// 第二个返回值是错误对象，这里使用_忽略错误检查（实际项目中不建议这样做）
e, _ := casbin.NewCachedEnforcer(m, a)

// 设置缓存过期时间为3600秒（1小时）
// 这意味着策略缓存将在1小时后失效，需要重新加载
e.SetExpireTime(60 * 60)

// 从适配器（数据库）加载策略到执行器中
// 这是必须的一步，否则执行器不知道任何权限规则
// 错误对象被忽略（实际项目中应该检查错误）
_ = e.LoadPolicy()

e.AddPolicy("admin", "/api/users", "GET")
e.AddRoleForUser("zhangsan", "admin")
check(e, "zhangsan", "/api/users", "GET")
e.RemoveGroupingPolicy("zhangsan", "admin")
e.RemovePolicy("admin", "/api/users", "GET")
check(e, "zhangsan", "/api/users", "GET")
e.SavePolicy()
check(e, "zhangsan", "/api/users", "GET")

	// 从数据库中移除关联
	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 {
		return fmt.Errorf("Casbin移除用户角色失败: %w", err)
	}

	// 从数据库中移除关联
	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)
	}