登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 安全 ›.NET 权限系统（RBAC）怎么设计？直接可复用 ...

.NET 权限系统（RBAC）怎么设计？直接可复用

余思洁 昨天 11:50
程序园永久vip申请，500美金$，无限下载程序园所有程序/软件/数据/等
纸上得来终觉浅，绝知此事要躬行。嗨，大家好！我是码农刚子。在企业级应用开发中，权限管理是后台系统的核心基础设施之一。一个设计良好、易于维护的权限模型不仅能保障系统安全，还能提升开发效率。本文将基于 RBAC（基于角色的访问控制） 模型，结合 .NET Core / .NET Framework 后端、SQL Server 数据库以及 Vue 前端，为你提供一套开箱即用、可复用的权限系统设计方案。无论你是从零搭建新系统，还是为现有项目引入权限模块，本文的代码和思路都能帮助你快速落地。
一、RBAC 核心概念

RBAC 通过引入“角色”作为用户与权限的桥梁，将权限授予角色，再将角色授予用户，从而简化权限管理。核心元素包括：

  • 用户（User）：系统的操作者。
  • 角色（Role）：权限的集合，例如“管理员”、“财务专员”。
  • 权限（Permission）：对某个资源（如菜单、按钮、API）的操作许可。
  • 用户-角色关联：用户拥有的角色。
  • 角色-权限关联：角色拥有的权限。
此外，在实际企业系统中，我们通常还需要管理菜单（Menu）和按钮（Button），以实现前端动态路由和界面元素的权限控制。
二、数据库设计（SQL Server）

首先设计数据表，这是整个权限系统的基石。以下脚本采用 SQL Server，但稍作修改即可适配其他数据库。
2.1 核心表结构
  1. -- 用户表
  2. CREATE TABLE [User] (
  3.     Id          INT PRIMARY KEY IDENTITY(1,1),
  4.     UserName    NVARCHAR(50) NOT NULL UNIQUE,
  5.     Password    NVARCHAR(128) NOT NULL, -- 存储哈希后的密码
  6.     RealName    NVARCHAR(50),
  7.     Email       NVARCHAR(100),
  8.     Phone       NVARCHAR(20),
  9.     IsEnabled   BIT DEFAULT 1,
  10.     CreatedAt   DATETIME DEFAULT GETDATE()
  11. );
  13. -- 角色表
  14. CREATE TABLE [Role] (
  15.     Id          INT PRIMARY KEY IDENTITY(1,1),
  16.     RoleName    NVARCHAR(50) NOT NULL UNIQUE,
  17.     Description NVARCHAR(200),
  18.     IsEnabled   BIT DEFAULT 1
  19. );
  21. -- 权限表
  22. CREATE TABLE [Permission] (
  23.     Id          INT PRIMARY KEY IDENTITY(1,1),
  24.     ParentId    INT NULL,                      -- 父权限，用于树形结构
  25.     PermissionName NVARCHAR(50) NOT NULL,
  26.     PermissionCode NVARCHAR(100) NOT NULL UNIQUE, -- 权限唯一标识，如 "user:add"
  27.     PermissionType TINYINT DEFAULT 1,           -- 1-菜单 2-按钮 3-API
  28.     Url         NVARCHAR(200),                  -- 菜单路径或API路径
  29.     Icon        NVARCHAR(50),                    -- 菜单图标
  30.     SortOrder   INT DEFAULT 0,
  31.     FOREIGN KEY (ParentId) REFERENCES Permission(Id)
  32. );
  34. -- 用户-角色关联表
  35. CREATE TABLE [UserRole] (
  36.     UserId INT NOT NULL,
  37.     RoleId INT NOT NULL,
  38.     PRIMARY KEY (UserId, RoleId),
  39.     FOREIGN KEY (UserId) REFERENCES [User](Id) ON DELETE CASCADE,
  40.     FOREIGN KEY (RoleId) REFERENCES [Role](Id) ON DELETE CASCADE
  41. );
  43. -- 角色-权限关联表
  44. CREATE TABLE [RolePermission] (
  45.     RoleId       INT NOT NULL,
  46.     PermissionId INT NOT NULL,
  47.     PRIMARY KEY (RoleId, PermissionId),
  48.     FOREIGN KEY (RoleId) REFERENCES [Role](Id) ON DELETE CASCADE,
  49.     FOREIGN KEY (PermissionId) REFERENCES [Permission](Id) ON DELETE CASCADE
  50. );
