.net web mvc 权限验证（asp.net mvc权限验证）

25-04-29 1

此处将为大家介绍关于.netwebmvc权限验证的详细内容，并且为您解答有关asp.netmvc权限验证的相关问题，此外，我们还将为您介绍关于.netwebapi权限验证、004-SpringBoot

此处将为大家介绍关于.net web mvc 权限验证的详细内容，并且为您解答有关asp.net mvc权限验证的相关问题，此外，我们还将为您介绍关于.net web api 权限验证、004-SpringBoot Security 权限验证、3,Django回顾-权限表设计-session写入权限-权限验证-展示菜单-控制粒度到按钮级别、9-4.Asp.net Mvc 身份验证、异常处理、权限验证(拦截器)实现代码的有用信息。

本文目录一览：

.net web mvc 权限验证（asp.net mvc权限验证）
.net web api 权限验证
004-SpringBoot Security 权限验证
3,Django回顾-权限表设计-session写入权限-权限验证-展示菜单-控制粒度到按钮级别
9-4.Asp.net Mvc 身份验证、异常处理、权限验证(拦截器)实现代码

.net web mvc 权限验证（asp.net mvc权限验证）

这里分享MVC的权限验证，内容中可能存在一些，莫名其妙的方法，那些是以前封装好的，大致可以根据方法名称知道他的意思。

using Game.Entity;
using Game.Entity.PlatformManager;
using Game.Facade;
using Game.Utils.Cache;
using Game.Web.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using System.Web.Security;

namespace Game.Web.Authorize
{
    /// <summary>
    /// web mvc 管理员权限验证
    /// </summary>
    public class AdminLoginAuthorize : AuthorizeAttribute
    {
        /// <summary>
        /// 管理员权限验证
        /// </summary>
        /// <param name="httpContext"></param>
        /// <returns></returns>
        protected override bool AuthorizeCore(HttpContextBase httpContext)
        {
            bool result = false;
            if (httpContext.User != null)
            {
                //获取用户票证
                var ticObject = WHCache.Default.Get<CookiesCache>(FormsAuthentication.FormsCookieName);
                if (ticObject != null)
                {
                    FormsAuthenticationTicket ticket = FormsAuthentication.Decrypt(ticObject.ToString());
                    if (!ticket.Expired && ticket.CookiePath == httpContext.Request.UserHostAddress)
                    {
                        //获取Session缓存用户
                        var user = FacadeManage.aidePlatformManagerFacade.GetUserInfoFromCache();
                        if (user == null)
                        {
                            user = FacadeManage.aidePlatformManagerFacade.GetUserByUserID(int.Parse(ticket.Name.Split(''_'')[1]));
                            FacadeManage.aidePlatformManagerFacade.SaveUserCache(user);
                        }
                        //验证Session缓存用户是否和登录用户一致
                        if (ticket.Name == $"UserToken_{user.UserID}")
                        {
                            result = true;
                        }
                    }
                }
            }
            return result;
        }

        /// <summary>
        /// 处理授权失败的 HTTP 请求。
        /// </summary>
        /// <param name="filterContext">封装用于 System.Web.Mvc.AuthorizeAttribute 的信息。 filterContext 对象包括控制器、HTTP 上下文、请求上下文、操作结果和路由数据。</param>
        protected override void HandleUnauthorizedRequest(System.Web.Mvc.AuthorizationContext filterContext)
        {
            string _errorMsg = "出错了";
            if (filterContext.ActionDescriptor.IsDefined(typeof(AllowAnonymousAttribute), true)
                || filterContext.ActionDescriptor.ControllerDescriptor.IsDefined(typeof(AllowAnonymousAttribute), true))
            {
                return;
            }

            //异步请求
            if (filterContext.HttpContext.Request.IsAjaxRequest())
            {
                filterContext.HttpContext.Response.StatusCode = (int)System.Net.HttpStatusCode.InternalServerError;
                filterContext.Result = new JsonResult()
                {
                    JsonRequestBehavior = JsonRequestBehavior.AllowGet,
                    Data = new
                    {
                        ErrorType = this.GetType().Name,
                        Action = filterContext.ActionDescriptor.ActionName,
                        Message = _errorMsg
                    }
                };
            }
            else
            {
                filterContext.Result = new RedirectResult("/Home/Login");
            }
        }
    }
}

