网站后台权限设计

头一次写博客，可能章法有些乱，大家将就看下吧。

（图太大，建议下载下来看）

一，前言

公司网站的后台是和其它2个同事一起做的，权限这块是最后加上去的，当时是另外一个同事做的。

后来那位同事离职了，后台在不断修改和增加功能的情况下，页面越来越多，原来的权限设计越来越不能满足需求了。

主要是因为原来的权限是根据页面地址用正则匹配的,这样就出现一个问题，页面如果增加或减少一个参数，就要去修改正则，这样显的太繁琐。

于是就想着重新设计一套权限。于是就有了本文。

二，设计思路

我的设计思路也是根据页面地址来判断，但分成两部分。第一部分为不带参数的页面地址，第二部分是页面地址上带的参数。

当用户访问某个页面时

1，先截取不带参数的地址url，再截取地址中的参数对 params

2，然后从数据库中取出当前用户的所有权限，根据第1步取得的url去匹配权限列表list（同一地址可能对应几个不同权限，比如添加和修改为同一个页面，但权限又是分开的），如果能匹配到，则继续看第3步，否则表示用户没有该页面访问权限

3，如果第2步能匹配到权限列表list，则从第1步中取出参数对 params ；循环list，判断每一个权限的参数是否能与params中的参数匹配（正则）；如果有一个完全匹配，则说明用户有访问本页面权限。

三，开始设计

我把权限大致分为页面级权限（即能不能访问某页面）和功能级权限（即能不能使用某页面上的某功能，如删除等）

先设计数据库，如下图：

部分权限如下：

 

 四，判断权限

1，页面级权限

如上图，假设当前访问的页面是 http://admin/message/msgDraftList.aspx?t=2&s=1&kk=9

则根据不带参数的URL：admin/message/msgDraftList.aspx可以匹配到6个权限，这时再根据访问时所带的参数 t=2    s=1  kk=9判断应该属于哪个权限

很明显应该匹配 RightID=879的权限，kk=9不参与权限判定，因为权限表中并没有以该参数作为权限判定的依据。

假设上面的地址中参数 s=9，则明显匹配不到任何权限，这时应该判定当前用户没有权限

2，页面上的功能权限

页面上的功能如果也需要设置权限，则设为 Right=882这样的，在页面上手动输入该权限的 Code来访问该权限，如果用户有该权限，则应该为true否则应该为false

3，A页面上链接到B页面的权限

假设A页面上有链接到B页面的<a href='b.aspx'>带我去B页面</a>， 这时可以通过B页面对应的Code判断是否拥有该页面的权限。

五，实现

1，所有后台页面继承自同一页面 AdminPage，在这个页面上判断页面级权限。然后在每个页面上判断功能级权限。

2，实现代码，贴下我的代码吧：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.IO;
using System.Text.RegularExpressions;
using System.Collections;
using VGShop.Utility;
using System.Collections.Specialized;
namespace VGShop.Utility
{
    /// <summary>
    /// 登录状态、权限判断
    /// </summary>
    public class AdminPage : Page
    {
        /// <summary>
        /// 已登录的管理员
        /// </summary>
        protected VGShop.Entity.Admin user;
        /// <summary>
        /// 用户权限
        /// </summary>
        protected AdminRights UserRight;
        /// <summary>
        /// 当前页的权限
        /// </summary>
        AdminRights.SystemRight thisRight = AdminRights.SystemRight.None;
        /// <summary>
        /// 页面加载之前的事件，主要是实例化已登录的用户和判断权限
        /// </summary>
        /// <param name="e"></param>
        protected override void OnPreLoad(EventArgs e)
        {
            base.OnPreLoad(e);
            user = Session["user"] as VGShop.Entity.Admin;
            if (user == null)
            {
                System.Configuration.AppSettingsReader asr = new System.Configuration.AppSettingsReader();
                string loginPage = asr.GetValue("loginPage", typeof(string)).ToString();
                Response.Write(string.Format("<script>top.location.href='/admin/{0}';</script>", loginPage));
                Response.End();
            }
            List<Entity.Rights> allRighs = new List<Entity.Rights>();//数据库中所有的权限列表
            user.RightList = this.GetAdminRights(user, ref allRighs);  //查询管理员的权限列表
            bool result = this.CheckUrl(Request.Url, user.RightList, allRighs);   // 页面权限
            if (user.AdminType == 0)    //如果是普通管理员，则检查权限
            {
                this.UpAdmin();             //检查当前管理员信息是否被修改过
                if (!result)
                {
                    string js = "<script>var noneRightTip = {msg:\"<font color='blue'>您没有权限访问本页，请联系管理员！<br />本页地址：\"+location.href+\"</font>\",fun:function(){}};if (parent.$ && parent.$.jBox) {parent.$.jBox.closeTip();parent.$.jBox.error(noneRightTip.msg, \"无权访问\",{closed:noneRightTip.fun,500});} else {if(!alert(noneRightTip.msg)){noneRightTip.fun();};}</script>";
                    Response.Write(js);
                    Response.End();
                    return;
                }
            }
            UserRight = new AdminRights(user.RightList, user.AdminType == 1);   //用户的权限用于页面上
            UserRight.CurrentPageRight = thisRight;
        }

