为什么我们需要前端实现RBAC

在说我们前端为什么要实现权限控制之前，大家势必要了解一下我们要实现的东西的本质是什么，下面简单引用两句介绍：

RBAC 以角色为基础的访问控制（英语：Role-based access control，RBAC），RBAC认为权限授权实际上是Who、What、How的问题。在RBAC模型中，who、what、how构成了访问权限三元组,也就是“Who对What(Which)进行How的操作”。 RBAC是一种思想，任何编程语言都可以实现，其成熟简单的控制思想 越来越受广大开发人员喜欢。

更多内容，请大家不熟悉的势必自行google；
我认为前后端是相辅相成的，所以要做好前端的权限控制，如果能提前了解后端的权限分配规则和数据结构是能够更好的进行相互配合的，当然如果完全不理会后台的权限划分，硬性来做上面的两个需求也是能实现的，只是不掌握全局，就很难理解这样做的意义何在，所以建议大家在考虑这个问题的时候（这里指前端同学），还是要大概去看看RBAC的概念，属性经典的表结构，从而属性后台权限分别的业务规则。
“权限管理”一般大家的印象中都属于后端的责任，但是这两年随着SPA应用的兴起，很多应用都采用了前后端分离的方式进行开发，但是纯前端的开发方式就导致很多以前由后端模板语言硬件解决的问题，现在势必要重新造一次轮子，而这个时候前端我认为是配合后端对应语言的安全框架根据自身的业务需要来实现，在这里就说说我们的需求：

  1. 完善我们自己的Vue插件vue-viewplus的业务模块（这个插件是我们经过一年的内部使用，用来将一些开发应用所需的公共需求，抽取为一个个模块，方便进行快速的应用开发所写）
  2. 我们认为如果在前端根据后端配置的权限规则就能拦截一些不必要的请求，就能减少后端不必要的资源损耗，也能更快的提示正常用户
  3. 我们需要解决管理端界面菜单和按钮根据后端权限配置隐藏显示的需求
  4. 我们需要解决前端视图可访问性根据后端权限配置动态调整的需求

以上2、3、4点在前后端不曾分离的时候，这些事情都是由后类html模板语言（如传统的java中的jsp）所包办的，类似这样：

  1. <html>
  2. <sec:authorize access="hasRole('supervisor')">
  3. This content will only be visible to users who have
  4. the "supervisor" authority in their list of <tt>GrantedAuthority</tt>s.
  5. </sec:authorize>
  6. </html>
  7. 复制代码

docs.spring.io/spring-secu…

实现目标

  • 我们希望在进行页面导航的时候能先根据登录用户所具有的权限判断用户是否能访问该页面
  • 实现可见页面的局部UI组件的可使用性或可见性控制，即基于自定义v-access指令，对比声明的接口或资源别是否已经授权
  • 实现发送请求前对待请求接口进行权限检查，如果用户不具有访问该后端接口的权限，则不发送请求，而是友好的提示用户

    实现方式

    要实现【我们希望在进行页面导航的时候能先根据登录用户所具有的权限判断用户是否能访问该页面】这个目标，我们的方案是：
  1. 获得登录用户的可访问前端页面的path列表
  2. 一个公共的path列表
  3. 在router进行导航的beforeEach前置钩子中判断当前用户所请求的页面是否在以上两个集合之中，如果是则放行，如果不是，则通知插件调用方，让其自己处理失败的情况