.net web api 权限验证

做一个登录权限验证。

开始吧。

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Web;
using System.Web.Http;
using System.Web.Security;
using Game.Web.Models;

namespace Game.Web.ApiControllers
{
    [Authorize.APIAuthorize]
    [RoutePrefix("api/home")]
    public class HomeController : BaseController
    {
        /// <summary>
        /// 用户登录
        /// </summary>
        /// <returns></returns>
        [Route("loginUser"), HttpPost, AllowAnonymous]
        public AjaxJsonResult LoginUser(UserInfo info)
        {
            AjaxJsonResult ajax = new AjaxJsonResult() { code = (int)CodeStatus.NoLogin, msg = ajax.GetEnumDescription(CodeStatus.NoLogin) };
            try
            {
                //调用登录方法
                UserInfo _info = new UserInfo()
                {
                    UserName = "aaa",
                    PassWord = "123"
                };
                if (_info.UserName == info.UserName && _info.PassWord == info.PassWord)
                {
                    //登录成功,添加票证
                    FormsAuthenticationTicket ticket = new FormsAuthenticationTicket(
                        1
                        , $"UserToken"
                        , DateTime.Now
                        , DateTime.Now.AddMinutes(60)
                        , false
                        , $"{info.UserName}:{info.PassWord}"
                        , HttpContext.Current.Request.UserHostAddress);
                    string ticStr = FormsAuthentication.Encrypt(ticket);
                    ajax.code = (int)Models.CodeStatus.OK; ajax.msg = "登入成功！";
                }
                else
                {
                    ajax.msg = "登入失败！";
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error("登录报错！", ex);
            }
            return ajax;
        }
    }
}

AllowAnonymous 特性，不需要验证

LogHelper 静态方法，这里用了Log4，进行错误日志记录，网上有自己百度哦。

这里只是简单的加入了票证，其实可以把它再加密成Token放到Response的Headers里面，具体这么操作自行百度吧。

登录成功后下面就是用API接口获取List数据拉。

不过在获取前，我们需要进行权限验证。using Game.Facade;

using Game.Utils.Cache;
using Game.Web.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Text;
using System.Web;
using System.Web.Http;
using System.Web.Http.Controllers;
using System.Web.Security;

namespace Game.Web.Authorize
{
    /// <summary>
    /// web api 权限验证
    /// </summary>
    public class APIAuthorize : AuthorizeAttribute
    {
        private HttpContext _context { get; set; }

        /// <summary>
        /// 管理员权限验证
        /// </summary>
        /// <param name="httpContext"></param>
        /// <returns></returns>
        public override void OnAuthorization(HttpActionContext httpContext)
        {
            //获取用户票证
            if (ValidateTicket(httpContext))
            {
                base.IsAuthorized(httpContext);
            }
            else
            {
                HandleUnauthorizedRequest(httpContext);
            }
        }

        /// <summary>
        /// 处理授权失败的 HTTP 请求。
        /// </summary>
        /// <param name="filterContext">封装用于 System.Web.Mvc.AuthorizeAttribute 的信息。 filterContext 对象包括控制器、HTTP 上下文、请求上下文、操作结果和路由数据。</param>
        protected override void HandleUnauthorizedRequest(HttpActionContext httpContext)
        {
            if (httpContext.ActionDescriptor.GetCustomAttributes<AllowAnonymousAttribute>().Any() ||
             httpContext.ControllerContext.ControllerDescriptor.GetCustomAttributes<AllowAnonymousAttribute>().Any())
            {
                return;
            }
            base.HandleUnauthorizedRequest(httpContext);
            var response = httpContext.Response = httpContext.Response ?? new HttpResponseMessage();
            response.StatusCode = HttpStatusCode.Forbidden;
            var ajax = new AjaxJson
            {
                code = (int)CodeStatus.NoAuthorization,
                msg = AjaxJson.GetEnumDescription(CodeStatus.NoAuthorization),
            };
            response.Content = new StringContent(ajax.SerializeToJson(), Encoding.UTF8, "application/json");
        }

