element-admin动态路由设置_vue-element-admin 动态路由

0 引言

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

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

admin

common

文章原文链接：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
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

同时要修改 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

1
2
3
4
5
6
7
8
9
10

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

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
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

添加完 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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

最后还要修改 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

1
2
3
4
5
6
7
8
9
10
11

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()
})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

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>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59