下面是代码实现：

  1. /**
  2.  * RBAC权限控制模块
  3.  */
  4. import _ from 'lodash';
  5. let _onPathCheckFail
  6. let _publicPaths = []
  7. let _authorizedPaths = []
  8. /**
  9.  * 是否是【超级管理员】
  10.  * 如果登录用户是这个`角色`，那么就无需进行各种授权控制检测
  11.  * @type {boolean}
  12.  * @private
  13.  */
  14. let _superAdminStatus = false
  15. const _compare = function(rule, path) {
  16.   let temp = false
  17.   if (_.isRegExp(rule)) {
  18.     temp = rule.test(path)
  19.   } else {
  20.     temp = _.isEqual(path, rule)
  21.   }
  22.   return temp
  23. }
  24. /**
  25.  * 检测登录用户是否具有访问对应页面的权限
  26.  * 1.校验是否登录
  27.  * 2.校验带访问的页面是否在`loginStateCheck#authorizedPaths`授权`paths`集合中
  28.  * @param to
  29.  * @param from
  30.  * @param next
  31.  * @private
  32.  */
  33. const _rbacPathCheck = function(to, from, next) {
  34.   if (_superAdminStatus) {
  35.     next();
  36.     return;
  37.   }
  38.   try {
  39.     // 默认认为所有资源都需要进行权限控制
  40.     let isAllow = false
  41.     const path = to.path;
  42.     // 先检测公共页面集合
  43.     const publicPathsLength = _publicPaths.length
  44.     for (let i = publicPathsLength; i--;) {
  45.       const rule = _publicPaths[i];
  46.       isAllow = _compare(rule, path)
  47.       if (isAllow) {
  48.         break;
  49.       }
  50.     }
  51.     // 非公共页面 && 已经登录
  52.     if (!isAllow && this.isLogin()) {
  53.       // 检测已授权页面集合
  54.       const authorizedPathsLength = _authorizedPaths.length;
  55.       for (let i = authorizedPathsLength; i--;) {
  56.         const rule = _authorizedPaths[i];
  57.         isAllow = _compare(rule, path);
  58.         if (isAllow) {
  59.           break;
  60.         }
  61.       }
  62.     }
  63.     if (isAllow) {
  64.       next();
  65.     } else {
  66.       if (_.isFunction(_onPathCheckFail)) {
  67.         if (_debug) {
  68.           console.error(`[v+] RBAC模块检测：用户无权访问【${path}】，回调onPathCheckFail钩子`);
  69.         }
  70.         this::_onPathCheckFail(to, from, next);
  71.       } else {
  72.         next(new Error('check_authorize_paths_fail'));
  73.       }
  74.     }
  75.   } catch (e) {
  76.     if (_debug) {
  77.       console.error(`[v+] RBAC模块检测出错: ${e.message}`);
  78.     }
  79.     if (_.isFunction(_errorHandler)) {
  80.       this::_errorHandler(e)
  81.     }
  82.   }
  83. };
  84. const rbacModel = {
  85.   /**
  86.    * 【可选】有些系统存在一个超级用户角色，其可以访问任何资源、页面，故如果设置，针对这个登录用户将不会做任何权限校验，以便节省前端资源
  87.    * @param status
  88.    */
  89.   rabcUpdateSuperAdminStatus(status) {
  90.     _superAdminStatus = status;
  91.     this.cacheSaveToSessionStore('AUTHORIZED_SUPER_ADMIN_STATUS', _superAdminStatus)
  92.   },
  93.   /**
  94.    * 添加授权路径集合
  95.    * 如：登录完成之后，将用户被授权可以访问的页面`paths`添加到`LoginStateCheck#authorizedPaths`中
  96.    * @param paths
  97.    */
  98.   rabcAddAuthorizedPaths(paths) {
  99.     this::rbacModel.rabcUpdateAuthorizedPaths(_.concat(_authorizedPaths, paths))
  100.   },
  101.   /**
  102.    * 更新授权路径集合
  103.    * @param paths
  104.    */
  105.   rabcUpdateAuthorizedPaths(paths) {
  106.     _authorizedPaths = [...new Set(paths)]
  107.     this.cacheSaveToSessionStore('AUTHORIZED_PATHS', _authorizedPaths)
  108.   },
  109.   /**
  110.    * 更新公共路径集合
  111.    * @param paths
  112.    */
  113.   rabcUpdatePublicPaths(paths) {
  114.     _publicPaths = [...new Set(paths)];
  115.     this.cacheSaveToSessionStore('PUBLIC_PATHS', _publicPaths)
  116.   },
  117.   /**
  118.    * 添加公共路径集合
  119.    * @param paths
  120.    */
  121.   rabcAddPublicPaths(paths) {
  122.     this::rbacModel.rabcUpdatePublicPaths(_.concat(_publicPaths, paths))
  123.   },
  124.   install(Vue, {
  125.     /**
  126.      * [*] 系统公共路由path路径集合，即可以让任何人访问的页面路径
  127.      * {Array<Object>}
  128.      * <p>
  129.      *   比如登录页面的path，因为登录之前我们是无法判断用户是否可以访问某个页面的，故需要这个配置，当然如果需要这个配置也可以在初始化插件之前从服务器端获取，这样前后端动态性就更高，但是一般没有这种需求：）
  130.      * <p>
  131.      * 数组中的item，可以是一个**正则表达式字面量**，如`[/^((\/Interbus)(?!\/SubMenu)\/.+)$/]`，也可以是一个字符串
  132.      * <p>
  133.      * 匹配规则：如果在`LoginStateCheck#publicPaths`**系统公共路由path路径集合**中，那么就直接跳过权限校验
  134.      */
  135.     publicPaths = [],
  136.     /**
  137.      * [*] 登录用户拥有访问权限的路由path路径集合
  138.      * {Array<Object>}
  139.      * <p>
  140.      * 数组中的item，可以是一个**正则表达式字面量**，如`[/^((\/Interbus)(?!\/SubMenu)\/.+)$/]`，也可以是一个字符串
  141.      * <p>
  142.      * 匹配规则：如果在`LoginStateCheck#authorizedPaths`**需要身份认证规则集**中，那么就需要查看用户是否登录，如果没有登录就拒绝访问
  143.      */
  144.     authorizedPaths = [],
  145.     /**
  146.      * [*] `$vp::onPathCheckFail(to, from, next)`
  147.      * <p>
  148.      * 访问前端页面时权限检查失败时被回调
  149.      */
  150.     onPathCheckFail = null,
  151.   } = {}) {
  152.     _onPathCheckFail = onPathCheckFail;
  153.     router.beforeEach((to, from, next) => {
  154.       this::_rbacPathCheck(to, from, next);
  155.     });
  156.   }
  157. };
  158. export default rbacModel;
  159. 复制代码

