• Vue3动态路由（Vite+Vue3+TS+Mock）

    一、动态路由简介

    Vue通过路由进行页面管理，不同的路由绑定到不同的页面。一般来说，前端直接写好的路由为静态路由，在不修改代码的情况下，路由表是不会改变的。对于不需要动态改变路由表的网站，静态路由就已经足够了，但是当页面需要与权限进行绑定时，不同用户允许浏览的页面是不一样的，在这种情况下，静态路由就难以满足需求了。动态路由就是由后端根据场景生成的合适路由数据，前端获取此数据并进行解析，最后与固定不变的静态路由组合而成的路由。

    本文将基于Vite+Vue3+TypeScript构建的Vue项目与mock模拟的后端接口，简单介绍Vue的动态路由配置。

    此项目代码已上传至GitHub，链接如下：

    https://github.com/XMNHCAS/VueDynamicRoute

    二、创建Vite+Vue3+TS基础项目

    首先使用以下命令创建项目

    npm create vite 项目名 -- --template vue-ts

    在刚刚创建的项目的目录下执行以下命令，安装vue初始的node依赖包 

    npm i

    参考示例如下：

    项目创建完成后，在项目目录下执行以下命令，使用VSCode打开此项目。也可以直接在此目录下右键点击使用VSCode打开。

    Code .

    注意：使用VSCode编辑Vue+TS的项目，建议禁用Vetur，使用Volar插件。

    三、项目初始化及静态路由配置 

    3.1、安装需要的Node Module 

    接下来我们需要安装几个node模块：vue-router、axios和mock。其中vue-router是Vue的路由配置模块，axios是请求包，mock则是前端模拟api接口的包。

    可依次执行以下命令，或修改package.json文件之后直接npm i。

    安装vue-router和axios：

    npm i vue-router axios -S

    安装mockjs和vite-plugin-mock。由于本项目的mock主要用途仅为模拟后端数据接口，所以安装为开发依赖，若打包为生产环境则会失效。

    npm i mockjs vite-plugin-mock@2.9.8 -D

    ps. 目前vite-plugin-mock最新版本修改了配置选项，而且直接运行可能会报错，暂时建议使用2.9.8或2.9.8以下的版本，等待作者修复后再使用新版本。若需要使用最新版本，请移步至该项目的Github仓库（https://github.com/vbenjs/vite-plugin-mock），Issues中有解决报错的办法。

    3.2、创建需要的文件夹以及文件

    首先我们打开src文件夹下的components文件，删除HelloWorld.vue。打开App.vue，将文件内容修改为以下代码：

    1. <template>
    2.   <router-view>router-view>
    3. template>

    然后在src文件夹下分别创建router、utils、apis、views和mock文件夹，并在文件夹中创建如图所示的文件：

     

    3.3、配置vue-router

    /src/router/index.ts：此文件为路由配置文件，我们先在此创建初始的静态路由。

    1. import { RouteRecordRaw, createRouter, createWebHistory } from 'vue-router'
    2.  
    3. // 静态路由表
    4. const routes: Array<RouteRecordRaw> = [
    5.     {
    6.         // 路由重定向配置
    7.         path: '/',
    8.         redirect: '/Home'
    9.     }, {
    10.         path: '/Home',
    11.         component: () => import('../views/HomePage.vue')
    12.     }
    13. ]
    14.  
    15. // 路由对象
    16. const router = createRouter({
    17.     history: createWebHistory(),
    18.     routes
    19. })
    20.  
    21. export default router

    3.4、配置mock

    /src/mock/index.ts：此文件为mock模拟接口配置，我们先创建一个测试接口，返回一个Hello World

    1. import { MockMethod } from "vite-plugin-mock"
    2.  
    3. const mock: Array<MockMethod> = [
    4.     {
    5.         // 接口路径
    6.         url: '/api/test',
    7.         
    8.         // 接口方法
    9.         method: 'get',
    10.  
    11.         // 返回数据
    12.         response: () => {
    13.             return {
    14.                 status: 200,
    15.                 message: 'success',
    16.                 data: 'Hello World'
    17.             }
    18.         }
    19.     }
    20. ]
    21.  
    22. export default mock

    3.5、配置vite.config.ts

    要使用mock，我们还需要在vite.config.ts文件下对mock进行配置，让vite启动的同时启动mock服务。

    1. import { defineConfig } from 'vite'
    2. import vue from '@vitejs/plugin-vue'
    3. import { viteMockServe } from 'vite-plugin-mock'
    4.  
    5. // https://vitejs.dev/config/
    6. export default defineConfig({
    7.   plugins: [
    8.     vue(),
    9.     // mock服务
    10.     viteMockServe({
    11.       supportTs: false,
    12.       logger: false,
    13.       mockPath: "./src/mock/",
    14.     }),
    15.   ]
    16. })

    3.6、配置axios

    /src/utils/request.ts：此文件为axios配置文件，它将创建一个axios全局单例，由于本项目仅做最简单的演示，所以仅配置baseUrl，实际使用时可根据实际情况添加拦截器等功能。

    1. import axios from 'axios'
    2.  
    3. // axios对象
    4. const service = axios.create({
    5.     // axios请求基础URL
    6.     // 由于本项目使用mock + vite-plugin-mock启动的mock服务，默认使用的端口号与页面一致
    7.     baseURL: "http://localhost:5173",
    8.     timeout: 5000
    9. })
    10.  
    11. export default service

    /src/apis/index.ts：此文件为接口文件，接口统一放到此文件中。

    1. import req from '../utils/request'
    2.  
    3. /**
    4.  * 测试接口
    5.  */
    6.  
    7. // 测试用Hello World
    8. export const TestApi = () => req({ url: '/api/test', method: 'get' })

    3.7、首页代码

    /src/views/HomePage.vue：

    2.  
    3. <script lang="ts" setup>
    4. import { TestApi } from '../apis'
    5.  
    6. TestApi().then(res => console.log(res)).catch(err => console.log(err))
    7. script>

    3.8、配置main.ts

    1. import { createApp } from 'vue'
    2. import './style.css'
    3. import App from './App.vue'
    4. import router from './router'
    5.  
    6. const app = createApp(App)
    7.  
    8. // 启用路由
    9. app.use(router)
    10.  
    11. app.mount('#app')

    3.9、静态路由运行 

    使用此命令运行，vite3默认的运行端口为5173。 

    npm run dev

    运行结果如下所示：

    从右侧开发者工具中可以看出，我们模拟的test接口已经成功返回了数据，页面也正常根据路由跳转至Home页面。

    四、配置动态路由

    4.1、配置动态路由接口

    首先我们先在刚刚创建的mock接口文件（/src/mock/index.ts）中添加一个返回路由信息的路由接口，如下所示：

    1. import { MockMethod } from "vite-plugin-mock"
    2.  
    3. const mock: Array<MockMethod> = [
    4.     /**
    5.      * 测试接口
    6.      */
    7.     {
    8.         // 接口路径
    9.         url: '/api/test',
    10.  
    11.         // 接口方法
    12.         method: 'get',
    13.  
    14.         // 返回数据
    15.         response: () => {
    16.             return {
    17.                 status: 200,
    18.                 message: 'success',
    19.                 data: 'Hello World'
    20.             }
    21.         }
    22.     }, 
    23.     /**
    24.      * 路由数据接口
    25.      */
    26.     {
    27.         url: '/api/routes',
    28.         method: 'get',
    29.         response: () => {
    30.             // 路由
    31.             const routes = [
    32.                 {
    33.                     path: '/PageOne',
    34.                     name: 'PageOne',
    35.                     component: 'PageOne.vue'
    36.                 }, {
    37.                     path: '/PageTwo',
    38.                     name: 'PageTwo',
    39.                     component: 'PageTwo.vue'
    40.                 }, {
    41.                     path: '/PageThree',
    42.                     name: 'PageThree',
    43.                     component: 'PageThree.vue',
    44.                 }
    45.             ]
    46.  
    47.             return {
    48.                 status: 200,
    49.                 message: 'success',
    50.                 data: routes
    51.             }
    52.         }
    53.     }
    54. ]
    55.  
    56. export default mock

    此接口返回三个页面的路由，根据这个接口的数据，我们在views文件夹中创建这三个页面。 

     

    页面仅由一个h1标签组成，h1的内容为文件名。此外再加上一个按钮，用以跳转回Home页面。PageOne.vue代码如下：

    1. <template>
    2.     <h1>Page Oneh1>
    3.     <button @click="handleClick">Homebutton>
    4. template>
    5.  
    6. <script lang="ts" setup>
    7. import { useRouter } from 'vue-router';
    8.  
    9. const router = useRouter()
    10. const handleClick = () => router.push({ path: '/Home' })
    11. script>

    其余两个页面仅需修改h1标签的内容。

    4.2、安装并配置pinia

    我们的动态路由数据应由一个公共的地方进行管理，本文选用vue的状态管理器来实现这个功能。pinia是vue新一代的状态管理器，与vuex作用基本相同，但是功能比vuex更加强大。

    pinia官方文档：https://pinia.web3doc.top

    首先在项目目录下执行以下命令，安装pinia：

    npm i pinia -S

    安装完成后，创建store文件夹，并在此文件夹下创建index.ts文件。

     /src/store/index.ts：

    1. import { defineStore } from 'pinia'
    2.  
    3. // pinia状态管理器
    4. export const useStore = defineStore('myStore', {
    5.     state: () => {
    6.         return {}
    7.     },
    8.     getters: {},
    9.     actions: {}
    10. })

     完成基础配置后，需要在mian.ts中引入pinia，需要注意的是，pinia必须在vue-router之后引入。

    main.ts

    1. import { createApp } from 'vue'
    2. import './style.css'
    3. import App from './App.vue'
    4. import router from './router'
    5.  
    6. import { createPinia } from 'pinia'
    7. const pinia = createPinia()
    8.  
    9. const app = createApp(App)
    10.  
    11. // 启用路由
    12. app.use(router)
    13.  
    14. // 启用pinia
    15. app.use(pinia)
    16.  
    17. app.mount('#app')

    4.3、添加路由数据接口

    /src/apis/index.ts：

    1. import req from '../utils/request'
    2.  
    3. /**
    4.  * 测试接口
    5.  */
    6.  
    7. // 测试用Hello World
    8. export const TestApi = () => req({ url: '/api/test', method: 'get' })
    9.  
    10. /**
    11.  * 动态路由接口
    12.  */
    13. export const GetDynamicRoutes = () => req({ url: '/api/routes', method: 'get' })

    4.4、在pinia中添加配置项

    由于我们使用的pinia存储我们的路由数据，所以我们需要在pinia的state中添加一个路由项（RouteRecordRaw类型的数组routes）。

    我们在pinia的action中还需要添加一个根据路由数据加载动态路由的方法（addRoutes），路由数据和router对象由外部传入。外部传入router是为了避免循环调用router，毕竟需要进行加载动态路由的地方基本都有个router的示例对象，不过也可以直接在此方法里面直接调用router，并不影响结果，也不会报错。

    加载路由的思路很简单，首先解析外部传入的路由数据，根据路由的数据类型生成对应的路由表，并存储到pinia中，然后直接遍历这个pinia中的路由表，使用router.addRoute()方法将路由加载进去。router.addRoute()方法还支持传如两个参数，这是为了在指定位置的路由中插入children，这种情况下第一个参数是父级路由的name，第二个参数就是要添加的children路由对象。本文的项目并没有做多层级的路由，所以使用一个参数即可。

    vite使用动态路由，在动态导入组件的时候，需要注意不能将页面路径直接作为component导入，虽然开发环境一般是能正常加载，但是打包到生产环境的时候就会出错，所以我们需要添加以下代码：

    let modules = import.meta.glob("../views/Pages/*.vue")

    然后使用这个modules来配置组件：

    1. // 错误示例：components:()=>import(`../views/Pages/${m.component}`)
    2. // 正确示例如下：
    3. component: modules[`../views/Pages/${m.component}`],

    最终的pinia代码如下： 

     /src/store/index.ts：

    1. import { defineStore } from 'pinia'
    2. import { RouteRecordRaw } from 'vue-router'
    3.  
    4. let modules = import.meta.glob("../views/Pages/*.vue")
    5.  
    6. // pinia状态管理器
    7. export const useStore = defineStore('myStore', {
    8.     state: () => {
    9.         return {
    10.             // 路由表
    11.             routes: [] as Array<RouteRecordRaw>
    12.         }
    13.     },
    14.     getters: {},
    15.     actions: {
    16.         // 添加动态路由，并同步到状态管理器中
    17.         addRoutes(data: Array<any>, router: any) {
    18.             data.forEach(m => {
    19.                 this.routes.push({
    20.                     path: m.path,
    21.                     name: m.name,
    22.                     // 错误示例：components:()=>import(`../views/Pages/${m.component}`)
    23.                     // 正确示例如下：
    24.                     component: modules[`../views/Pages/${m.component}`],
    25.                 })
    26.             })
    27.  
    28.             this.routes.forEach(m => router.addRoute(m))
    29.         },
    30.     }
    31. })

    4.5、加载动态路由

    配置了路由接口和加载路由的方法，接下来我们就需要加载我们的动态路由了。

    思路也很简单，在我们的Home页面中调用路由的数据接口，在获取到数据之后调用加载的方法即可。为了验证我们的路由是否被加载成功，我们还需要添加三个路由对应的按钮，以便我们进行路由跳转。

    /src/views/HomePage.vue：

    1. <template>
    2.     <h1>Homeh1>
    3.     <div style="display: flex;gap:20px">
    4.         <button v-for="item in routes" @click="handleClick(item.path)"> {{ item.name }}button>
    5.     div>
    6. template>
    7.  
    8. <script lang="ts" setup>
    9. import { useStore } from "../store";
    10. import { TestApi, GetDynamicRoutes } from '../apis'
    11. import { useRouter } from 'vue-router'
    12. import { computed } from "@vue/reactivity";
    13. import { onMounted } from "vue";
    14.  
    15. const router = useRouter()
    16. const store = useStore()
    17.  
    18. // 动态路由表
    19. const routes = computed(() => store.routes)
    20.  
    21. // 路由按钮点击事件
    22. const handleClick = (path: string) => {
    23.     router.push({ path })
    24. }
    25.  
    26. onMounted(() => {
    27.     if (store.routes.length < 1) {
    28.         // 获取动态路由
    29.         GetDynamicRoutes().then(res => {
    30.             store.addRoutes(res.data.data, router)
    31.         })      
    32.     }
    33.  
    34.      // 测试接口
    35.      TestApi().then(res => console.log(res.data)).catch(err => console.log(err))
    36. })
    37. script>

    效果如下： 

    随便点击一个按钮，我们就能成功跳转到我们的动态路由了。

    4.6、配置路由守卫

    到这里，我们的动态路由已经加载成功了。不过其实我们还没有做完，这个动态路由还存在一个bug，假如我们刷新跳转后的页面，或者直接使用动态路由的路径进行跳转，就会出现以下情况：

    可以看到，这种情况下我们的动态路由失效了，页面没了。这是因为我们的路由和pinia在刷新之后都会被重置，而我们加载路由的方法是在Home页面被调用的，当我们直接跳转到动态加载出来的路径或者直接在这个路径刷新的时候，Home页面并没有被加载，也就是说我们的动态路由并没有被加载上去，自然这个动态的页面也就丢失了。

    解决方法有很多，举个例子，既然我们刷新丢了路由是因为Home页面没被加载，那我们把加载的方法直接写到必然会被调用的App.vue就可以了，这是个简单直接的方法。不过考虑到实际使用的时候，我们可能需要在路由跳转时进行鉴权操作，下面介绍另一种方法，使用路由守卫进行加载。

    其实路由守卫加载的思路也很简单，假如我们的页面请求路径不是某个指定的路径的时候，我们就在跳转之前先去查询状态管理器中是否存在我们的动态路由，或者该动态路由是否满足我们的跳转要求，如果不满足就请求接口并加载我们的动态路由，并在加载完成后再继续跳转操作。在本项目中，我们的固定页面是Home页面，所以只要我们跳转的不是Home页面，就查询pinia是否存在路由表，如果没有则请求接口获取路由并加载。代码示例如下：

    /src/router/index.ts：

    1. import { RouteRecordRaw, createRouter, createWebHistory } from 'vue-router'
    2. import { useStore } from "../store";
    3. import { GetDynamicRoutes } from '../apis'
    4.  
    5. // 静态路由表
    6. const routes: Array<RouteRecordRaw> = [
    7.     {
    8.         // 路由重定向配置
    9.         path: '/',
    10.         redirect: '/Home'
    11.     }, {
    12.         path: '/Home',
    13.         component: () => import('../views/HomePage.vue')
    14.     }
    15. ]
    16.  
    17. // 路由对象
    18. const router = createRouter({
    19.     history: createWebHistory(),
    20.     routes
    21. })
    22.  
    23. // 路由守卫
    24. router.beforeEach((to, from, next) => {
    25.     if (to.path !== '/Home' && to.path !== '/') {
    26.         const store = useStore()
    27.         if (store.routes.length < 1) {
    28.  
    29.             GetDynamicRoutes().then(res => {
    30.                 store.addRoutes(res.data.data, router)
    31.                 next({ path: to.path, replace: true })
    32.  
    33.             }).catch(_ => {
    34.                 next()
    35.             })
    36.  
    37.         } else {
    38.             next()
    39.         }
    40.     } else {
    41.         next()
    42.     }
    43. })
    44.  
    45. export default router

    现在我们直接访问我们的动态页面也能成功加载了。

    虽然能成功加载了，但是开发者工具那里还有一条报错：

    [Vue Router warn]: No match found for location with path "/PageOne"

    这是因为我们在路由跳转之前请求了一次接口进行加载，但是在完成路由加载之前，vue-router就直接先去找了这个路径，我们的路由都还没加载完成，当然也就找不到了，所以就会出这个警告。其实这个警告完全可以无视，不过我们最好还是处理一下，避免出现意外情况。

    解决方法也很简单，添加一个404页面就可以了。在views文件夹中添加一个Error文件夹，并在此文件夹中添加404.vue文件。

    1. <template>
    2.     <h1>404h1>
    3. template>

    然后在静态路由中添加一个错误的路由：

     /src/router/index.ts：

    1. import { RouteRecordRaw, createRouter, createWebHistory } from 'vue-router'
    2. import { useStore } from "../store";
    3. import { GetDynamicRoutes } from '../apis'
    4.  
    5. // 静态路由表
    6. const routes: Array<RouteRecordRaw> = [
    7.     {
    8.         // 路由重定向配置
    9.         path: '/',
    10.         redirect: '/Home'
    11.     }, {
    12.         path: '/Home',
    13.         component: () => import('../views/HomePage.vue')
    14.     }, {
    15.         // 404页面配置
    16.         path: '/:catchAll(.*)',
    17.         component: () => import('../views/Errors/404.vue')
    18.     }
    19. ]
    20.  
    21. // 路由对象
    22. const router = createRouter({
    23.     history: createWebHistory(),
    24.     routes
    25. })
    26.  
    27. // 路由守卫
    28. router.beforeEach((to, from, next) => {
    29.     if (to.path !== '/Home' && to.path !== '/') {
    30.         const store = useStore()
    31.         if (store.routes.length < 1) {
    32.  
    33.             GetDynamicRoutes().then(res => {
    34.                 store.addRoutes(res.data.data, router)
    35.                 next({ path: to.path, replace: true })
    36.  
    37.             }).catch(_ => {
    38.                 next()
    39.             })
    40.  
    41.         } else {
    42.             next()
    43.         }
    44.     } else {
    45.         next()
    46.     }
    47. })
    48.  
    49. export default router

     效果如下：

    五、结尾

    至此我们的动态路由就完成了，动态路由的实现方法有很多，本文介绍的也只是其中一种，也有很大的优化空间，这个就看需要参照实际需求了。

  • 相关阅读:
    鸿蒙开发实例 ｜ 分布式涂鸦
    【实验技术笔记】细胞表型检测之细胞凋亡（Hoechst染色 + PI染色 + TUNEL 染色 + Annexin V-PI 双染）
    CSS三种样式表、样式表优先级、CSS选择器
    细聊init进程和Linux系统启动流程
    微服务 第二章 CountDownLatch和Semaphone的应用
    EasyExcel实现动态表头功能
    TensorFlow实现基于卷积神经网络的频域重建MRI图像方法
    2023最新SSM计算机毕业设计选题大全（附源码+LW）之java慢性病个人管理系统466cs
    基于MATLAB开发AUTOSAR软件应用层模块-part10.AUTOSAR Dictionary-1
    Spring自动注入
  • 原文地址：https://blog.csdn.net/XUMENGCAS/article/details/128036487