复制代码
说明：

  • Permission 表采用父子关系，可构建菜单树。PermissionCode 是后端进行 API 权限判定的关键字段（如 user:view, order:export）。
  • UserRole 和 RolePermission 为多对多关联表，支持用户多角色、角色多权限。
  • 可根据实际需要扩展字段，如软删除、租户隔离等。
2.2 初始数据示例
  1. -- 插入权限
  2. INSERT INTO Permission (PermissionName, PermissionCode, PermissionType, Url, ParentId) VALUES
  3. ('系统管理', 'sys', 1, '/system', NULL),
  4. ('用户管理', 'sys:user', 1, '/system/user', 1),
  5. ('查看用户', 'sys:user:view', 2, NULL, 2),
  6. ('新增用户', 'sys:user:add', 2, NULL, 2),
  7. ('编辑用户', 'sys:user:edit', 2, NULL, 2),
  8. ('删除用户', 'sys:user:delete', 2, NULL, 2),
  9. ('角色管理', 'sys:role', 1, '/system/role', 1),
  10. ('查看角色', 'sys:role:view', 2, NULL, 7),
  11. ('分配权限', 'sys:role:assign', 2, NULL, 7);
  13. -- 插入角色
  14. INSERT INTO Role (RoleName, Description) VALUES ('超级管理员', '拥有所有权限'), ('普通用户', '仅有查看权限');
  16. -- 关联角色与权限（超级管理员拥有所有权限）
  17. INSERT INTO RolePermission (RoleId, PermissionId)
  18. SELECT 1, Id FROM Permission;
  20. -- 关联角色与权限（普通用户仅拥有查看权限）
  21. INSERT INTO RolePermission (RoleId, PermissionId)
  22. SELECT 2, Id FROM Permission WHERE PermissionCode LIKE '%view%';
复制代码
三、后端实现（.NET Core 6+）

后端基于 .NET Core 6（或更高版本）和 Entity Framework Core 构建，提供 JWT 认证、权限验证接口以及中间件。
3.1 项目结构与依赖

假设项目使用以下 NuGet 包：

  • Microsoft.EntityFrameworkCore.SqlServer
  • Microsoft.AspNetCore.Authentication.JwtBearer
  • Swashbuckle.AspNetCore（可选，用于 API 文档）
3.2 实体类映射

使用 EF Core Code First 方式，创建实体类：
  1. public class User
  2. {
  3.     public int Id { get; set; }
  4.     public string UserName { get; set; }
  5.     public string Password { get; set; } // 哈希值
  6.     public string RealName { get; set; }
  7.     public string Email { get; set; }
  8.     public string Phone { get; set; }
  9.     public bool IsEnabled { get; set; }
  10.     public DateTime CreatedAt { get; set; }
  11.     public ICollection<Role> Roles { get; set; }
  12. }
  14. public class Role
  15. {
  16.     public int Id { get; set; }
  17.     public string RoleName { get; set; }
  18.     public string Description { get; set; }
  19.     public bool IsEnabled { get; set; }
  20.     public ICollection<User> Users { get; set; }
  21.     public ICollection<Permission> Permissions { get; set; }
  22. }
  24. public class Permission
  25. {
  26.     public int Id { get; set; }
  27.     public int? ParentId { get; set; }
  28.     public string PermissionName { get; set; }
  29.     public string PermissionCode { get; set; }
  30.     public byte PermissionType { get; set; } // 1-菜单 2-按钮 3-API
  31.     public string Url { get; set; }
  32.     public string Icon { get; set; }
  33.     public int SortOrder { get; set; }
  34.     public Permission Parent { get; set; }
  35.     public ICollection<Permission> Children { get; set; }
  36.     public ICollection<Role> Roles { get; set; }
  37. }
