element-admin动态路由设置

阳光穿透心脏的1/2处 2023-09-23 18:10 6阅读 0赞

### 0 引言 ###

本篇文章是我在做element-admin-template的动态路由时所参考的文章，解决方案非常详细，只要由vue基础，按照这个步骤就可以完成路由的动态权限展示.

效果(我由admin和common两个用户权限):

`admin`

![image-20221130145900657][]

`common`

![image-20221130145827414][]

**文章原文链接**：[https://blog.csdn.net/qq\_41773806/article/details/121407661][https_blog.csdn.net_qq_41773806_article_details_121407661]

### 01 Bug 描述 ###

笔者基于简化版的 `vue-element-admin` 前端框架 `vue-admin-template` 进行二次开发。

我在项目中设定了三个用户角色，不同的角色具有不同的权限，也对应着不同的路由，同时侧边栏也需根据不同的权限异步生成。

我根据 `vue-element-admin` 作者的博客手摸手，带你用vue撸后台 系列二(登录权限篇)修改权限认证。大致过程分为如下四个步骤：

*  修改 `src/store/modules/user.js` 增加用户信息中角色的权限列表 roles
 *  修改 `src/router/index.js` 根据用户权限划分路由
 *  增加 `src/store/modules/permission.js` 通过获取当前用户的权限去比对路由表，生成当前用户具有访问权限的动态路由表
 *  修改 `src/permission.js` 通过 `router.addRoutes` 将用户可访问路由表动态挂载到 `router` 上

完成修改之后，我重启项目。但是发现页面没有动态渲染侧边栏，除了没有进行权限划分的页面，即 `constantRoutes` 中的路由可以访问，其他的页面都没有渲染出来。

### 02 动态路由修改过程 ###

为了找到bug出现的位置，我重新梳理了一遍基于 `vue-admin-template` 进行动态路由修改的过程。

#### 2.1 添加用户权限列表 ####

动态路由是根据用户权限划分的，所以要先修改 `src/store/modules/user.js` 增加用户信息中角色的权限列表 `roles`。

import {
         login, logout, getInfo } from '@/api/user'
    import {
         getToken, setToken, removeToken } from '@/utils/auth'
    import {
         resetRouter } from '@/router'
    
    const getDefaultState = () => {
        
      return {
        
        token: getToken(),
        name: '',
        avatar: '',
        introduction: '',
        roles: []                                             // 1. 添加权限列表 roles
      }
    }
    
    const state = getDefaultState()
    
    const mutations = {
        
      RESET_STATE: (state) => {
        
        Object.assign(state, getDefaultState())
      },
      SET_TOKEN: (state, token) => {
        
        state.token = token
      },
      SET_NAME: (state, name) => {
        
        state.name = name
      },
      SET_AVATAR: (state, avatar) => {
        
        state.avatar = avatar
      },
      SET_ROLES: (state, roles) => {
                                // 2. 添加 SET_ROLES 方法
        state.roles = roles
      }
    }
    
    const actions = {
        
      login({
          commit }, userInfo) {
        
        const {
         username, password } = userInfo
        return new Promise((resolve, reject) => {
        
          login({
         username: username.trim(), password: password }).then(response => {
        
            const {
         data } = response
            commit('SET_TOKEN', data.token)
            setToken(data.token)
            resolve()
          }).catch(error => {
        
            reject(error)
          })
        })
      },
    
      getInfo({
          commit, state }) {
        
        return new Promise((resolve, reject) => {
        
          getInfo(state.token).then(response => {
        
            const {
         data } = response
            if (!data) {
        
              reject('Verification failed, please Login again.')
            }
            const {
         roles, name, avatar, introduction } = data
            if (!roles || roles.length <= 0) {
        
              reject('getInfo: roles must be a non-null array!')
            }
            commit('SET_ROLES', roles)                     // 3. 从用户信息中获取用户权限列表roles
            commit('SET_NAME', name)
            commit('SET_AVATAR', avatar)
            commit('SET_INTRODUCTION', introduction)
            resolve(data)
          }).catch(error => {
        
            reject(error)
          })
        })
      },
    
      // user logout
      logout({
          commit, state }) {
        
        return new Promise((resolve, reject) => {
        
          logout(state.token).then(() => {
        
            removeToken()
            resetRouter()
            commit('RESET_STATE')
            commit('SET_ROLES', [])                      // 4. 退出登录把角色权限列表置为空
            resolve()
          }).catch(error => {
        
            reject(error)
          })
        })
      },
    
      // remove token
      resetToken({
          commit }) {
        
        return new Promise(resolve => {
        
          removeToken()
          commit('RESET_STATE')
          commit('SET_ROLES', [])                       // 4. 退出登录把角色权限列表置为空                    
          resolve()
        })
      }
    }
    
    export default {
        
      namespaced: true,
      state,
      mutations,
      actions
    }

同时要修改 `src/store/getters.js` 将拿到的用户roles权限列表设置到state中，并存储为全局变量

const getters = {
        
      sidebar: state => state.app.sidebar,
      device: state => state.app.device,
      token: state => state.user.token,
      avatar: state => state.user.avatar,
      name: state => state.user.name,
      roles: state => state.user.roles                 // 5. 将用户权限列表全局存储
    }
    export default getters

#### 2.2 根据用户权限划分路由 ####

定义好用户列表之后，根据需求设置路由进入的用户权限。

vue-element-admin 将路由分为两种，`constantRoutes` 和 `asyncRoutes`。

*  `constantRoutes`： 代表那些不需要动态判断权限的路由，如登录页、404、等通用页面。
 *  `asyncRoutes`： 代表那些需求动态判断权限并通过 addRoutes 动态添加的页面。

修改 `src/router/index.js` 根据用户权限划分路由如下：

import Vue from 'vue'
    import Router from 'vue-router'
    
    Vue.use(Router)
    
    import Layout from '@/layout'
    
    // 无权限路由
    export const constantRoutes = [
      {
        
        path: '/login',
        component: () => import('@/views/login/index'),
        hidden: true
      },
    
      {
        
        path: '/404',
        component: () => import('@/views/404'),
        hidden: true
      },
    
      {
        
        path: '/',
        component: Layout,
        redirect: '/home',
        children: [{
        
          path: 'home',
          name: 'Home',
          component: () => import('@/views/home/index'),
          meta: {
         title: '首页', icon: 'dashboard' }
        }]
      }
      // 注意不要把 404 放在这里，因为 asyncRoutes 中的路由是接在这后面的
    ]
    
    // 有权限动态路由
    export const asyncRoutes = [                           // 1. 添加有权限路由 asyncRoutes            
    {
        
        path: '/permission',
        component: Layout,
        redirect: '/permission/page',
        name: 'Permission',
        meta: {
        
          title: 'Permission',
          icon: 'lock',
          roles: ['admin', 'editor']                       // 2. 设置路由可进入权限列表
        },
        children: [
          {
        
            path: 'page',
            component: () => import('@/views/permission/page'),
            name: 'PagePermission',
            meta: {
        
              title: 'Page Permission',
              roles: ['admin']                            // 2. 设置路由可进入权限列表
            }
          },
          {
        
            path: 'directive',
            component: () => import('@/views/permission/directive'),
            name: 'DirectivePermission',
            meta: {
        
              title: 'Directive Permission'
              // 如果不设置权限，继承父路由的权限
            }
          },
          {
        
            path: 'role',
            component: () => import('@/views/permission/role'),
            name: 'RolePermission',
            meta: {
        
              title: 'Role Permission',
              roles: ['admin']                            // 2. 设置路由可进入权限列表
            }
          }
        ]
      },
    
      // 404 放在最后
      {
         path: '*', redirect: '/404', hidden: true }
    ]
    
    const createRouter = () => new Router({
        
      scrollBehavior: () => ({
         y: 0 }),
      routes: constantRoutes
    })
    
    const router = createRouter()
    
    export function resetRouter() {
        
      const newRouter = createRouter()
      router.matcher = newRouter.matcher // reset router
    }
     
    export default router

#### 2.3 根据用户权限生成动态路由表 ####

增加 `src/store/modules/permission.js` 通过获取当前用户的权限去比对路由表，生成当前用户具有访问权限的动态路由表

import {
         asyncRoutes, constantRoutes } from '@/router'
    
    // 校验用户是否具有进入该路由权限
    function hasPermission(roles, route) {
        
      if (route.meta && route.meta.roles) {
        
        return roles.some(role => route.meta.roles.includes(role))
      } else {
        
        return true
      }
    }
    
    // 递归过滤 asyncRoutes 路由中的 roles 可进入的路由
    export function filterAsyncRoutes(routes, roles) {
        
      const res = []
      
      routes.forEach(route => {
        
        const tmp = {
         ...route }
        if (hasPermission(roles, tmp)) {
        
          if (tmp.children) {
        
            tmp.children = filterAsyncRoutes(tmp.children, roles)
          }
          res.push(tmp)
        }
      })
      return res
    }
    
    // 全局保存动态路由
    const state = {
        
      routes: [],
      addRoutes: []
    }
    
    const mutations = {
        
      SET_ROUTES: (state, routes) => {
        
        state.addRoutes = routes
        state.routes = constantRoutes.concat(routes)
      }
    }
    
    // 根据用户权限生成动态路由表
    const actions = {
        
      generateRoutes({
          commit }, roles) {
        
        return new Promise(resolve => {
        
          let accessedRoutes
          if (roles.includes('admin')) {
        
            accessedRoutes = asyncRoutes || []
          } else {
        
            accessedRoutes = filterAsyncRoutes(asyncRoutes, roles)
          }
          commit('SET_ROUTES', accessedRoutes)
          resolve(accessedRoutes)
        })
      }
    }
    
    export default {
        
      namespaced: true,
      state,
      mutations,
      actions
    }

添加完 `src/store/modules/permission.js` 动态路由生成方法之后，我们还要在vuex中注册permission模块，即在`src/store/index.js`文件中导入该文件才能使其生效

import Vue from 'vue'
    import Vuex from 'vuex'
    import getters from './getters'
    import app from './modules/app'
    import settings from './modules/settings'
    import user from './modules/user'
    import permission from './modules/permission'            // 1. 引入 permission.js
    
    Vue.use(Vuex)
    const state = {
        
      isPractice: false
    }
    
    const store = new Vuex.Store({
        
      modules: {
        
        app,
        settings,
        user,
        permission                                           // 2. 注册 permission
      },
      state,
      getters
    })
    
    export default store

最后还要修改 `src/store/getters.js` 将 `permission.js` 生成的动态路由设置到state中，并存储为全局变量

const getters = {
        
      sidebar: state => state.app.sidebar,
      device: state => state.app.device,
      token: state => state.user.token,
      avatar: state => state.user.avatar,
      name: state => state.user.name,
      roles: state => state.user.roles,
      permission_routes: state => state.permission.routes   // 3. 动态路由表全局存储
    }
    export default getters

#### 2.4 挂载用户可访问动态路由表 ####

修改 `src/permission.js` 通过 `router.addRoutes` 将用户可访问路由表动态挂载到 `router` 上

import router from './router'
    import store from './store'
    import {
         Message } from 'element-ui'
    import NProgress from 'nprogress' 
    import 'nprogress/nprogress.css' 
    import {
         getToken } from '@/utils/auth'
    import getPageTitle from '@/utils/get-page-title'
    
    NProgress.configure({
         showSpinner: false })
    
    const whiteList = ['/login']
    
    router.beforeEach(async(to, from, next) => {
        
    
      NProgress.start()
      document.title = getPageTitle(to.meta.title)
      const hasToken = getToken()
    
      if (hasToken) {
        
        if (to.path === '/login') {
        
          next({
         path: '/' })
          NProgress.done()
        } else {
        
          const hasRoles = store.getters.roles && store.getters.roles.length > 0 // 1. 根据用户是否具有权限列表，判断用户时候已经登录
          if (hasRoles) {
        
            next()
          } else {
        
            try {
        
            
              const {
         roles } = await store.dispatch('user/getInfo')          // 2. 首次登录从用户信息中获取用户权限列表
              const accessRoutes = await store.dispatch('permission/generateRoutes', roles)   // 3. 根据用户权限列表生成用户可访问动态路由表
              router.addRoutes(accessRoutes)                    // 4. 将用户动态路由表挂载到 router
              
              next({
         ...to, replace: true })
            } catch (error) {
        
              await store.dispatch('user/resetToken')
              Message.error(error || 'Has Error')
              next(`/login?redirect=${
          to.path}`)
              NProgress.done()
            }
          }
        }
      } else {
        
        /* has no token*/
        if (whiteList.indexOf(to.path) !== -1) {
        
          next()
        } else {
        
          next(`/login?redirect=${
          to.path}`)
          NProgress.done()
        }
      }
    })
    
    router.afterEach(() => {
        
      NProgress.done()
    })

### 03 发现 Bug ###

经过上面这几个过程，最后挂载上动态路由表，到这似乎已经大功告成了。

但是就是无法渲染出侧边栏，即使在 `src/permission.js` 中 `console.log(router)` 可以输出根据用户权限过滤的动态路由。

可以输出路由，说明前面的修改没有问题，已经成功根据用户权限列表生成动态路由表。

可以想到的是，生成的动态路由表并没有被侧边栏使用。

查看侧边栏组件src/layout/components/Sidebar/index.vue，可以看到用于呈现菜单的 标签中使用的数据来源是 ，我们在前面整了半天生成的 permission\_routes 动态路由并没有被使用。

### 04 解决 Bug：修改侧边栏生成数据来源 ###

我们在前面整了半天生成的 `permission_routes` 动态路由并没有被使用，所以要修改侧边栏生成数据来源

<template>
      <div :class="{'has-logo':showLogo}">
        <logo v-if="showLogo" :collapse="isCollapse" />
        <el-scrollbar wrap-class="scrollbar-wrapper">
          <el-menu
            :default-active="activeMenu"
            :collapse="isCollapse"
            :background-color="variables.menuBg"
            :text-color="variables.menuText"
            :unique-opened="false"
            :active-text-color="variables.menuActiveText"
            :collapse-transition="false"
            mode="vertical"
          >
          	// 1. 修改侧边栏生成数据来源 route in permission_route
            <sidebar-item v-for="route in permission_routes" :key="route.path" :item="route" :base-path="route.path" />   
          </el-menu>
        </el-scrollbar>
      </div>
    </template>
    
    <script>
    import {
         mapGetters } from 'vuex'
    import Logo from './Logo'
    import SidebarItem from './SidebarItem'
    import variables from '@/styles/variables.scss'
    
    export default {
        
      components: {
         SidebarItem, Logo },
      computed: {
        
        ...mapGetters([
          'sidebar',
          'permission_routes'  // 2. 使用 permission_routes 数据源
        ]),
        routes() {
        
          console.log(this.$router.options.routes)
          return this.$router.options.routes
        },
        activeMenu() {
        
          const route = this.$route
          const {
         meta, path } = route
          if (meta.activeMenu) {
        
            return meta.activeMenu
          }
          return path
        },
        showLogo() {
        
          return this.$store.state.settings.sidebarLogo
        },
        variables() {
        
          return variables
        },
        isCollapse() {
        
          return !this.sidebar.opened
        }
      }
    }
    </script>

[image-20221130145900657]: https://img-blog.csdnimg.cn/img_convert/e999581844d0d62c2309da7e5ae3a3e5.png
[image-20221130145827414]: https://img-blog.csdnimg.cn/img_convert/67cd568a09ad62bc667fdf053dce2b9c.png
[https_blog.csdn.net_qq_41773806_article_details_121407661]: https://blog.csdn.net/qq_41773806/article/details/121407661