        /// <summary>
        /// 验证用户票证
        /// </summary>
        /// <param name="httpContext"></param>
        /// <returns></returns>
        private bool ValidateTicket(HttpActionContext httpContext)
        {
            var res = false;
            //获取HttpContext
            dynamic ctx = httpContext.Request.Properties["MS_HttpContext"];
            if (ctx != null)
            {
                var ticObject = WHCache.Default.Get<CookiesCache>(FormsAuthentication.FormsCookieName);
                if (ticObject != null)
                {
                    FormsAuthenticationTicket ticket = FormsAuthentication.Decrypt(ticObject.ToString());
                    if (!ticket.Expired && ticket.CookiePath == ctx.Request.UserHostAddress)
                    {
　　　　　　　　　　　　　　 //这里只是做了简单的获取到了票证，并且票证未有效和IP地址是否一致，进一步优化可以做到验证用户信息等。
　　　　　　　　　　　　　　 //如果没有登录，肯定是没有获取到票证的。

                        res = true;
                    }
                }
            }
            return res;
        }
    }
}

using System;
using System.Web.Http;
using Game.Web.Models;

namespace Game.Web.ApiControllers
{
    [Authorize.APIAuthorize]
    [RoutePrefix("api/home")]
    public class HomeController : BaseController
    {
        /// <summary>
        /// 用户登录
        /// </summary>
        /// <returns></returns>
        [Route("list"), HttpPost, AllowAnonymous]
        public AjaxJsonResult List(UserInfo info)
        {
            AjaxJsonResult ajax = new AjaxJsonResult() {  };
            try
            {
                //假装成功并返回了我们想要的数据，哈哈。
            }
            catch (Exception ex)
            {
                LogHelper.Error("获取报错！", ex);
            }
            return ajax;
        }
    }
}

再分享一下Json的返回格式吧。

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Threading.Tasks;
using System.Web;

namespace Game.Web.Models
{
    /// <summary>
    /// Api返回类
    /// </summary>
    public class AjaxJsonResult
    {
        #region 属性
        /// <summary>
        /// 状态码
        /// </summary>
        public int code { get; set; }

        /// <summary>
        /// 消息
        /// </summary>
        public string msg { get; set; }

        /// <summary>
        /// 返回数据
        /// </summary>
        public object data { get; set; }

        /// <summary>
        /// 总行数
        /// </summary>
        public object count { get; set; }
        #endregion

        #region 构造函数
        /// <summary>
        /// 构造函数
        /// </summary>
        public AjaxJsonResult()
        {
            code = (int)CodeStatus.OK;
            msg = string.Empty;
            data = "";
            count = string.Empty;
        }
        #endregion
    }

    /// <summary>
    /// 接口状态码
    /// </summary>
    public enum CodeStatus
    {
        #region 操作返回码
        /// <summary>
        /// 成功
        /// </summary>
        [Description("成功")]
        OK = 0,

        /// <summary>
        /// 失败
        /// </summary>
        [Description("失败")]
        Error = -1,

        #region 登录返回码
        /// <summary>
        /// 请先登陆
        /// </summary>
        [Description("请重新登陆")]
        NoLogin = -100,

        /// <summary>
        /// 密码不能为空
        /// </summary>
        [Description("密码不能为空")]
        NotPassEmtry = -101,

        /// <summary>
        /// 验证码错误
        /// </summary>
        [Description("验证码错误")]
        VerifyCodeError = -102,

        [Description("未授权,请重新登录")]
        NoAuthorization = -103,
        #endregion