复制代码
配置多对多关系（在 DbContext.OnModelCreating 中）：
  1. modelBuilder.Entity<UserRole>()
  2.     .HasKey(ur => new { ur.UserId, ur.RoleId });
  4. modelBuilder.Entity<RolePermission>()
  5.     .HasKey(rp => new { rp.RoleId, rp.PermissionId });
复制代码
3.3 JWT 认证与登录接口

在 appsettings.json 中配置 JWT 参数：
  1. "Jwt": {
  2.   "Secret": "your-very-long-secret-key-here-change-it",
  3.   "Issuer": "your-issuer",
  4.   "Audience": "your-audience",
  5.   "ExpireMinutes": 120
  6. }
复制代码
配置服务（Program.cs）：
  1. using Microsoft.AspNetCore.Authentication.JwtBearer;
  2. using Microsoft.IdentityModel.Tokens;
  3. using System.Text;
  5. // 添加 JWT 认证
  6. var key = Encoding.ASCII.GetBytes(builder.Configuration["Jwt:Secret"]);
  7. builder.Services.AddAuthentication(x =>
  8. {
  9.     x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
  10.     x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
  11. })
  12. .AddJwtBearer(x =>
  13. {
  14.     x.RequireHttpsMetadata = false;
  15.     x.SaveToken = true;
  16.     x.TokenValidationParameters = new TokenValidationParameters
  17.     {
  18.         ValidateIssuerSigningKey = true,
  19.         IssuerSigningKey = new SymmetricSecurityKey(key),
  20.         ValidateIssuer = true,
  21.         ValidIssuer = builder.Configuration["Jwt:Issuer"],
  22.         ValidateAudience = true,
  23.         ValidAudience = builder.Configuration["Jwt:Audience"],
  24.         ValidateLifetime = true,
  25.         ClockSkew = TimeSpan.Zero
  26.     };
  27. });
复制代码
登录接口（AuthController）：
  1. [HttpPost("login")]
  2. public async Task> Login(LoginDto loginDto)
  3. {
  4.     var user = await _context.Users
  5.         .Include(u => u.Roles)
  6.         .ThenInclude(r => r.Permissions)
  7.         .FirstOrDefaultAsync(u => u.UserName == loginDto.UserName && u.IsEnabled);
  9.     if (user == null || !VerifyPassword(loginDto.Password, user.Password))
  10.         return Unauthorized("用户名或密码错误");
  12.     // 生成 JWT Token
  13.     var claims = new List<Claim>
  14.     {
  15.         new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()),
  16.         new Claim(ClaimTypes.Name, user.UserName),
  17.         new Claim(ClaimTypes.GivenName, user.RealName ?? "")
  18.     };
  20.     // 将权限编码作为用户 Claims 的一部分（用于后端 API 权限判断）
  21.     var permissions = user.Roles.SelectMany(r => r.Permissions)
  22.                                 .Select(p => p.PermissionCode)
  23.                                 .Distinct();
  24.     foreach (var perm in permissions)
  25.     {
  26.         claims.Add(new Claim("Permission", perm));
  27.     }
  29.     var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["Jwt:Secret"]));
  30.     var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
  31.     var token = new JwtSecurityToken(
  32.         issuer: _configuration["Jwt:Issuer"],
  33.         audience: _configuration["Jwt:Audience"],
  34.         claims: claims,
  35.         expires: DateTime.Now.AddMinutes(double.Parse(_configuration["Jwt:ExpireMinutes"])),
  36.         signingCredentials: creds
  37.     );
  39.     return Ok(new
  40.     {
  41.         token = new JwtSecurityTokenHandler().WriteToken(token),
  42.         userInfo = new { user.Id, user.UserName, user.RealName }
  43.     });
  44. }
复制代码
3.4 权限验证中间件与自定义特性

方案一：基于策略的授权

可以在 Program.cs 中定义策略，将权限编码映射到策略：
  1. builder.Services.AddAuthorization(options =>
  2. {
  3.     // 从数据库读取所有权限并添加策略（需在应用启动时执行一次）
  4.     using var scope = builder.Services.BuildServiceProvider().CreateScope();
  5.     var dbContext = scope.ServiceProvider.GetRequiredService();
  6.     var permissions = dbContext.Permissions.Select(p => p.PermissionCode).ToList();
  7.     foreach (var perm in permissions)
  8.     {
  9.         options.AddPolicy(perm, policy => policy.RequireClaim("Permission", perm));
  10.     }
  11. });