这里解释一下：

  1. 整个代码最终导出了一个普通的json对象，作为vue-viewplus的一个自定义模块，将会被mixin到其插件内部作为一个自定义模块：

    1. // 应用入口mian.js
    2. import Vue from 'vue'
    3. import router from './router'
    4. import ViewPlus from 'vue-viewplus'
    5. import viewPlusOptions from '@/plugin/vue-viewplus'
    6. import rbacModule from '@/plugin/vue-viewplus/rbac.js'
    7. Vue.use(ViewPlus, viewPlusOptions)
    8. ViewPlus.mixin(Vue, rbacModule, {
    9. moduleName: '自定义RBAC',
    10. router,
    11. publicPaths: ['/login'],
    12. onPathCheckFail(to, from, next) {
    13.  NProgress.done()
    14.  const title = to.meta.title
    15.  this.dialog(`您无权访问【${_.isNil(title) ? to.path : title}】页面`)
    16.    .then(() => {
    17.      // 没有登录的时候跳转到登录界面
    18.      // 携带上登陆成功之后需要跳转的页面完整路径
    19.      next(false)
    20.    })
    21. }
    22. })
    23. 复制代码

  2. 大家如果没有使用或者不想使用这个插件（vue-viewplus也无所谓，这里只要知道，导出的这个对象的install会在应用入口被调用，并传入几个install方法几个必须的参数：

    • 路由对象
    • 应用的公共页面paths列表
    • 权限校验失败之后的处理函数
  3. 这样我们就能在初始化函数中缓存应用公共页面paths列表，注册路由钩子，监听路由变化。
    这里我使用这个插件为的还有第二个目的，利用其来管理用户登录状态，详细看下面我为什么要使用这个状态

  4. 在监听到某个公共页面访问的时候，_rbacPathCheck函数将会：

    • 首先判断当前用户是否是超级管理员，你可以理解为linux中的root用户，如果是则直接放行，这样做是为了减少判断带来的开销，当然如果需要实现这个效果，需要在登录之后，根据后端返回的用户信息中查看用户的角色，是否是超级管理员，如果是，则调用文件导出的rabcUpdateSuperAdminStatus方法，在这里是页面实例的this.$vp.rabcUpdateSuperAdminStatus方法（vue-viewplus将每个模块导出的api绑定到页面实例即vm的$vp属性之下）：

      1. // 登录页面提交按钮绑定方法
      2. submit() {
      3.  this.$refs.loginForm.validate(valid => {
      4.    if (valid) {
      5.      // 登录
      6.      this.login({
      7.        vm: this,
      8.        username: this.formLogin.username,
      9.        password: this.formLogin.password,
      10.        imageCode: this.formLogin.code
      11.      }).then((res) => {
      12.        // 修改用户登录状态
      13.        this.$vp.modifyLoginState(true);
      14.        // 解析服务端返回的登录用户数据，得到菜单、权限相关数据
      15.        const isSuperAdminStatus = parseUserRoleIsSuperAdminStatus(res.principal.admin.roles);
      16.        this.$vp.toast('登录成功', {
      17.          type: 'success'
      18.        });
      19.        // 重定向对象不存在则返回顶层路径
      20.        this.$router.replace(this.$route.query.redirect || '/')
      21.      })
      22.    } else {
      23.      // 登录表单校验失败
      24.      this.$message.error('表单校验失败')
      25.    }
      26.  })
      27. }
      28. 复制代码

    • 如果不是则检测待访问的页面的path是否在应用的公共页面paths列表_publicPaths中，如果是则放行
      而做这个判断的前提是应用登录成功之后需要将其获得授权的前端paths设置this.$vp.rabcUpdateAuthorizedPaths给插件：

      1. submit() {
      2.  this.$refs.loginForm.validate(valid => {
      3.    if (valid) {
      4.      // 登录
      5.      this.login({
      6.        vm: this,
      7.        username: this.formLogin.username,
      8.        password: this.formLogin.password,
      9.        imageCode: this.formLogin.code
      10.      }).then((res) => {
      11.        this.$vp.rabcUpdateAuthorizedPaths(authorizeResources.paths);
      12.      })
      13.    } else {
      14.      // 登录表单校验失败
      15.      this.$message.error('表单校验失败')
      16.    }
      17.  })
      18. }
      19. 复制代码

    • 数据的格式如下：

      1. ["/mngauth/admin", "/index", "/mngauth"]
      2. 复制代码

    • 并且，数组的值支持为正则表达式；

    • 如果不是则检查待访问页面的path是否在登录用户拥有访问权限的路由path路径集合_authorizedPaths中，如果是则放行，如果不是则整个校验结束，判断用户无权访问该页面，调用_onPathCheckFail回调函数，通知应用，这里应用则会打印dialog提示用户

  5. 因为我们的目的是抽象整个业务，所以这里才以回调的方式让应用有实际去感知和处理这一情况；
    这样我们就完成了第一个目标；

    要实现【实现可见页面的局部UI组件的可使用性或可见性控制，即基于自定义v-access指令，对比声明的接口或资源别是否已经授权】这个目标，我们的方案是：

  6. 获得登录用户的:

    • 被授权角色所拥有的资源列表，对应的资源别名
      数据格式类似：

      1. ["MNG_USERMNG", "MNG_ROLEMNG"]
      2. 复制代码

    • 被授权角色所拥有的资源列表（或资源）所对应的后端接口集合
      数据格式类似：

      1. ["admin/dels/*", "admin/search/*/*/*", "admin/*/*/*", "role/list/*", "admin/*"]
      2. 复制代码

    • 但是默认希望的是RESTful格式：

      1. [{url: "admin/dels/*", method: "DELETE"}, ....]
      2. 复制代码

    • 当然同样支持js正则表达式；

  7. 通过以上两组（二选一）授权数据，我们就可以对比用户在指令中声明的条件权限进行对比。
  8. 定义一个Vue指令，这里命名为access，其需要具备以下特点：
    • 可以让用户声明不同的权限表达式，如这个按钮是需要一组接口，还是一个资源别名
    • 可以让用户控制，在不满足权限检查之后，是让UI组件不显示还是让其不可用
  9. 当然要理解上面的数据结构后端是怎么构建的，可以参考表结构和权限说明