        /// <summary>
        /// 其他
        /// </summary>
        [Description("其他")]
        EveryThing = -10000,
    }
}

以上就是我的Web API简单登录权限验证。

然后Web MVC 的登录权限验证，其实和这个也差不多，请看我的另一篇。

https://www.cnblogs.com/nnnnnn/p/10923262.html

004-SpringBoot Security 权限验证

前面三篇写的都是用户认证的内容。本篇记录一下权限的验证。权限的内容要建立在认证的基础上进行开发。

权限的关键点有两个，一个是给路由定义权限；另一个是给用户赋予权限。

定义权限

上面一句是开启权限验证；

下面一句是给路由定义权限；

定义其实很简单，就是通过注解@PreAuthorize增加定义即可，hasAnyAuthority是一个SpringSecurity默认提供的验证方法，方法里面传入权限名即可

通过源码，可以看出，允许传入多个权限项。除了这个方法，还有其它的，比如：hasAuthority，hasRole等

当然，这个方法，我们也可以自定义进行开发，后面将会写一个示例；

给用户赋权限

示例中，故意给出了不一样的权限，请求的时候，就会发现返回请求被禁止

自定义权限验证

自定义权限验证，可以满足更广泛的验证需求，比如，对于权限项的规则定义，通配符的定义等等。

首先定义验证的方法，注意要声明为组件，便于注入，同时，可以声明一个名称缩写，便于代码中书写

使用，即如下图所示

至此，权限的功能便可以实现了。具体到项目中，就是通过数据库记录数据。比如使用RBAC（Role-Based Access Control）模型创建授权数据结构。代码中补充完整即可。

再补充一点，权限的验证，还可以通过在配置类中，进行配置

该种使用的目的是，固定权限的路由，直接书写，更省力

3,Django回顾-权限表设计-session写入权限-权限验证-展示菜单-控制粒度到按钮级别

s13day107 
内容回顾：
    1. django模板中自定义方法。
    
    2. 视图三个返回值的区别。
    
    3. orm高级操作
        F
        Q
        select_related
        prefetch_related
        only
        defer
        原生SQL
            - connections
            - raw
            - extra
    
    4. 表操作FK
        on_delete
        limit_choice_to
        related_name
        
        fk创造m2m
        联合唯一索引
        
    5. Form和ModelForm作用？
        - 动态创建HTML表单标签
        - 用户提交的数据进行校验
        - 显示错误信息（保留原提交的数据）
        
    6. ModelFormSet作用？
        批量的操作
        - 动态创建HTML表单标签
        - 用户提交的数据进行校验
        - 显示错误信息（保留原提交的数据）
        
    7. 面向对象中 
        init
        call
        new
        getitem
        setitem
        delitem
        
        setattr
        getattr
        delattr
        
        enter
        exit
        repr
        str
        
    
    8. 简述django中session的实现原理？
        
        中间件：django.contrib.sessions.middleware.SessionMiddleware
            
            1. 实例化SessionMiddleware
                
                
                class SessionMiddleware(MiddlewareMixin):
                    def __init__(self, get_response=None):
                        self.get_response = get_response
                        # engine = django.contrib.sessions.backends.db
                        engine = import_module(settings.SESSION_ENGINE)
                        # from django.contrib.sessions.backends.db import SessionStore
                        # self.SessionStore = SessionStore
                        self.SessionStore = engine.SessionStore
            
            2. 执行process_request
            
                    def process_request(self, request):
                        # 根据sessionid获取原来我给浏览器设置的随机字符串。
                        session_key = request.COOKIES.get(settings.SESSION_COOKIE_NAME)
                        
                        
                        # request.session是SessionStore对象
                        request.session = self.SessionStore(session_key)
                        
                        源码执行流程：
                            - 执行 SessionStore的 __init__方法
                                class SessionStore(SessionBase):
                                    def __init__(self, session_key=None):
                                        super(SessionStore, self).__init__(session_key)
                                        
                                    ...
                                    
                            - 执行 SessionBase的 __init__方法
                                class SessionBase(object):
                                    TEST_COOKIE_NAME = ''testcookie''
                                    TEST_COOKIE_VALUE = ''worked''

                                    __not_given = object()

                                    def __init__(self, session_key=None):
                                        self._session_key = session_key
                                        self.accessed = False
                                        self.modified = False
                                        self.serializer = import_string(settings.SESSION_SERIALIZER)
                                    ...
            
            
            3. 执行视图函数
                def goods(request):
                    
                    # 调用 SessionStore对象的 __setitem__
                    # 内部：维护了一个字典SessionStore对象._session，在字典中设置了一个键值对 SessionStore对象._session = {''k1'':123}
                    request.session[''k1''] = 123
                    # 内部：维护了一个字典SessionStore对象._session，在字典中设置了一个键值对 SessionStore对象._session = {''k1'':123,''k2'':456}
                    request.session[''k2''] = 456
                    
                    del request.session[''k2'']
                
                        
                    return render(request,''goods.html'')
            
            
            4. 执行中间件的process_response
                - 将内存中的字典序列化，并保存到数据库。
                - 给用户浏览器设置cookie，将随机字符串写给浏览器。
            
                
                