        /// <summary>
        /// 检查地址是否有权限
        /// </summary>
        /// <param name="url">地址</param>
        /// <param name="list">用户的权限列表</param>
        /// <returns></returns>
        bool CheckUrl(Uri url, List<Entity.Rights> list, List<Entity.Rights> allRights)
        {
            if (url == null)    //如果地址为空，则返回false
                return false;
            string lastUrl = url.AbsolutePath.TrimStart('/').ToLower();
            var rightList = allRights.Where(a => a.Path.TrimStart('/').ToLower() == lastUrl);
            int count = rightList.Count();
            if (count == 0) //根据当前地址没有找到对应的权限时，则本地址没有权限访问
                return false;
            NameValueCollection cols = new NameValueCollection();
            #region 获取参数对
            if (!url.Query.IsNullOrWhiteSpace())
            {
                string[] arr = url.Query.TrimStart('?').Split('&');
                foreach (var item in arr)
                {
                    if (!item.IsNullOrWhiteSpace())
                    {
                        string[] temp = item.Split('=');
                        if (temp.Length == 2)
                        {
                            cols.Add(temp[0].ToLower(), temp[1]);
                        }
                    }
                }
            }
            #endregion
            #region 验证权限
            Dictionary<int, int> dic = new Dictionary<int, int>();  //Key:正面循环中的i，Value:i对应的权限匹配的参数个数
            for (int i = 0; i < count; i++)
            {
                int correct = 0;    //已经匹配正确的参数数量
                bool result = false;
                int ruleContainsKey = 0;
                var current = rightList.ElementAt(i);   //当前循环的权限
                result = this.CheckParamAndValue(cols, current.Param1, current.Value1, ref ruleContainsKey); //检查参数1
                if (!result)    //不匹配
                    continue;
                correct += ruleContainsKey;
                result = this.CheckParamAndValue(cols, current.Param2, current.Value2, ref ruleContainsKey); //检查参数2
                if (!result)    //不匹配
                    continue;
                correct += ruleContainsKey;
                result = this.CheckParamAndValue(cols, current.Param3, current.Value3, ref ruleContainsKey); //检查参数3
                if (!result)    //不匹配
                    continue;
                correct += ruleContainsKey;
                result = this.CheckParamAndValue(cols, current.Param4, current.Value4, ref ruleContainsKey); //检查参数4
                if (!result)    //不匹配
                    continue;
                correct += ruleContainsKey;
                dic.Add(i, correct);
            }
            if (dic.Count > 0)
            {
                //Response.Write("<script>alert('匹配的权限有"+dic.Count+"个');</script>");
                int index = dic.OrderByDescending(a => a.Value).First().Key;  //如果有多个相匹配的权限，则取匹配参数最多的一个
                Entity.Rights right = rightList.ElementAt(index);
                if (list.Exists(a => a.RightID == right.RightID))   //如果当前筛选出的权限在用户的权限中，则说明用户有权限，否则说明用户没有该权限
                {
                    thisRight = (AdminRights.SystemRight)Enum.Parse(typeof(AdminRights.SystemRight), right.Code, true);
                    return true;
                }
            }
            #endregion
            return false;
        }
        /// <summary>
        /// 检查该权限的指定参数是否匹配规则，如果权限中不包含该参数，则false，包含且值不能匹配也为false
        /// </summary>
        /// <param name="cols">当前地址请求中的所有参数和参数名</param>
        /// <param name="key">权限中的参数名</param>
        /// <param name="rule">权限中的参数值的规则</param>
        /// <param name="ruleContainsKey">规则中是是否存在该参数</param>
        /// <returns></returns>
        bool CheckParamAndValue(NameValueCollection cols, string key, string rule, ref int ruleContainsKey)
        {
            ruleContainsKey = 0;
            bool result = true; //默认匹配
            if (!key.IsNullOrWhiteSpace()) // 1) 如果权限中该参数不为空
            {
                string val = cols.Get(key.ToLower());
                if (val != null)          // 2) 如果请求的地址中存在该参数
                {
                    ruleContainsKey = 10;   //如果请求的地址中确实存在该参数，则增量为10
                    if (!rule.IsNullOrWhiteSpace()) // 3) 如果权限中规则不为空，则用正则匹配
                    {
                        result = Regex.IsMatch(val, rule, RegexOptions.IgnoreCase);
                    }
                }
                else                      // 2) 如果请求的地址中不存在该参数，则不匹配
                {
                    result = false;
                    //如果规则为空，或者可以匹配空字符串，说明参数允许为空，此时也认为请求的地址中包含该参数，此时为真
                    if (rule.IsNullOrWhiteSpace() || (!rule.IsNullOrWhiteSpace() && Regex.IsMatch(string.Empty, rule, RegexOptions.IgnoreCase)))
                    {
                        ruleContainsKey = 1;//如果请求的地址中并没有该参数，但因为参数可匹配空字符串，则增量为1
                        result = true;
                    }
                }
            }
            return result;
        }
        /// <summary>
        /// 查询管理员的权限列表
        /// </summary>
        /// <param name="user">管理员</param>
        /// <param name="rights">系统中所有权限的列表（不论当前用户有没有）</param>
        private List<Entity.Rights> GetAdminRights(Entity.Admin user, ref List<Entity.Rights> rights)
        {
            List<Entity.Rights> list = null;
            if (user.AdminType == 1)
            {
                rights = list = VGShop.Factory.BLLFactory.CreateRights().GetList(true);    //取得所有权限的列表
            }
            else
            {
                string key = string.Format("admin_rights_{0}", user.AdminID);
                list = Common.CacheAccess.GetCache(key) as List<Entity.Rights>;
                rights = VGShop.Factory.BLLFactory.CreateRights().GetList(true);    //取得所有权限的列表
                if (list == null)
                {
                    var bll = VGShop.Factory.BLLFactory.CreateRightMaps();
                    List<Entity.RightMaps> roleMaps = bll.GetList(user.RoleIDList, true);   //角色的所有权限
                    List<Entity.RightMaps> userMaps = bll.GetList(user.AdminID, false, true);   //用户的所有权限
                    List<Entity.RightMaps> maps = roleMaps.Union(userMaps).Where(a => !userMaps.Exists(b => b.RightID == a.RightID && b.Forbid)).Distinct(a => a.RightID).ToList();    //得到当前管理员最终的权限映射关系
                    list = rights.Where(a => (!a.Lowest && maps.Exists(b => b.RightID == a.RightID)) || a.Lowest).ToList();   //得到当前管理员最终的所有权限
                    Common.CacheAccess.SetCache(key, list);
                }
            }
            return list;
        }
        /// <summary>
        /// 处理页面异常
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void Page_Error(object sender, EventArgs e)
        {
            Exception ex = Server.GetLastError();
            Tools.WriteErrorLog(ex, true);
            if (ex is HttpRequestValidationException)
            {
                Response.Write("<h1 style='margin:100px 0 0 0;text-align:center;top:100px'>发生一个错误！<a href='javascript:history.go(-1)'>后退</a></h1>");
                Response.Write("<label style=\"color:Red;\">" + HttpUtility.HtmlEncode(ex.Message) + "</label>");
                Server.ClearError(); // 如果不ClearError()这个异常会继续传到Application_Error()。
            }
        }

