詳解基於vue，vue-router, vuex以及addRoutes進行權限控制

基於vuex, vue-router,vuex的權限控制教程，完整代碼地址見 https://github.com/linrunzhen...

接下來讓咱們模擬一個普通用戶打開網站的過程，一步一步的走完整個流程。

首先從打開本地的服務localhost:8080開始，咱們知道打開後會進入login頁面，那麼判斷的依據是什麼。
首先是token。
沒有登錄的用戶是獲取不到token的，而登錄後的角色咱們會將token存到local或者seesionStorage 所以，根據當前有沒有token便可知道是否登錄。

爲了存取token而且方便咱們操做，能夠配和vuex實現

/* state.js */
export default {
    get UserToken() {
        return localStorage.getItem('token')
    },
    set UserToken(value) {
        localStorage.setItem('token', value)
    }
}
/* mutation.js */
export default {
    LOGIN_IN(state, token) {
        state.UserToken = token
    },
    LOGIN_OUT(state) {
        state.UserToken = ''
    }
}

攔截的判斷

1. 沒有token進入須要權限的頁面：redirect到login頁面
2. 因爲咱們路由是動態掛載的，包括 ' ' 和404，因此當匹配不到路由時，也重定向到login

router.beforeEach((to, from, next) => {
    if (!store.state.UserToken) {
        if (
            to.matched.length > 0 &&
            !to.matched.some(record => record.meta.requiresAuth)
        ) {
            next()
        } else {
            next({ path: '/login' })
        }
    } 
})

好了，此時用戶打開localhost:8080,默認匹配的是''路徑，此時咱們並無掛載路由，也沒有token，因此來到了login。

輸入用戶名密碼後，有token了，經過store觸發 commit('LOGIN_IN') 來設置token。

可是仍是沒有路由，目前最開始只有login路由

/* 初始路由 */
export default new Router({
    routes: [
        {
            path: '/login',
            component: Login
        }
    ]
})

/* 準備動態添加的路由 */
export const DynamicRoutes = [
    {
        path: '',
        component: Layout,
        name: 'container',
        redirect: 'home',
        meta: {
            requiresAuth: true,
            name: '首頁'
        },
        children: [
            {
                path: 'home',
                component: Home,
                name: 'home',
                meta: {
                    name: '首頁'
                }
            }
        ]
    },
    {
        path: '/403',
        component: Forbidden
    },
    {
        path: '*',
        component: NotFound
    }
]

咱們要根據當前用戶的token去後臺獲取權限。

因爲權限這塊邏輯還挺多，因此在vuex添加了一個permission模塊來處理權限。

爲了判斷是已有路由列表，須要在vuex的permission模塊存一個state狀態permissionList用來判斷,假如permissionList不爲null，即已經有路由，若是不存在，就須要咱們幹活了。

router.beforeEach((to, from, next) => {
    if (!store.state.UserToken) {
        ...
    } else {
        /* 如今有token了 */
        if (!store.state.permission.permissionList) {
            /* 若是沒有permissionList，真正的工做開始了 */
            store.dispatch('permission/FETCH_PERMISSION').then(() => {
                next({ path: to.path })
            })
        } else {
            if (to.path !== '/login') {
                next()
            } else {
                next(from.fullPath)
            }
        }
    }
})

來看一下 store.dispatch('permission/FETCH_PERMISSION') 都幹了什麼

actions: {
    async FETCH_PERMISSION({ commit, state }) {
       /*  獲取後臺給的權限數組 */
        let permissionList = await fetchPermission()

        /*  根據後臺權限跟咱們定義好的權限對比，篩選出對應的路由並加入到path=''的children */
        let routes = recursionRouter(permissionList, dynamicRouter)
        let MainContainer = DynamicRoutes.find(v => v.path === '')
        let children = MainContainer.children
        children.push(...routes)

        /* 生成左側導航菜單 */
        commit('SET_MENU', children)

        setDefaultRoute([MainContainer])

        /*  初始路由 */
        let initialRoutes = router.options.routes

        /*  動態添加路由 */
        router.addRoutes(DynamicRoutes)

        /* 完整的路由表 */
        commit('SET_PERMISSION', [...initialRoutes, ...DynamicRoutes])
    }
}

首先,await fetchPermission()獲取後臺給的權限數組，格式大概以下

{
    "code": 0,
    "message": "獲取權限成功",
    "data": [
        {
            "name": "訂單管理",
            "children": [
                {
                    "name": "訂單列表"
                },
                {
                    "name": "生產管理",
                    "children": [
                        {
                            "name": "生產列表"
                        }                     
                    ]
                },
                {
                    "name": "退貨管理"
                }
            ]
        }
    ]
}

其次根據咱們寫好的路由數組，進行對比，過濾獲得咱們要的路由

/* 這裏是咱們寫好的須要權限判斷的路由 */
const dynamicRoutes = [
    {
        path: '/order',
        component: Order,
        name: 'order-manage',
        meta: {
            name: '訂單管理'
        },
        children: [
            {
                path: 'list',
                name: 'order-list',
                component: OrderList,
                meta: {
                    name: '訂單列表'
                }
            },
            {
                path: 'product',
                name: 'product-manage',
                component: ProductManage,
                meta: {
                    name: '生產管理'
                },
                children: [
                    {
                        path: 'list',
                        name: 'product-list',
                        component: ProductionList,
                        meta: {
                            name: '生產列表'
                        }
                    },
                    {
                        path: 'review',
                        name: 'review-manage',
                        component: ReviewManage,
                        meta: {
                            name: '審覈管理'
                        }
                    }
                ]
            },
            {
                path: 'returnGoods',
                name: 'return-goods',
                component: ReturnGoods,
                meta: {
                    name: '退貨管理'
                }
            }
        ]
    }
]