                    def process_response(self, request, response):
                        """
                        If request.session was modified, or if the configuration is to save the
                        session every time, save the changes and set a session cookie or delete
                        the session cookie if the session has been emptied.
                        """
                        try:
                            accessed = request.session.accessed
                            modified = request.session.modified
                            empty = request.session.is_empty()
                        except AttributeError:
                            pass
                        else:
                            # First check if we need to delete this cookie.
                            # The session should be deleted only if the session is entirely empty
                            if settings.SESSION_COOKIE_NAME in request.COOKIES and empty:
                                response.delete_cookie(
                                    settings.SESSION_COOKIE_NAME,
                                    path=settings.SESSION_COOKIE_PATH,
                                    domain=settings.SESSION_COOKIE_DOMAIN,
                                )
                            else:
                                if accessed:
                                    patch_vary_headers(response, (''Cookie'',))
                                if (modified or settings.SESSION_SAVE_EVERY_REQUEST) and not empty:
                                    if request.session.get_expire_at_browser_close():
                                        max_age = None
                                        expires = None
                                    else:
                                        max_age = request.session.get_expiry_age()
                                        expires_time = time.time() + max_age
                                        expires = cookie_date(expires_time)
                                    # Save the session data and refresh the client cookie.
                                    # Skip session save for 500 responses, refs #3881.
                                    if response.status_code != 500:
                                        try:
                                            request.session.save()
                                        except UpdateError:
                                            raise SuspiciousOperation(
                                                "The request''s session was deleted before the "
                                                "request completed. The user may have logged "
                                                "out in a concurrent request, for example."
                                            )
                                        response.set_cookie(
                                            settings.SESSION_COOKIE_NAME,
                                            request.session.session_key, max_age=max_age,
                                            expires=expires, domain=settings.SESSION_COOKIE_DOMAIN,
                                            path=settings.SESSION_COOKIE_PATH,
                                            secure=settings.SESSION_COOKIE_SECURE or None,
                                            httponly=settings.SESSION_COOKIE_HTTPONLY or None,
                                        )
                        return response


今日内容：
    - 权限
    - django rest framework
    
内容详细：
    - 权限 
    
        1. 什么是rbac？
            基于角色的权限控制。
        
        2. 你的权限系统中都有哪些表？
            
            用户表
            
            角色表
            
            用户角色关系表
            
            权限表
            
            权限角色关系表
            
            菜单表
            
        3. 系统表设计 
            
            第一版：用户和权限（3张表）
            
            第二版：用户、角色、权限（5张表） rbac，基于角色的权限控制。
    
            第三版：菜单、用户、角色、权限（6张表） rbac，基于角色的权限控制 + 菜单。
    