复制代码
然后在 Controller 或 Action 上使用 [Authorize(Policy = "sys:user:view")]。
但这种方式在权限动态变化时需重启应用。更灵活的方式是使用自定义授权处理器。
方案二：自定义授权过滤器

创建一个自定义特性 PermissionAttribute，在 OnActionExecuting 中检查当前用户是否拥有指定权限编码。
  1. [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true)]
  2. public class PermissionAttribute : AuthorizeAttribute
  3. {
  4.     public string Code { get; }
  6.     public PermissionAttribute(string code)
  7.     {
  8.         Code = code;
  9.     }
  10. }
  12. // 在过滤器管道中处理（需注册）
  13. public class PermissionFilter : IAsyncAuthorizationFilter
  14. {
  15.     public async Task OnAuthorizationAsync(AuthorizationFilterContext context)
  16.     {
  17.         var user = context.HttpContext.User;
  18.         if (!user.Identity.IsAuthenticated)
  19.         {
  20.             context.Result = new UnauthorizedResult();
  21.             return;
  22.         }
  24.         var permissionAttr = (context.ActionDescriptor as ControllerActionDescriptor)
  25.             ?.MethodInfo.GetCustomAttribute<PermissionAttribute>();
  26.         if (permissionAttr == null) return;
  28.         var requiredCode = permissionAttr.Code;
  29.         var userPermissions = user.FindAll("Permission").Select(c => c.Value).ToList();
  31.         if (!userPermissions.Contains(requiredCode))
  32.         {
  33.             context.Result = new ForbidResult();
  34.         }
  35.     }
  36. }
  38. // 在 Program.cs 中注册
  39. builder.Services.AddControllers(options =>
  40. {
  41.     options.Filters.Add<PermissionFilter>();
  42. });
复制代码
使用时：
  1. [HttpGet]
  2. [Permission("sys:user:view")]
  3. public async Task<IActionResult> GetUsers()
  4. {
  5.     // ...
  6. }
复制代码
这种方法权限变更后，用户需重新登录（或刷新 Token）才能生效。若需实时生效，可将权限存储在 Redis 中，并在过滤器中每次查询。
3.5 获取用户菜单与按钮权限接口

前端需要根据当前用户权限动态生成路由和按钮。后端提供两个接口：

  • 获取菜单树：返回当前用户拥有的所有菜单类型权限（PermissionType=1）。
  • 获取按钮权限码集合：返回当前用户拥有的所有按钮权限编码（PermissionType=2）。
  1. [HttpGet("menus")]
  2. [Permission("sys:menu")] // 可自定义权限
  3. public async Task>> GetUserMenus()
  4. {
  5.     var userId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
  6.     var user = await _context.Users
  7.         .Include(u => u.Roles)
  8.         .ThenInclude(r => r.Permissions)
  9.         .FirstOrDefaultAsync(u => u.Id == userId);
  11.     var menuPermissions = user.Roles
  12.         .SelectMany(r => r.Permissions)
  13.         .Where(p => p.PermissionType == 1) // 菜单
  14.         .OrderBy(p => p.SortOrder)
  15.         .ToList();
  17.     // 构建树形结构
  18.     var menuTree = BuildMenuTree(menuPermissions, null);
  19.     return Ok(menuTree);
  20. }
  22. [HttpGet("buttons")]
  23. public async Task>> GetUserButtons()
  24. {
  25.     var userId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
  26.     var user = await _context.Users
  27.         .Include(u => u.Roles)
  28.         .ThenInclude(r => r.Permissions)
  29.         .FirstOrDefaultAsync(u => u.Id == userId);
  31.     var buttonCodes = user.Roles
  32.         .SelectMany(r => r.Permissions)
  33.         .Where(p => p.PermissionType == 2) // 按钮
  34.         .Select(p => p.PermissionCode)
  35.         .Distinct()
  36.         .ToList();
  38.     return Ok(buttonCodes);
  39. }
