路由处理逻辑分析

路由处理逻辑图如下：

路由场景分析

中后台路由常见的常见如下：

已获取 Token：
访问 /login：重定向到 /
访问 /login?redirect=/xxx：重定向到 /xxx
访问 /login 以外的路由：直接访问 /xxx
未获取 Token：
访问 /login：直接访问 /login
访问 /login 以外的路由：如访问 /dashboard，实际访问路径为 /login?redirect=%2Fdashboard，登录后会直接重定向 /dashboard

路由逻辑源码

第一步，main.js 中加载了全局路由守卫

import './permission' // permission control

第二步，permission.js 定义了全局路由守卫

import router from './router'
import store from './store'
import { Message } from 'element-ui'
import NProgress from 'nprogress' // progress bar
import 'nprogress/nprogress.css' // progress bar style
import { getToken } from '@/utils/auth' // get token from cookie
import getPageTitle from '@/utils/get-page-title'

NProgress.configure({ showSpinner: false }) // 设置为true时，右上角在页面加载过程中会有转圈圈的加载动画

const whiteList = ['/login', '/auth-redirect'] // 白名单

router.beforeEach(async(to, from, next) => {


  //开始progress bar加载动画
  NProgress.start()

  //设置页面题目
  document.title = getPageTitle(to.meta.title)

  //判断cookies中是否有token
  const hasToken = getToken()

  if (hasToken) {
    if (to.path === '/login') {
      // 如果当前路径为 login 则直接重定向至首页
      next({ path: '/' })
      NProgress.done() 
    } else {
       判断用户的角色是否存在
      const hasRoles = store.getters.roles && store.getters.roles.length > 0
      // 如果用户角色存在，则直接访问
      if (hasRoles) {
        next()
      } else {
        try {
         // 异步获取用户的角色
          // note: roles must be a object array! such as: ['admin'] or ,['developer','editor']
          const { roles } = await store.dispatch('user/getInfo')

          // 根据用户角色，动态生成路由
          const accessRoutes = await store.dispatch('permission/generateRoutes', roles)

         // 调用 router.addRoutes 动态添加路由
          router.addRoutes(accessRoutes)

       // 使用 replace 访问路由，不会在 history 中留下记录
          next({ ...to, replace: true })
        } catch (error) {
          // 移除 Token 数据
          await store.dispatch('user/resetToken')
           // 显示错误提示
          Message.error(error || 'Has Error')
          // 重定向至登录页面
          next(`/login?redirect=${to.path}`)
          NProgress.done()
        }
      }
    }
  } else {
    /*如果token不存在*/

    if (whiteList.indexOf(to.path) !== -1) {
      // 在白名单中的直接跳到白名单页面
      next()
    } else {
      //如果访问的 URL 不在白名单中，则直接重定向到登录页面，并将访问的 URL 添加到 redirect 参数中
      next(`/login?redirect=${to.path}`)
      //停止进度条
      NProgress.done()
    }
  }
})

router.afterEach(() => {
 //停止进度条
  NProgress.done()
})

动态路由分析

动态路由流程图

动态路由生成逻辑如下图：

动态路由源码分析

  if (hasToken) {
    if (to.path === '/login') {
      // 如果当前路径为 login 则直接重定向至首页
      next({ path: '/' })
      NProgress.done() 
    } else {
       判断用户的角色是否存在
      const hasRoles = store.getters.roles && store.getters.roles.length > 0
      // 如果用户角色存在，则直接访问
      if (hasRoles) {
        console.log(111)
        next()
      } else {
        console.log(222)
        try {
         // 异步获取用户的角色
          // note: roles must be a object array! such as: ['admin'] or ,['developer','editor']
          const { roles } = await store.dispatch('user/getInfo')

          // 根据用户角色，动态生成路由
          const accessRoutes = await store.dispatch('permission/generateRoutes', roles)

         // 调用 router.addRoutes 动态添加路由
          router.addRoutes(accessRoutes)

       // 使用 replace 访问路由，不会在 history 中留下记录
          next({ ...to, replace: true })
        } catch (error) {
          // 移除 Token 数据
          await store.dispatch('user/resetToken')
           // 显示错误提示
          Message.error(error || 'Has Error')
          // 重定向至登录页面
          next(`/login?redirect=${to.path}`)
          NProgress.done()
        }
      }
    }
  }

在登陆页面，用户名和密码正确的情况下，hastoken是为true的，但是to.path的路径是"/"，所以走的是else路径，先获取角色，再根据角色生成动态路由，然后再走一遍这个流程，不过这次走的是 if (hasRoles) 。

也可以看出来是我们猜想的这样。

动态路由主要的就是为了侧边栏（自我觉得哈).主要看生成动态路由的源码吧
生成动态路由的源码位于 src/store/modules/permission.js 中generateRoutes 方法;

import { asyncRoutes, constantRoutes } from '@/router'

generateRoutes({ commit }, roles) {
  // 返回 Promise 对象
  return new Promise(resolve => {
    let accessedRoutes
    if (roles.includes('admin')) {
      // 如果角色中包含 admin，则直接跳过判断，直接将 asyncRoutes 全部返回
      accessedRoutes = asyncRoutes || []
    } else {
      // 如果角色中没有包含 admin，则调用 filterAsyncRoutes 过滤路由
      accessedRoutes = filterAsyncRoutes(asyncRoutes, roles)
    }
    // 将路由保存到 vuex 中
    commit('SET_ROUTES', accessedRoutes)
    resolve(accessedRoutes)
  })
}

SET_ROUTES 方法源码如下：

SET_ROUTES: (state, routes) => {
  // 将 routes 保存到 state 中的 addRoutes
  state.addRoutes = routes
  // 将 routes 集成到 src/router/index.js 的 constantRoutes 中
  state.routes = constantRoutes.concat(routes)
}

路由过滤的方法 filterAsyncRoutes 源码如下：

/**
 * @params routes - 异步加载的路由
 * @params roles - 用户的角色，数组形式
 */
export function filterAsyncRoutes(routes, roles) {
  const res = []

  // 遍历全部路由
  routes.forEach(route => {
    // 对路由进行浅拷贝，注意 children 不会拷贝，因为不需要对 children 进行判断，所以可以使用浅拷贝
    const tmp = { ...route }
    // 检查用户角色是否具备访问路由的权限
    if (hasPermission(roles, tmp)) {
      // 当路由具有访问权限时，判断路由是否具备 children 属性
      if (tmp.children) {
        // 当路由包含 children 时，对 children 迭代调用 filterAsyncRoutes 方法
        tmp.children = filterAsyncRoutes(tmp.children, roles)
      }
      // 当路由具有访问权限时，将 tmp 保存到 res 中
      res.push(tmp)
    }
  })

  return res
}

检查权限方法 hasPermission 源码如下：

function hasPermission(roles, route) {
  // 检查路由是否包含 meta 和 meta.roles 属性
  if (route.meta && route.meta.roles) {
    // 判断 route.meta.roles 中是否包含用户角色 roles 中的任何一个权限，如果包含则返回 true，否则为 false
    return roles.some(role => route.meta.roles.includes(role))
  } else {
    // 如果路由没有 meta 或 meta.roles 属性，则视为该路由不需要进行权限控制，所有用户对该路由都具有访问权限
    return true
  }
}