        4. 权限功能实现

9-4.Asp.net Mvc 身份验证、异常处理、权限验证(拦截器)实现代码

1、用户登录
验证用户是否登录成功步骤直接忽略，用户登录成功后怎么保存当前用户登录信息（session，cookie），本文介绍的是身份验证（其实就是基于cookie）的，下面看看代码。
引入命名空间
using System.Web.Security;

 
Users ModelUser = new Users() { ID = 10000, Name = UserName, UserName = UserName, PassWord = PassWord, Roles = "admin" };//用户实体 
string UserData = SerializeHelper.Instance.JsonSerialize<Users>(ModelUser);//序列化用户实体 
//保存身份信息，参数说明可以看提示 
FormsAuthenticationTicket Ticket = new FormsAuthenticationTicket(1, UserName, DateTime.Now, DateTime.Now.AddHours(12), false, UserData); 
HttpCookie Cookie = new HttpCookie(FormsAuthentication.FormsCookieName, FormsAuthentication.Encrypt(Ticket));//加密身份信息，保存至Cookie 
Response.Cookies.Add(Cookie);

现在身份信息就保存到cookie中了，如果有场景需要用到当前用户的用户ID或者别的信息的时候该怎么办呢？
那么，我们重新在cookie中获取身份信息，然后解密，再反序列化成用户实体就OK了。

 
/// <summary> 
/// 获取用户登录信息 
/// </summary> 
/// <returns></returns> 
public Users GetUser() 
{ 
if (HttpContext.Current.Request.IsAuthenticated)//是否通过身份验证 
{ 
HttpCookie authCookie = HttpContext.Current.Request.Cookies[FormsAuthentication.FormsCookieName];//获取cookie 
FormsAuthenticationTicket Ticket = FormsAuthentication.Decrypt(authCookie.Value);//解密 
return SerializeHelper.Instance.JsonDeserialize<Users>(Ticket.UserData);//反序列化 
} 
return null; 
}

2、权限验证
这里用到的是MVC中的action拦截器（重写OnActionExecuting），在action执行之前会先运行拦截器中的代码。这里同时可以身份验证是否过期。

 
/// <summary> 
/// 权限验证 
/// </summary> 
public class AuthAttribute : ActionFilterattribute 
{ 
/// <summary> 
/// 角色名称 
/// </summary> 
public string Code { get; set; } 
/// <summary> 
/// 验证权限（action执行前会先执行这里） 
/// </summary> 
/// <param name="filterContext"></param> 
public override void OnActionExecuting(ActionExecutingContext filterContext) 
{ 
//如果存在身份信息 
if (!HttpContext.Current.User.Identity.IsAuthenticated) 
{ 
ContentResult Content = new ContentResult(); 
Content.Content = string.Format("<script type='text/javascript'>alert('请先登录！');window.location.href='{0}';</script>", FormsAuthentication.LoginUrl); 
filterContext.Result = Content; 
} 
else 
{ 
string[] Role = CheckLogin.Instance.GetUser().Roles.Split(',');//获取所有角色 
if (!Role.Contains(Code))//验证权限 
{ 
//验证不通过 
ContentResult Content = new ContentResult(); 
Content.Content = "<script type='text/javascript'>alert('权限验证不通过！');history.go(-1);</script>"; 
filterContext.Result = Content; 
} 
} 
} 
}

那么在action中怎么去调用呢？这里贴出HomeController中的代码来看下。

 
public class HomeController : BaseController 
{ 
[AuthAttribute(Code = "admin")]//验证通过（这个action只允许admin查看） 
public ActionResult Index() 
{ 
Users ModelUser = CheckLogin.Instance.GetUser(); 
return View(ModelUser); 
} 
[AuthAttribute(Code = "user")]//验证不通过 
public ActionResult Index2() 
{ 
return View(); 
} 
[AuthAttribute(Code = "admin")]//验证通过，发生异常 
public ActionResult Index3() 
{ 
return View(); 
} 
}

这样就可以把权限控制到action了。
3、异常处理
上面HomeController并不是继承Controller，而是继承我们自己定义的一个BaseController，那么我们来看看BaseController中有写什么东西？

 
[ErrorAttribute] 
public class BaseController : Controller 
{ 
//所有Controller都继承BaseController，则都会进行异常捕获 
}

在这里BaseController只做了一件事情，就是增加了一个ErrorAttribute的错误拦截器，那么只要是在Controller中发生的异常都会在ErrorAttribute中进行处理，你可以记录到数据库等操作。那么我们看看ErrorAttribute是怎么工作的。

 
/// <summary> 
/// 错误日志（Controller发生异常时会执行这里） 
/// </summary> 
public class ErrorAttribute : ActionFilterattribute, IExceptionFilter 
{ 
/// <summary> 
/// 异常 
/// </summary> 
/// <param name="filterContext"></param> 
public void OnException(ExceptionContext filterContext) 
{ 
//获取异常信息，入库保存 
Exception Error = filterContext.Exception; 
string Message = Error.Message;//错误信息 
string Url = HttpContext.Current.Request.RawUrl;//错误发生地址 
filterContext.ExceptionHandled = true; 
filterContext.Result = new RedirectResult("/Error/Show/");//跳转至错误提示页面 
} 
}

在这里可以把异常捕获，然后跳转到友好的错误提示页面。在MVC中几个操作就可以这样简单的完成了，关于代码在文章下面会提供下载。

关于.net web mvc 权限验证和asp.net mvc权限验证的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于.net web api 权限验证、004-SpringBoot Security 权限验证、3,Django回顾-权限表设计-session写入权限-权限验证-展示菜单-控制粒度到按钮级别、9-4.Asp.net Mvc 身份验证、异常处理、权限验证(拦截器)实现代码等相关知识的信息别忘了在本站进行查找喔。

本文标签：