复制代码
四、前端集成（Vue 3 + Vue Router + Pinia）

前端使用 Vue 3 组合式 API，配合 Vue Router 和 Pinia 实现动态路由和按钮级权限控制。
4.1 存储用户信息及权限

在 Pinia store 中保存 token、用户信息、菜单列表和按钮权限集合。
  1. // stores/user.js
  2. import { defineStore } from 'pinia'
  3. import { login as apiLogin, getUserMenus, getUserButtons } from '@/api/auth'
  5. export const useUserStore = defineStore('user', {
  6.   state: () => ({
  7.     token: localStorage.getItem('token') || '',
  8.     userInfo: null,
  9.     menus: [],
  10.     buttons: []
  11.   }),
  12.   actions: {
  13.     async login(credentials) {
  14.       const res = await apiLogin(credentials)
  15.       this.token = res.token
  16.       localStorage.setItem('token', res.token)
  17.       this.userInfo = res.userInfo
  18.       await this.fetchPermissions()
  19.     },
  20.     async fetchPermissions() {
  21.       const [menuRes, buttonRes] = await Promise.all([
  22.         getUserMenus(),
  23.         getUserButtons()
  24.       ])
  25.       this.menus = menuRes
  26.       this.buttons = buttonRes
  27.     },
  28.     logout() {
  29.       this.token = ''
  30.       this.userInfo = null
  31.       this.menus = []
  32.       this.buttons = []
  33.       localStorage.removeItem('token')
  34.     }
  35.   }
  36. })
复制代码
4.2 动态路由生成

在路由守卫中，根据后端返回的菜单树动态添加路由。
  1. // router/index.js
  2. import { createRouter, createWebHistory } from 'vue-router'
  3. import { useUserStore } from '@/stores/user'
  5. // 静态路由（如登录页、404等）
  6. export const constantRoutes = [
  7.   { path: '/login', component: () => import('@/views/Login.vue'), hidden: true },
  8.   { path: '/404', component: () => import('@/views/404.vue'), hidden: true }
  9. ]
  11. // 异步路由（需动态添加）
  12. const asyncRoutes = [] // 初始为空
  14. const router = createRouter({
  15.   history: createWebHistory(),
  16.   routes: constantRoutes
  17. })
  19. // 重置路由（用于注销）
  20. export function resetRouter() {
  21.   router.getRoutes().forEach(route => {
  22.     if (route.name && !constantRoutes.some(r => r.name === route.name)) {
  23.       router.removeRoute(route.name)
  24.     }
  25.   })
  26. }
  28. // 递归生成路由配置
  29. function generateRoutes(menus) {
  30.   const routes = []
  31.   menus.forEach(menu => {
  32.     const route = {
  33.       path: menu.url,
  34.       name: menu.permissionCode, // 可选
  35.       component: () => import(`@/views${menu.url}.vue`), // 根据路径映射组件
  36.       meta: { title: menu.permissionName, icon: menu.icon },
  37.       children: menu.children ? generateRoutes(menu.children) : []
  38.     }
  39.     routes.push(route)
  40.   })
  41.   return routes
  42. }
  44. // 路由守卫
  45. router.beforeEach(async (to, from, next) => {
  46.   const userStore = useUserStore()
  47.   if (to.path === '/login') {
  48.     next()
  49.   } else {
  50.     if (!userStore.token) {
  51.       next('/login')
  52.     } else {
  53.       // 如果菜单为空，说明刚登录或刷新页面，需要拉取权限并动态添加路由
  54.       if (userStore.menus.length === 0) {
  55.         await userStore.fetchPermissions()
  56.         const routes = generateRoutes(userStore.menus)
  57.         routes.forEach(route => router.addRoute(route))
  58.         // 添加404重定向
  59.         router.addRoute({ path: '/:pathMatch(.*)*', redirect: '/404' })
  60.         next(to.path) // 重新导航到目标
  61.       } else {
  62.         next()
  63.       }
  64.     }
  65.   }
  66. })
复制代码
4.3 按钮级权限指令