我们继续往上面的代码中添加逻辑，下面是代码实现：

  1. const rbacModel = {
  2.   //....
  3.   /**
  4.    * 更新授权接口集合
  5.    * @param interfaces
  6.    */
  7.   rabcUpdateAuthorizeInterfaces(interfaces) {
  8.     _authorizeInterfaces = [...new Set(interfaces)]
  9.     this.cacheSaveToSessionStore('AUTHORIZED_INTERFACES', _authorizeInterfaces)
  10.   },
  11.   /**
  12.    * 添加授权接口集合
  13.    * @param interfaces
  14.    */
  15.   rabcAddAuthorizeInterfaces(interfaces) {
  16.     this::rbacModel.rabcUpdateAuthorizeInterfaces(_.concat(_authorizeInterfaces, interfaces))
  17.   },
  18.   /**
  19.    * 更新资源别名集合
  20.    * @param alias
  21.    */
  22.   rabcUpdateAuthorizeResourceAlias(alias) {
  23.     _authorizeResourceAlias = [...new Set(alias)]
  24.     this.cacheSaveToSessionStore('AUTHORIZED_RESOURCE_ALIAS', _authorizeResourceAlias)
  25.   },
  26.   /**
  27.    * 添加资源别名集合
  28.    * @param alias
  29.    */
  30.   rabcAddAuthorizeResourceAlias(alias) {
  31.     this::rbacModel.rabcUpdateAuthorizeResourceAlias(_.concat(_authorizeResourceAlias, alias))
  32.   },
  33.   install(Vue, {
  34.     //....
  35.     /**
  36.      * [可选] 登录用户拥有访问权限的资源别名集合
  37.      * {Array<Object>}
  38.      * <p>
  39.      * 数组中的item，可以是一个**正则表达式字面量**，如`[/^((\/Interbus)(?!\/SubMenu)\/.+)$/]`，也可以是一个字符串
  40.      * <p>
  41.      * 匹配规则：因为如果都用`LoginStateCheck#authorizeInterfaces`接口进行匹配，可能有一种情况，访问一个资源，其需要n个接口，那么我们在配置配置权限指令：v-access="[n, n....]"的时候就需要声明所有需要的接口，就会需要对比多次，
  42.      * 当我们系统的接口集合很大的时候，势必会成为一个瓶颈，故我们可以为资源声明一个别名，这个别名则可以代表这n个接口，这样的话就从n+减少到n次匹配；
  43.      */
  44.     authorizeResourceAlias = [],
  45.     /**
  46.      * [*] 登录用户拥有访问权限的后台接口集合
  47.      * {Array<Object>}
  48.      * <p>
  49.      *   1.在`v-access`指令配置为url（默认）校验格式时，将会使用该集合和指令声明的待审查授权接口列表进行匹配，如果匹配成功，则指令校验通过，否则校验不通过，会将对应dom元素进行处理
  50.      *   2.TODO 将会用于在发送ajax请求之前，对待请求的接口和当前集合进行匹配，如果匹配失败说明用户就没有请求权限，则直接不发送后台请求，减少后端不必要的资源浪费
  51.      * <p>
  52.      * 数组中的item，可以是一个**正则表达式字面量**，如`[/^((\/Interbus)(?!\/SubMenu)\/.+)$/]`，也可以是一个字符串
  53.      * <p>
  54.      * 匹配规则：将会用于在发送ajax请求之前，对待请求的接口和当前集合进行匹配，如果匹配失败说明用户就没有请求权限，则直接不发送后台请求，减少后端不必要的资源浪费
  55.      * <p>
  56.      *   注意需要根据`isRESTfulInterfaces`属性的值，来判断当前集合的数据类型：
  57.      *
  58.      * 如果`isRESTfulInterfaces`设置为`false`，则使用下面的格式：
  59.      * ```json
  60.      * ["admin/dels/*", ...]
  61.      *
  1.  * 如果`isRESTfulInterfaces`设置为`true`，**注意这是默认设置**，则使用下面的格式：
  2.  * ```json
  3.  * [[{url: "admin/dels/*", method: "DELETE"}, ...]]
  4.  * ```
  5.  */
  6. authorizeInterfaces = [],
  7. /**
  8.  * [*] 声明`authorizeInterfaces`集合存储的是RESTful类型的接口还是常规接口
  9.  * 1. 如果是（true），则`authorizeInterfaces`集合需要存储的结构就是:
  10.  * [{url: 'admin/dels/*', method: 'DELETE'}]
  11.  * 即进行接口匹配的时候会校验类型
  12.  * 2. 如果不是（false），则`authorizeInterfaces`集合需要存储的结构就是，即不区分接口类型:
  13.  * ['admin/dels/*']
  14.  */
  15. isRESTfulInterfaces = true

} = {}) { //…. this::_createRBACDirective(Vue) } }; export default rbacModel; 复制代码

  1. 首先我们在插件中添加几个字段和对应的设置接口：
  3. - `isRESTfulInterfaces`
  4. - `authorizeInterfaces`
  5. - `authorizeResourceAlias`
  7. 这样我们就可以维护用户拥有的授权资源别名列表、资源（对应接口）后端接口数据列表，并默认认为接口为RESTful数据结构；<br />接着我们就可以定义指令（在插件初始化方法install中），并在指令的`bind`声明周期，解析对应UI组件声明的所需权限信息，并和持有的资源列表进行对比，如果对比失败则对UI组件做相应的显示或者`disable`操作：

/**

  • 推荐使用资源标识配置：v-access:alias[.disable]="'LOGIN'" 前提需要注入身份认证用户所拥有的授权资源标识集合，因为这种方式可以较少比较的次数
  • 传统使用接口配置：v-access:[url][.disable]="'admin'" 前提需要注入身份认证用户所拥有的授权接口集合
  • 两种都支持数组配置
  • v-access:alias[.disable]=”[‘LOGIN’, ‘WELCOME’]”
  • v-access:[url][.disable]=”[‘admin’, ‘admin/*’]”
  • 针对于RESTful类型接口：
  • v-access=”[{url: ‘admin/search/*’, method: ‘POST’}]”
  • 默认使用url模式，因为这种方式比较通用
  • v-access=”[‘admin’, ‘admin/*’]”

  • 其中[.disbale]用来标明在检测用户不具有对当前声明的权限时，将会把当前声明指令的el元素添加el.disabled = true，默认则是影藏元素：el.style.display = 'none'

  • 举例：<el-form v-access="['admin/search']" slot="search-inner-box" :inline="true" :model="searchForm" :rules="searchRules" ref="ruleSearchForm" class="demo-form-inline">...</el-form>
  • 上面这个检索表单需要登录用户具有访问'admin/search'接口的权限，才会显示
  • @param Vue
  • @private */ const _createRBACDirective = function(Vue) { Vue.directive(‘access’, { bind: function(el, { value, arg, modifiers }) { if (_superAdminStatus) {
    1.  return;
    } let isAllow = false const statementAuth = _parseAccessDirectiveValue2Arr(value) switch (arg) {
    1.  case 'alias':
    2.    isAllow = _checkPermission(statementAuth, _authorizeResourceAlias)
    3.    break
    4.  // 默认使用url模式
    5.  case 'url':
    6.  default:
    7.    if (_isRESTfulInterfaces) {
    8.      isAllow = _checkPermissionRESTful(statementAuth, _authorizeInterfaces)
    9.    } else {
    10.      isAllow = _checkPermission(statementAuth, _authorizeInterfaces)
    11.    }
    } if (!isAllow) {
    1.  if (_debug) {
    2.    console.warn(`[v+] RBAC access权限检测不通过：用户无权访问【${_.isObject(value) ? JSON.stringify(value) : value}】`);
    3.  }
    4.  if (_.has(modifiers, 'disable')) {
    5.    el.disabled = true;
    6.    el.style.opacity = '0.5'
    7.  } else {
    8.    el.style.display = 'none';
    9.  }
    } } }) } /**
  • 校验给定指令显示声明所需列表是否包含于身份认证用户所具有的权限集合中，如果是则返回true标识权限校验通过
  • @param statementAuth
  • @param authorizeCollection
  • @returns {boolean}
  • @private / const _checkPermission = function(statementAuth, authorizeCollection) { let voter = [] statementAuth.forEach(url => { voter.push(authorizeCollection.includes(url)) }) return !voter.includes(false) } /*
  • {@link _checkPermission} 附加了对接口类型的校验
  • @param statementAuth
  • @param authorizeCollection
  • @returns {boolean}
  • @private */ const checkPermissionRESTful = function(statementAuth, authorizeCollection) { let voter = [] const expectedSize = statementAuth.length const size = authorizeCollection.length for (let i = 0; i < size; i++) { const itf = authorizeCollection[i] if (.find(statementAuth, itf)) { voter.push(true) // 移除判断成功的声明权限对象 statementAuth.splice(i, 1) } } // 如果投票得到的true含量和需要判断的声明权限长度一致，则标识校验通过 return voter.length === expectedSize } const parseAccessDirectiveValue2Arr = function(value) { let params = [] if (.isString(value) || .isPlainObject(value)) { params.push(value) } else if (.isArray(value)) { params = value } else { throw new Error(‘access 配置的授权标识符不正确，请检查’) } return params } 复制代码
    1. 在使用指令之前，我们还需要解决插件所需权限列表的设置：
    submit() { this.$refs.loginForm.validate(valid => {
    1.  if (valid) {
    2.    // 登录
    3.    this.login({
    4.      vm: this,
    5.      username: this.formLogin.username,
    6.      password: this.formLogin.password,
    7.      imageCode: this.formLogin.code
    8.    }).then((res) => {
    9.      // 修改用户登录状态
    10.      this.$vp.modifyLoginState(true);
    11.      //...
    12.      const authorizeResources = parseAuthorizePaths(res.principal.admin.authorizeResources);
    13.      this.$vp.rabcUpdateAuthorizeResourceAlias(authorizeResources.alias);
    14.      const authorizeInterfaces = parseAuthorizeInterfaces(res.principal.admin.authorizeInterfaces);
    15.      this.$vp.rabcUpdateAuthorizeInterfaces(authorizeInterfaces);
    16.        //...
    17.  }
    }) } 复制代码
    1. 这里的`parseAuthorizePaths`和`parseAuthorizeInterfaces`的作用是解析后端返回的登录用户资源和接口列表，这个因人而异，就不贴了；<br />还需要注意的一点就是，`this.$vp.modifyLoginState(true)`，是vue-viewplus插件登录身份控制模块所提供的一个接口，其可以为应用维护登录状态，比如在监控到后端返回会话超时时候**自动**将状态设置为`false`，更多请查看*[这里](http://jiiiiiin.cn/vue-viewplus/#/login-state-check?id=login-state-checkjs)*，这也是逻辑复用的一个好处了；<br />当然如果你只是想实现自己的权限控制模块，并不想抽象的这么**简单**，也可以硬编码到项目中；<br />这样我们就完成了第二个目标；<br />哦哦哦忘了写一下，我们怎么用这个指令了，补充一下：
    //… 复制代码 `` 上面是一个最简单的例子，即声明，如果要使用该检索功能，需要用户拥有：{url: ‘admin/search///*’, method: ‘POST’`这个接口权限；
    另外指令的更多声明方式，请查看这里
    要【实现发送请求前对待请求接口进行权限检查，如果用户不具有访问该后端接口的权限，则不发送请求，而是友好的提示用户】这个目标，我们的方案是：
  1. 获得登录用户的:
    • 被授权角色所拥有的资源列表（或资源）所对应的后端接口集合，这一步在实现第二个目标的时候已经完成，即在登录成功之后：this.$vp.rabcUpdateAuthorizeInterfaces(authorizeInterfaces);，这里只要复用即可
  2. 拦截请求，这里我们应用请求都是基于vue-viewplus的util-http.js 针对axios进行了二次封装的ajax模块来发送，它的好处是我80%的请求接口不用单独写错误处理代码，而是由改模块自动处理了，回到正题，我们怎么拦截请求，因为该ajax插件底层使用的是axios，对应的其提供了我们拦截请求的钩子https://github.com/Jiiiiiin/jiiiiiin-security#表结构和权限说明)
    在具备以上条件之后我们好像就可以写代码了，嘿嘿：）

我们继续往上面的代码中添加逻辑，下面是代码实现：

  1. const rbacModel = {
  2.   //...
  3.   install(Vue, {
  4.     //...
  5.     /**
  6.      * [*] `$vp::onPathCheckFail(to, from, next)`
  7.      * <p>
  8.      * 发送ajax请求时权限检查失败时被回调
  9.      */
  10.     onAjaxReqCheckFail = null
  11.   } = {}) {
  12.     _onAjaxReqCheckFail = onAjaxReqCheckFail;
  13.     this::_rbacAjaxCheck()
  14.   }
  15. };
  16. 复制代码

还是在插件对象中，首先声明了所需配置的onAjaxReqCheckFail，其次调用_rbacAjaxCheck进行axios拦截声明：

  1. /**
  2.  * 用于在发送ajax请求之前，对待请求的接口和当前集合进行匹配，如果匹配失败说明用户就没有请求权限，则直接不发送后台请求，减少后端不必要的资源浪费
  3.  * @private
  4.  */
  5. const _rbacAjaxCheck = function() {
  6.   this.getAjaxInstance().interceptors.request.use(
  7.     (config) => {
  8.       const { url, method } = config
  9.       const statementAuth = []
  10.       let isAllow
  11.       if (_isRESTfulInterfaces) {
  12.         const _method = _.toUpper(method)
  13.         statementAuth.push({ url, method: _method });
  14.         isAllow = _checkPermissionRESTful(statementAuth, _authorizeInterfaces)
  15.         // TODO 因为拦截到的请求`{url: "admin/0/1/10", method: "GET"}` 没有找到类似java中org.springframework.util.AntPathMatcher;
  16.         // 那样能匹配`{url: "admin/*/*/*", method: "GET"}`，的方法`temp = antPathMatcher.match(anInterface.getUrl(), reqURI)`
  17.         // 故这个需求暂时没法实现 ：）
  18.         console.log('statementAuth', isAllow, statementAuth, _authorizeInterfaces)
  19.       } else {
  20.         isAllow = _checkPermission(statementAuth, _authorizeInterfaces)
  21.       }
  22.       if (isAllow) {
  23.         return config;
  24.       } else {
  25.         if (_debug) {
  26.           console.warn(`[v+] RBAC ajax权限检测不通过：用户无权发送请求【${method}-${url}】`);
  27.         }
  28.         if (_.isFunction(_onAjaxReqCheckFail)) {
  29.           this::_onAjaxReqCheckFail(config);
  30.         } else {
  31.           throw new Error('check_authorize_ajax_req_fail');
  32.         }
  33.       }
  34.     },
  35.     error => {
  36.       return Promise.reject(error)
  37.     }
  38.   )
  39. }
  40. 复制代码

这里可能this.getAjaxInstance()不知道是什么，在调用_rbacAjaxCheck是我们指定了this，即this::_rbacAjaxCheck()，而这个this就是$vp对象，即vue-viewplus绑定到Vue实例的$vp属性；
其他的就很简单了，根据配置的_isRESTfulInterfaces属性看我们要校验的是RESTful接口还是普通接口，如果校验通过则返回axios所需请求config，如果失败则调用配置的_onAjaxReqCheckFail通知应用，让应用去处理权限失败的情况，一般也是弹出一个toast提示用户权限不足。
这样好像我们就完成了所有目标，哈哈哈。
写文章真是比敲代码累得多呀。
但是不幸的是我们并没有实现第三个目标，问题就在于，上面代码片段的TODO中所描述，我没有解决RESTful PathValue类型接口的权限对比，后端我用的库是通过：

  1. log.debug("内管权限校验开始：{} {} {}", admin.getUsername(), reqURI, reqMethod);
  2.                 for (Role role : roles) {
  3.                     boolean temp;
  4.                     for (Resource resource : role.getResources()) {
  5.                         for (Interface anInterface : resource.getInterfaces()) {
  6.                             temp = antPathMatcher.match(anInterface.getUrl(), reqURI) && reqMethod.equalsIgnoreCase(anInterface.getMethod());
  7.                             if (temp) {
  8.                                 hasPermission = true;
  9.                                 break;
  10.                             }
  11.                         }
  12.                     }
  13.                 }
  14. 复制代码

org.springframework.util.AntPathMatcher提供的方法来完成的，但是js我没有找到合适的库来对比：

  1. {url: "admin/*/*/*", method: "GET"} <> {url: "admin/0/1/10", method: "GET"}
  2. 复制代码

这样的两个对象，所以有耐心看到这里的朋友，如果你解决了这个问题，请联系我，谢谢。
谢谢你耐心的看到这里，如果觉得对你有所帮助，请帮忙支持一下我的两个项目：
vue-viewplus
jiiiiiin-security

作者：赵津
链接：https://juejin.im/post/5c1f8d6c6fb9a049e06353aa
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。