export default dynamicRoutes

爲了對比，我寫好了一個遞歸函數，用name和meta.name進行對比 ，根據這個函數就能夠獲得咱們想要的結果

/**
 *
 * @param  {Array} userRouter 後臺返回的用戶權限json
 * @param  {Array} allRouter  前端配置好的全部動態路由的集合
 * @return {Array} realRoutes 過濾後的路由
 */

export function recursionRouter(userRouter = [], allRouter = []) {
    var realRoutes = []
    allRouter.forEach((v, i) => {
        userRouter.forEach((item, index) => {
            if (item.name === v.meta.name) {
                if (item.children && item.children.length > 0) {
                    v.children = recursionRouter(item.children, v.children)
                }
                realRoutes.push(v)
            }
        })
    })
    return realRoutes
}

獲得過濾後的數組後，加入到path爲''的children下面

{
        path: '',
        component: Layout,
        name: 'container',
        redirect: 'home',
        meta: {
            requiresAuth: true,
            name: '首頁'
        },
        children: [
            {
                path: 'home',
                component: Home,
                name: 'home',
                meta: {
                    name: '首頁'
                }
            },
            <!-- 將上面獲得的東西加入到這裏 -->
            ...
        ]
    }

這個時候,path爲''的children就是咱們左側的導航菜單了，存到state的sidebarMenu待用。加入到children後，這時DynamicRoutes就能夠加入到路由了。

/*  動態添加路由 */
router.addRoutes(DynamicRoutes)


 /*  初始路由 */
let initialRoutes = router.options.routes
/* 合併起來，就是完整的路由了 */
commit('SET_PERMISSION', [...initialRoutes, ...DynamicRoutes])

路由添加完了，也就是action操做完畢了，便可在action.then裏面調用 next({ path: to.path })進去路由，這裏要注意, next裏面要傳參數即要進入的頁面的路由信息，由於next傳參數後，當前要進入的路由會被廢止，轉而進入參數對應的路由，雖然是同一個路由，這麼作主要是爲了確保addRoutes生效了。

進入路由後，要開始生成左側菜單，以前咱們已經存到sidebarMenu了，如今須要作的只是遞歸生成菜單而已，雖然用了element的導航菜單，可是爲了遞歸路由，還須要本身封裝一下。這裏核心的地方是組件的name，在組件裏面有children的地方，又再次使用本身，從而遍歷整個tree結構的路由。

<template>
    <div class="menu-container">
        <template v-for="v in menuList">
            <el-submenu :index="v.name" v-if="v.children&&v.children.length>0" :key="v.name">
                <template slot="title">
                    <i class="iconfont icon-home"></i>
                    <span>{{v.meta.name}}</span>
                </template>
                <el-menu-item-group>
                    <my-nav :menuList="v.children"></my-nav>
                </el-menu-item-group>
            </el-submenu>
            <el-menu-item :key="v.name" :index="v.name" @click="gotoRoute(v.name)" v-else>
                <i class="iconfont icon-home"></i>
                <span slot="title">{{v.meta.name}}</span>
            </el-menu-item>
        </template>
    </div>
</template>

<script>
export default {
    name: 'my-nav',
    props: {
        menuList: {
            type: Array,
            default: function() {
                return []
            }
        }
    },
    methods: {
        gotoRoute(name) {
            this.$router.push({ name })
        }
    }
}
</script>

刷新頁面後，根據咱們router.beforeEach的判斷，有token可是沒permissionList，咱們是會從新觸發action去獲取路由的，因此無需擔憂。可是導航菜單active效果會不見。不過咱們已經把el-menu-item的key設置爲路由的name，那麼咱們只要在刷新後，在afterEach把當前路由的name賦值給el-menu default-active便可。同理，在afterEach階段獲取全部matched的路由，便可實現麪包屑導航。

if (!store.state.permission.permissionList) {
    store.dispatch('permission/FETCH_PERMISSION').then(() => {
        next({ path: to.path })
    })
} 



...
router.afterEach((to, from, next) => {
    var routerList = to.matched
    store.commit('setCrumbList', routerList)
    store.commit('permission/SET_CURRENT_MENU', to.name)
})

退出登錄後，須要刷新頁面，由於咱們是經過addRoutes添加的，router沒有deleteRoutes這個api，因此清除token,清除permissionList等信息，刷新頁面是最保險的。

最後還有一點，每次請求得帶上token, 能夠對axios封裝一下來處理

var instance = axios.create({
    timeout: 30000,
    baseURL
})

// 添加請求攔截器
instance.interceptors.request.use(
    function(config) {
        // 請求頭添加token
        if (store.state.UserToken) {
            config.headers.Authorization = store.state.UserToken
        }
        return config
    },
    function(error) {
        return Promise.reject(error)
    }
)

/* axios請求二次封裝 */
instance.get = function(url, data, options) {
    return new Promise((resolve, reject) => {
        axios
            .get(url, data, options)
            .then(
                res => {
                    var response = res.data
                    if (response.code === 0) {
                        resolve(response.data)
                    } else {
                        Message.warning(response.message)
                        /* reject(response.message) */
                    }
                },
                error => {
                    if (error.response.status === 401) {
                        Message.warning({
                            message: '登錄超時,請從新登陸'
                        })
                        store.commit('LOGIN_OUT')
                        window.location.reload()
                    } else {
                        Message.error({
                            message: '系統異常'
                        })
                    }
                    reject(error)
                }
            )
            .catch(e => {
                console.log(e)
            })
    })
}

export default instance