封装一个自定义指令 v-permission，用于控制按钮的显示隐藏。
  1. // directives/permission.js
  2. import { useUserStore } from '@/stores/user'
  4. export const permission = {
  5.   mounted(el, binding) {
  6.     const userStore = useUserStore()
  7.     const { value } = binding
  8.     if (value && !userStore.buttons.includes(value)) {
  9.       el.parentNode?.removeChild(el)
  10.     }
  11.   }
  12. }
  14. // main.js 中注册
  15. import { permission } from '@/directives/permission'
  16. app.directive('permission', permission)
复制代码
使用示例：
  1. <template>
  2.   <button v-permission="'sys:user:add'">新增用户</button>
  3. </template>
复制代码
五、可复用组件与工具类

为了提升复用性，可以将权限相关逻辑封装成以下模块：
5.1 后端通用权限验证服务
  1. public interface IPermissionService
  2. {
  3.     Task<bool> HasPermissionAsync(int userId, string permissionCode);
  4.     Task<List<string>> GetUserPermissionsAsync(int userId);
  5. }
  7. public class PermissionService : IPermissionService
  8. {
  9.     private readonly AppDbContext _dbContext;
  10.     public PermissionService(AppDbContext dbContext) => _dbContext = dbContext;
  12.     public async Task<bool> HasPermissionAsync(int userId, string permissionCode)
  13.     {
  14.         return await _dbContext.UserRoles
  15.             .Where(ur => ur.UserId == userId)
  16.             .SelectMany(ur => ur.Role.RolePermissions)
  17.             .AnyAsync(rp => rp.Permission.PermissionCode == permissionCode);
  18.     }
  20.     public async Task<List<string>> GetUserPermissionsAsync(int userId)
  21.     {
  22.         return await _dbContext.UserRoles
  23.             .Where(ur => ur.UserId == userId)
  24.             .SelectMany(ur => ur.Role.RolePermissions)
  25.             .Select(rp => rp.Permission.PermissionCode)
  26.             .Distinct()
  27.             .ToListAsync();
  28.     }
  29. }
复制代码
可在需要的地方通过 DI 注入使用。
5.2 前端权限 Hook

封装一个组合式函数，方便在组件内判断权限：
  1. // composables/usePermission.js
  2. import { useUserStore } from '@/stores/user'
  4. export function usePermission() {
  5.   const userStore = useUserStore()
  7.   function hasPermission(permissionCode) {
  8.     return userStore.buttons.includes(permissionCode)
  9.   }
  11.   return { hasPermission }
  12. }
复制代码
使用：
  1. <template>
  2.   <button v-if="hasPermission('sys:user:add')">新增</button>
  3. </template>
复制代码
六、扩展考虑

6.1 数据权限

RBAC 模型通常只能控制“能否访问”，但实际业务中往往需要控制“能访问哪些数据”（如只能查看本部门数据）。此时可以引入“数据权限规则”，例如在权限表中增加 DataScope 字段，在查询时动态拼接过滤条件。
6.2 多租户

SaaS 系统中，需要在所有表增加 TenantId 字段，并在数据访问层自动过滤，实现租户隔离。
6.3 审计日志

记录用户操作日志，结合权限系统可追踪谁在何时做了什么。
七、总结

本文从数据库设计、后端实现到前端集成，完整地展示了一套基于 RBAC 的权限系统在 .NET + Vue 技术栈下的落地方法。你可以直接复制使用文中代码，并根据项目需求进行调整。关键要点：

  • 数据库表结构设计清晰，权限编码规范化。
  • 后端使用 JWT 携带权限 Claim，配合自定义过滤器实现 API 权限控制。
  • 前端动态生成路由，利用指令实现按钮级权限。
  • 封装可复用的服务和 Hook，方便业务层调用。
这套方案已在实际企业后台系统中多次验证，具有良好的扩展性和可维护性。希望对你有所帮助，欢迎在评论区交流讨论！
本人擅长 .NET 后台、小程序、商城定制开发，有需求可私信。
#.NET权限系统 #RBAC #数据库设计 #后台开发

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！
NET权限系统RBAC怎么

使用道具 举报

相关推荐
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
余思洁
昨天 11:50

0

粉丝关注

17

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