        /// <summary>
        /// 输出站点地图和禁用缓存
        /// </summary>
        /// <param name="writer"></param>
        protected override void Render(HtmlTextWriter writer)
        {
            base.Render(writer);
            var node = SiteMap.CurrentNode;
            if (node != null)
            {
                string script = string.Format("<script defer='defer'>var pagebar=document.getElementById('titleBar');if(pagebar){{pagebar.innerHTML='<img height=\"20\" src=\"' + location.protocol + '//' + location.host + '/{0}/skin/Default/Images/home.png\" width=\"20\" /><a href=\"#\" title=\"Billion牛仔\">Billion牛仔</a>&gt;&gt;<a href=\"#\">{1}</a> &gt;&gt; <a href=\"#\">{2}</a> ';}}</script>", "Admin", node.ParentNode.Title.ClearHtmlTag().ReplaceHtmlTag(), node.Title.ClearHtmlTag().ReplaceHtmlTag());
                writer.WriteLine(script);
            }
            //禁止缓存
            Response.Cache.SetCacheability(HttpCacheability.NoCache);
            Response.Expires = 0;
            Response.Buffer = true;
            Response.ExpiresAbsolute = DateTime.Now.AddSeconds(-1);
            Response.AddHeader("pragma", "no-cache");
            Response.CacheControl = "no-cache";

        }
        /// <summary>
        /// 进行信息更新，判断是否进入被修改名单，是：查询最新信息写入Session，否：不操作。
        /// </summary>
        void UpAdmin()
        {
            List<int> loginUserList = Application["loginUserList"] as List<int> ?? new List<int>();
            //是否被修改了
            if (loginUserList.Contains(user.AdminID))
            {
                user = VGShop.Factory.DALFactory.CreateAdmin().GetModelByLoginName(user.LoginName);
                loginUserList.Remove(user.AdminID);
                Application.Lock();
                Application["loginUserList"] = loginUserList;
                Application.UnLock();
                Session.Add("user", user);
            }
        }
    }
    /// <summary>
    /// 系统权限
    /// </summary>
    public class AdminRights
    {
        List<Entity.Rights> myRights = null;
        bool isSuper = false;
        /// <summary>
        /// 当前管理员的全部权限
        /// </summary>
        public List<Entity.Rights> AllRights
        {
            get { return myRights; }
        }
        /// <summary>
        /// 带参数构造参数
        /// </summary>
        /// <param name="rights">管理员的权限</param>
        /// <param name="superAdmin">是否超级管理员</param>
        public AdminRights(List<Entity.Rights> rights, bool superAdmin)
        {
            myRights = rights;
            isSuper = superAdmin;
        }
        /// <summary>
        /// 根据权限代码判断是否拥有该权限，超级管理员输入任意代码均返回true
        /// </summary>
        /// <param name="key">权限代码，不区分大小写，即Rights.Code</param>
        /// <returns>是否拥有该权限</returns>
        public bool this[string key]
        {
            get
            {
                if (isSuper)
                    return true;
                return myRights.Exists(a => a.Code.Equals(key, StringComparison.CurrentCultureIgnoreCase));
            }
        }
        /// <summary>
        /// 当前页面权限枚举
        /// </summary>
        public SystemRight CurrentPageRight { set; get; }
        #region 权限枚举
        /// <summary>
        /// 权限枚举
        /// </summary>
        public enum SystemRight
        {
            /// <summary>
            /// 无权限
            /// </summary>
            None
            #region 下面的枚举是从数据库中读取出来生成的，因为太长，就不贴出来了
            
            #endregion
        }
        #endregion
    }
}

六，总结
优点：访问页面时，参数位置可以随意调整，不参与权限判断的参数可以任意增减，并不影响权限，就是说访问页面地址比较灵活。

同一个页面根据不同参数可以分配成不同权限，像添加/修改这样的页面可以做成一个页面，根据参数来区分权限。

缺点：每增加一个页面，都要到数据库中添加权限代码，权限枚举也要重新生成（不是手动写的，太长了）。

页面上功能级权限任需要在页面上手写权限代码来判断权限，如下图：

 /// <summary>
        /// 验证权限
        /// </summary>
        private void CheckRight()
        {
            this.btnAddItem.Visible = UserRight["goods_goodsAdd"];
            this.btnDelete.Visible = UserRight["G_Delete"];
            this.btnOn.Visible  = UserRight["goods_Check"];
            this.btnOff.Visible = UserRight["G_CancelSale"];
            this.btnSaveSort.Visible = UserRight["G_SaveSort"];
        }